精华内容
下载资源
问答
  • 链表ADT C语言实现

    千次阅读 2016-01-25 18:34:26
    链表ADT 自己打的单链表 希望代码对大家有帮助哈哈,很全。 基本实现了应该有的功能 1.判断链表是否为空 2.判断链表是否为满 3.节点数量 4.链表的遍历 5.链表节点的替换 6.链表节点的寻找 7.链表节点的插入 8.链表...

    链表ADT

    自己打的单链表

    希望代码对大家有帮助哈哈,很全。

    基本实现了应该有的功能

    1.判断链表是否为空

    2.判断链表是否为满

    3.节点数量

    4.链表的遍历

    5.链表节点的替换

    6.链表节点的寻找

    7.链表节点的插入

    8.链表节点的添加


    大笑
    #define true 1
    #define false 0
    #include <stdio.h>
    #include <stdlib.h>
    struct list 
      {int data;
       struct list * next; 
      }; 
    typedef struct list List;  
    int ListIsEmpty( List * head);
    unsigned int ListItemCount( List * head);
    void Traverse( List * head);
    void Replace( List **ptr,int a,List * target);
    List * SeekItem( List * head,int a);
    bool InsertItem( List *head,int a,List * target);
    int InsertHeadItem(List ** ptr,List * target);
    List * AddItem( List * head);
    int main(void)
    {
    }
    int ListIsEmpty( List * head)
    {
    	if(head==NULL)
    	return true;
    	else return false;
     } 
    unsigned int ListItemCount( List * head)
    {
    	unsigned int count=0;
    	List * p=head;
    	while(p!=NULL){
    		++count;
    		p=p->next;
    	}
    	return count;
    }
    void Traverse( List * head)
    {
    	int count = 0;
    	List * p=head;
    	while(p!=NULL){
    		++count;
    		printf("%d%10d\n",count,p->data);
    		p=p->next;
    	}
    }
    void Replace( List **ptr,int a,List * target)//Replace(ptr,a,target);List **ptr   为了能替换第一个节点 ,需要改变头指针的值 
    {
    	List * p=*ptr;
    	List * pr=p;
    	if(*ptr==NULL) {
    		printf("nothing!");
    		exit(0); 
    	}
    	while(p!=NULL&&p->data!=a){
    		pr=p;
    		p=p->next;
    	}
    	if(p==NULL){
    		printf("not found!");
    		exit(1);
    	}
    	
    	if(p!=NULL){
    		if(*ptr==p){
    			target->next=p->next;
    			*ptr=target;
    			free(p);
    		}
            else{
    		
    			target->next=p->next;
    		    pr->next=target;
    		    free(p);
             }
    		
    	}
    }
    	
    
    List * SeekItem( List * head,int a)
    {
    	int count=0;
    	List * p,* pr;
    	p=head;
    	pr=p;
    	if(head==NULL){
    		printf("nothing!");
    		exit(0);
    	}
    	while(p!=NULL){
    		count++;
    		pr=p;
    		if(p->data==a){
    			printf("find it , it's %d\n",count);
    			return p;
    		}
    		p=p->next;
    	}
    	if(p=NULL){
    		printf("not found!");
    		return NULL;
    	}
    }
    bool InsertItem( List * head,int a,List * target)
    {
    	List * p;
    	p=SeekItem(head,a);
    	if(p==NULL){
    		printf("not found !");
    		return false;
    	}
    	target->next=p->next;
    	p->next=target;
    	return true;
    }
    int InsertHeadItem(List ** ptr,List * target)
    {
    	target->next=*ptr;
    	*ptr=target;
    	return true;
    }
    List *AddItem( List * head)
    {
    	List * pr=head;
    	List * p=NULL;
    	p=(List *)malloc(sizeof(List));
    	if(p==NULL){
    		printf("can't' malloc!");
    		
    	}
    	p->next=NULL;
    	printf("please input data :");
    	scanf("%d",&p->data);
    	if(head==NULL){
    		head=p;
    		
    	}
    	else{
    	
          while(pr->next!=NULL){
    		pr=pr->next;
    		printf("text!\n");
    	  }
    	  pr->next=p;
    	  
        }
        Traverse(head);
    	return head;
    }
    

    原创 转载注明出处


    展开全文
  • 广义数据结构ADT实现代码,符合ADT要求,头文件放ADT函数接口定义和存储结构定义,cpp文件放实现,在控制台查看输出,C语言实现,功能多,注释多,轻松易懂,可用来初学或者作业完成
  • 哈希数据结构实现代码,符合ADT要求,头文件放ADT函数接口定义和存储结构定义,cpp文件放实现,在控制台查看输出,C语言实现,功能多,注释多,轻松易懂,可用来初学或者作业完成
  • 广义ADT实现

    2010-07-11 01:29:48
    严蔚敏数据结构设计性实验,抽象数据类型广义实现。包括广义的创建,删除结点,插入,计算原子个数,长度,深度,销毁广义等基本操作,C语言代码版
  • 表ADT

    2017-04-19 09:51:27
    表ADT(Abstract Data Type)

    表ADT(Abstract Data Type)

    形如 A0,A2,A3,,AN1 的一般的表,表的大小为 N ,大小为0的表为空表。
    除空表外的任何表,Ai Ai1 之后, Ai1 前驱 Ai 。表中的第一个元素 A0 ,最后一个元素 AN1 。元素 Ai 在表中的位置为 i <script type="math/tex" id="MathJax-Element-10">i</script>。
    与之相关的是定义要在表ADT上进行操作的集合。

    表的简单数组实现

    内部存储数组的vector类使得用数组实现表成为可能,因为这样就允许在需要的时候将数组的大小增加一倍。
    用数组数组实现表的合适情况是,表通过在末尾插入元素来建立,之后只有数组访问发生。如果插入和删除在整个表中都发生,数组就不是个好选择。

    简单链表

    链表由一系列不必在内存中相连的结点组成。每一个结点均含有表元素和到包含后继元素的结点的next链。最后一个结点的next链指向NULL。
    这里写图片描述
    这里写图片描述
    这里写图片描述
    为了方便删除最后一个结点,在链表中的每一个结点都添加一个指向上一项的链表,变成双向链表。
    这里写图片描述
    参考Mark Allen Weiss《数据结构与算法分析c++描述》第三版

    展开全文
  • 链表分很多种,有单链表、双链表、循环链表等,这里我以单链表为例,实现单链表的ADT。 单链表是一种最简单的链表表示,也叫作线性链表。用它来表示线性表时,用指针表示节点间的逻辑关系。因此单链表的一个存储...

            链表适用于插入或删除操作频繁,存储空间需求不定的情形。链表分很多种,有单链表、双链表、循环链表等,这里我以单链表为例,实现单链表的ADT。

            单链表是一种最简单的链表表示,也叫作线性链表。用它来表示线性表时,用指针表示节点间的逻辑关系。因此单链表的一个存储节点包含两部分:

                                             

           其中,data部分称为数据域,用于存储线性表中的一个数据元素,其数据类型由应用问题决定。link部分称为指针域或链域,用于存放一个指针,该指针表示该链表中下一个结点的开始存储地址。一个线性表的单链表结构如下图所示:

         

           其中,链表的第一个结点的地址可以通过链表的头指针first找到,其他结点的地址则在前驱节点的link域中,链表的最后一个结点没有后继,link内容为NULL。

           单链表的特点是长度可以很容易的扩充。链表的元素之间只在逻辑上相邻,在存储位置不一定相邻。                                     

    下面给出来链式表ADT的C++实现:

    一、顺序表的基本操作

    1.链表置空操作

    //链表置空
    void LinkList::MakeEmpty(){
        //删除列表中处表头节点外的其他所有节点
        LinkNode *q;
        while(first->link!=NULL){
            q = first->link;//将一个节点从链中“摘下”
            first->link = q->link;
            delete q;//释放
        }
    }

    2.求链表长度操作

    //求长度
    int LinkList::Length(){
        LinkNode *q = first;
        int Count = 0;
        while(q->link!=NULL){
            Count++;
            q = q->link;
        }
        return Count;
    }

    3.查找操作

    //查找
    LinkNode* LinkList::Search(T x){
        LinkNode *p = first->link;
        while(p!=NULL&&p->data!=x){
            p = p->link;
        }
        return p;
    }

    4.定位操作

    //定位
    LinkNode* LinkList::Locate(int i){
        LinkNode *p=first;
        int j=0;//j计数
        if(i<0) return NULL;
        while(p!=NULL&&j<i){
            p = p->link;
            j++;
        }
        return p;
    }

    5.插入操作

    //插入
    //找到第i-1个元素,使x成为其后继,其原来的后继成为x的后继
    bool LinkList::Insert(int i,T x){
        LinkNode *p = Locate(i-1);
        if(p==NULL){return false;}
        LinkNode *newnode = new LinkNode(x);
        if(newnode==NULL){
            cerr<<"内存分配错误!"<<endl;
            exit(1);
        }
        newnode->link = p->link;
        p->link = newnode;
    }

    6.删除操作

    //删除
    bool LinkList::Delete(int i,T x){
        LinkNode *p = Locate(i-1),*q;
        if(p==NULL||p->link==NULL){
            return false;
        }
        q = p->link;
        p->link = q->link;//重新链接
        x = q->data;
        delete q;
        return true;
    }

    7.输入操作

    //输入
    void LinkList::InputList(T EndTag){
        LinkNode *newnode,*r;
        T val;
        first == new LinkNode();//生成头结点
        if(first==NULL){cerr<<"存储分配错误!"<<endl;exit(1);}
        cout<<"请输入链表节点的元素:";
        cin>>val;//读入数据元素
        r = first;//r总是指向目前链表的最后一个结点
        while(val!=EndTag){
            newnode = new LinkNode(val);//申请空间,读入存储元素
            if(newnode==NULL){
                cerr<<"存储分配错误!"<<endl;
                exit(1);
            }
            r->link = newnode;//链接到最后面
            r = newnode;//刚链上的结点成为最后一个结点
            cin>>val;//读入数据元素
        }
        r->link = NULL;
    }

    8.输出操作

    void LinkList::PrintList(){
        LinkNode *p=first->link;
        while(p!=NULL){
            cout<<p->data<<endl;
            p = p->link;
        }
    }

    二、完整的ADT和函数操作

    1.数据结构的定义和基本操作函数的声明

    /*
    链式表ADT
    */
    
    #include <iostream>
    #include <stdlib.h>
    #include <cstdlib>
    using namespace std;
    
    typedef int T;
    class LinkList;//前视定义,否则友元类无法定义
    class LinkNode{//链表节点类的定义
        friend class LinkList;
    public:
        LinkNode *link;
        T data;
    public:
        LinkNode(LinkNode *ptr=NULL){link=ptr;}
        LinkNode(T &item,LinkNode *ptr=NULL){
            data = item;
            link = ptr;
        }
        ~LinkNode(){};
    };
    
    class LinkList{
    public:
        LinkNode *first;//指向链表头的指针
    public:
        LinkList(){first = new LinkNode();}//带头节点的构造函数
        LinkList(T &x){//不带头节点的构造函数
            first = new LinkNode(x);
        }
        ~LinkList(){MakeEmpty();delete first;}//析构函数
        void MakeEmpty();//链表置空
        int Length();//求链表长度
        LinkNode* GetHead(){return first;}
        LinkNode* Search(T x);
        T GetData(int i);//返回第i个元素的值
        LinkNode* Locate(int i);//返回第i个元素的地址(指针)
        bool Insert(int i,T x);//在第i个元素后插入元素x
        bool Delete(int i,T x);//删除第i个元素
        int IsEmpty(){return (first->link==NULL?1:0);}
        void InputList(T x);//建立链表,x是输入结束的标志
        void PrintList();//打印链表
    };

    2.操作函数的具体实现

    //链表置空
    void LinkList::MakeEmpty(){
        //删除列表中处表头节点外的其他所有节点
        LinkNode *q;
        while(first->link!=NULL){
            q = first->link;//将一个节点从链中“摘下”
            first->link = q->link;
            delete q;//释放
        }
    }
    
    //求长度
    int LinkList::Length(){
        LinkNode *q = first;
        int Count = 0;
        while(q->link!=NULL){
            Count++;
            q = q->link;
        }
        return Count;
    }
    
    //查找
    LinkNode* LinkList::Search(T x){
        LinkNode *p = first->link;
        while(p!=NULL&&p->data!=x){
            p = p->link;
        }
        return p;
    }
    
    //定位
    LinkNode* LinkList::Locate(int i){
        LinkNode *p=first;
        int j=0;//j计数
        if(i<0) return NULL;
        while(p!=NULL&&j<i){
            p = p->link;
            j++;
        }
        return p;
    }
    
    //插入
    //找到第i-1个元素,使x成为其后继,其原来的后继成为x的后继
    bool LinkList::Insert(int i,T x){
        LinkNode *p = Locate(i-1);
        if(p==NULL){return false;}
        LinkNode *newnode = new LinkNode(x);
        if(newnode==NULL){
            cerr<<"内存分配错误!"<<endl;
            exit(1);
        }
        newnode->link = p->link;
        p->link = newnode;
    }
    
    //删除
    bool LinkList::Delete(int i,T x){
        LinkNode *p = Locate(i-1),*q;
        if(p==NULL||p->link==NULL){
            return false;
        }
        q = p->link;
        p->link = q->link;//重新链接
        x = q->data;
        delete q;
        return true;
    }
    
    //输入
    void LinkList::InputList(T EndTag){
        LinkNode *newnode,*r;
        T val;
        first == new LinkNode();//生成头结点
        if(first==NULL){cerr<<"存储分配错误!"<<endl;exit(1);}
        cout<<"请输入链表节点的元素:";
        cin>>val;//读入数据元素
        r = first;//r总是指向目前链表的最后一个结点
        while(val!=EndTag){
            newnode = new LinkNode(val);//申请空间,读入存储元素
            if(newnode==NULL){
                cerr<<"存储分配错误!"<<endl;
                exit(1);
            }
            r->link = newnode;//链接到最后面
            r = newnode;//刚链上的结点成为最后一个结点
            cin>>val;//读入数据元素
        }
        r->link = NULL;
    }
    
    void LinkList::PrintList(){
        LinkNode *p=first->link;
        while(p!=NULL){
            cout<<p->data<<endl;
            p = p->link;
        }
    }

     

    展开全文
  • /* description:judge whether the linklist is empty or not */ template<class ElemType> bool LinkList<ElemType>::ListEmpty() const { if(head->next) { return false;...}
  • 数据结构:顺序表ADT实现

    千次阅读 2019-09-23 17:56:27
    下面给出顺序表ADT的C++实现: 一、顺序的基本操作 1.构造函数 通过指定sz,定义数组的长度。 LinearList::LinearList(int sz){ //构造函数,通过指定size,定义数组长度 if(sz>0){ data = new T...

           线性结构是简单且常用的数据结构,而线性表是一种典型的数据结构。

           一般情况下,如果需要在程序中存储数据,最简单、最有效的方法是把它们存放在线性表中。只有当需要组织和搜索大量数据时,才会考虑使用更复杂的数据结构。

           在所有的数据结构中,最简单的是线性表。通常,定义线性表为n(n>=0)个数据元素的一个有限的序列。记为:

                                                      L = (a(1),···,a(i),a(i+1),···,a(n))

           其中,L是表名,a(i)是数据元素,是不可再分割的原子数据,亦成为结点或表项。

           线性表是一个有限序列,意味着表中的各个结点是相继排列的,且每两个相邻结点之间有直接前驱和直接后继的关系;线性表中存在惟一的第一个结点和最后一个结点,第一个结点没有前驱,最后一个结点没有后继,每个结点至多只有一个直接前驱并且至多只有一个直接后继。

           线性表的存储表示有两种:顺序存储方式和链表存储方式。用顺序存储方式实现的线性表称为顺序表,是用数组作为表的存储结构的。这里我们讲顺序表。

           顺序表的定义:把线性表中的所有结点按照其逻辑顺序依次存储到从计算机存储中指定存储位置开始的一块连续存储空间中。

           特点:(1)在 顺序表中各个结点的逻辑顺序与其存放的物理顺序一致,即第i个结点存储于第i个物理位置(1<=i<=n)。

                      (2)对顺序表中所有结点,既可以进行顺序访问,也可以进行随机访问。也就是时候,既可以从表的第一个结点开始                               逐个访问,也可以按照结点序号直接访问。

    下面给出顺序表ADT的C++实现:

    一、顺序表的基本操作

    1.构造函数

    通过指定sz,定义数组的长度。

    LinearList::LinearList(int sz){
        //构造函数,通过指定size,定义数组长度
        if(sz>0){
            data = new T[sz];//分配连续空间
            if(data!=NULL){//分配成功
                MaxSize = sz;
                last = -1;
            }
            else{
                cerr<<"存储分配错误!"<<endl;
                exit(0);
            }
        }
    }

    2.查找指定元素

    这里在表中从前向后顺序查找。

    int LinearList::Search(T &x) const{
        //搜索函数:在表中从前向后顺序查找x
        int i = 0;//起始位置
        while(i<=last&&data[i]!=x){
            i++;
        }
        if(i>last){
            return -1;//没找到
        }
        else{
            return i+1;//找到
        }
    }

    3.插入操作

           顺序表的插入操作比较简单,假设顺序表最后一个元素的下标是last,被插入的元素是x,要插入到下标为i的位置,只需要将原顺序表中下标为i到last的结点往后顺移一位,然后再将x插入下标为i的位置即可。

    void LinearList::Insert(int i,T &x){
        //i为下标,不是序号
        if(last==MaxSize-1){
            cerr<<"顺序表已满无法插入!"<<endl;
            exit(1);
        }
        if(i<0||i>last+1){
            cerr<<"参数i越界出错!"<<endl;
            exit(1);
        }
    
        last++;
        for(int j=last;j>i;j--){//移动元素
            data[j] = data[j-1];
        }
        data[i] = x;//在第i项处插入x
        cout<<"插入成功!"<<endl;
    }

    4.删除操作

            删除操作的思想和插入操作相似,假设线性表最后一个元素的下标为last,要删除下标为i的元素,只需要将下标为i+1到last的结点往前顺移一位即可。

    //删除下标为i的元素
    int LinearList::Delete(int i){
        if(i<0||i>last){
            cerr<<"参数i越界出错!"<<endl;
            exit(1);
        }
        if(i>=0){
            last--;//表长度-1
            for(int j=i;j<=last;j++){//向前移动元素
                data[j] = data[j+1];
            }
            cout<<"删除成功!"<<endl;
            return 1;//删除成功
        }
    }

    5.获取元素x之前的元素

    //获取x元素之前的元素
    T LinearList::GetPrior(T &x){
        if(Length()==0){
            cout<<"表已空!"<<endl;
            return 404;
        }
        else if(data[0]==x){
            cout<<"该元素是线性表第一个元素,没有前驱元素!"<<endl;
            return 404;
    
        }
        else if(Search(x)!=-1){
            return data[Search(x)-2];
        }
    }

    6.获得元素x的下标

    T LinearList::GetNext(T &x){
        if(Length()==0){
            cout<<"表已空!"<<endl;
            return 404;
        }
        else if(data[last]==x){
            cout<<"该元素是顺序表的最后一个元素,没有后继元素!"<<endl;
            return 404;
        }
        else if(Search(x)!=-1){
            return Search(x);
        }
    }
    

    7.打印顺序表

    void LinearList::PrintList(){
        for(int i=0;i<=last;i++){
            cout<<data[i]<<" "<<endl;
        }
        cout<<endl;
    }

    8.清空顺序表(利用析构函数)

    ~LinearList(){delete[] data;}

    9.求顺序表长度操作

    //返回线性表中元素的个数
    int Length() const {return last+1;}

    二、完整的ADT和函数操作

    1.数据结构的定义和基本操作函数的声明

    /*
    顺序表ADT
    */
    #include <iostream>
    #include <cstdlib>
    using namespace std;
    
    typedef double T;
    
    class LinearList{
    public:
        int last;
        int LinearListLength;//线性表长度
        int MaxSize;//允许线性表最大的元素个数
        int LinearListLast;//线性表最后一个元素的下标
        T *data;//动态存储的数组存储顺序表
    public:
        LinearList(int sz);
        ~LinearList(){delete[] data;}
    
        //返回线性表中元素的个数
        int Length() const {return last+1;}
        //返回元素x在表中的位置
        int Search(T &x) const;
        //在位置i插入元素x
        void Insert(int i,T &x);
        //删除值为x的元素
        int Delete(int i);
        //表空否
        int IsEmpty(){return last==-1;}
        //判断是否满
        int IsFull(){return last==MaxSize-1;}
        //获得第i个元素
        T GetData(int i){return data[i-1];};
        //取值为x的前驱元素
        T GetPrior(T &x);
        //取值为x的后继元素
        T GetNext(T &x);
        //输出线性表
        void PrintList();
    };

    2.操作函数的具体实现

    LinearList::LinearList(int sz){
        //构造函数,通过指定size,定义数组长度
        if(sz>0){
            data = new T[sz];//分配连续空间
            if(data!=NULL){//分配成功
                MaxSize = sz;
                last = -1;
            }
            else{
                cerr<<"存储分配错误!"<<endl;
                exit(0);
            }
        }
    }
    
    int LinearList::Search(T &x) const{
        //搜索函数:在表中从前向后顺序查找x
        int i = 0;//起始位置
        while(i<=last&&data[i]!=x){
            i++;
        }
        if(i>last){
            return -1;//没找到
        }
        else{
            return i+1;//找到
        }
    }
    
    void LinearList::Insert(int i,T &x){
        //i为下标,不是序号
        if(last==MaxSize-1){
            cerr<<"顺序表已满无法插入!"<<endl;
            exit(1);
        }
        if(i<0||i>last+1){
            cerr<<"参数i越界出错!"<<endl;
            exit(1);
        }
    
        last++;
        for(int j=last;j>i;j--){//移动元素
            data[j] = data[j-1];
        }
        data[i] = x;//在第i项处插入x
        cout<<"插入成功!"<<endl;
    }
    
    //删除下标为i的元素
    int LinearList::Delete(int i){
        if(i<0||i>last){
            cerr<<"参数i越界出错!"<<endl;
            exit(1);
        }
        if(i>=0){
            last--;//表长度-1
            for(int j=i;j<=last;j++){//向前移动元素
                data[j] = data[j+1];
            }
            cout<<"删除成功!"<<endl;
            return 1;//删除成功
        }
    }
    
    //获取x元素之前的元素
    T LinearList::GetPrior(T &x){
        if(Length()==0){
            cout<<"表已空!"<<endl;
            return 404;
        }
        else if(data[0]==x){
            cout<<"该元素是线性表第一个元素,没有前驱元素!"<<endl;
            return 404;
    
        }
        else if(Search(x)!=-1){
            return data[Search(x)-2];
        }
    }
    
    T LinearList::GetNext(T &x){
        if(Length()==0){
            cout<<"表已空!"<<endl;
            return 404;
        }
        else if(data[last]==x){
            cout<<"该元素是顺序表的最后一个元素,没有后继元素!"<<endl;
            return 404;
        }
        else if(Search(x)!=-1){
            return Search(x);
        }
    }
    
    void LinearList::PrintList(){
        for(int i=0;i<=last;i++){
            cout<<data[i]<<" "<<endl;
        }
        cout<<endl;
    }

     

    展开全文
  • 表ADT的两种实现

    2019-10-28 14:45:04
    的简单数组实现 对表的所有操作都可以通过数组来实现,它可以使得printList以线性时间被执行,而findKth操作则花费常数时间,不过,插入和删除的花费却潜藏着昂贵的开销,这取决于插入和删除发生在什么地方。 最坏...
  • 链表ADT数据结构代码

    2019-12-02 23:46:03
    链表ADT数据结构,符合ADT要求,头文件放函数结构和存储结构定义,cpp文件放实现,在控制台查看输出,C语言实现,轻松易懂,可用来初学或者作业完成
  • jsp无限级可分类的分类表ADT实现

    千次阅读 2007-09-26 12:05:00
    源码下载地址: http://www.javaall.com/resource/news.rar 本文的目的是利用数据结构: 树 ,来实现一个分类表ADT, 这个分类表ADT可以实现无限级分类 本例程采用Structs 架构, 符合MVC设计模式 数据库采用SQL ...
  • 表ADT1.1 什么是1.2 为什么需要1.3 怎么使用1.4 特点2. 链表2.1 什么是单向链表2.3 什么是双向链表2.2 为什么需要链表2.3 使用场景 1. 表ADT 1.1 什么是 形如A1, A2, …, An的的大小是n。大小为0的...
  • 简单实现string.h 完成字符串的操作实现 完成串ADT实现 加深数据结构的学习
  • 源码下载地址: http://www.javaall.com/resource/news.rar 本文的目的是利用数据结构: 树 ,来实现一个分类表ADT, 这个分类表ADT可以实现无限级分类 本例程采用Structs 架构, 符合MVC设计模式 数据库采用SQL ...
  • 单链表ADT实现

    千次阅读 2018-10-29 00:13:48
    单链表的实现: 链表使用: 单链表的定义: LinkedList.h文件 #ifndef LINKEDLIST_H_ #define LINKEDLIST_H_ #include <iostream> #define OK 1 #define ERROR 0 typedef int ElemType; typedef int ...
  • ADT实现

    2016-08-16 23:29:38
    栈的定义:  栈是限制插入和删除只能在一个位置上的进行的线性表,该位置是线性表的末端,称为栈顶(Top...由于栈是一种线性表,因此任何实现表的方法都可以实现栈; 栈的链表实现: 栈的数组实现: 栈的应用:
  • 1. ADT的定义 初始化链表的任务就是创建一个不包含元素的空节点,我们称这个空节点为头节点 头节点的特点如下: 头节点的元素值为空,当然也可以是你规定的为无效值的元素值; 头节点所指的下一个节点为空 typedef...
  • Java_ADT_... 通过不同数据结构的ADT实现 项目1 ADT清单 在某些ArrayList操作上基于数组的实现。 数组用作数据结构。 项目2 ADT LinkedString 在某些String操作上基于引用的实现。 双链表被用作数据结构。
  • 多项式ADT的链表实现

    千次阅读 2014-04-04 20:23:23
    昨天用数组实现了多项式,今天用链表实现了一下。在写代码的过程中,发现
  • ADT实现Graph类

    千次阅读 2018-03-24 23:29:50
    利用泛型实现一个Graph类 一、 定义一个接口Graph.java: public interface Graph&lt;L&gt; { public static &lt;L&gt; Graph&lt;L&gt; empty() { } //其中这个方法需要具体实现 ### ...
  • 树的ADT实现

    千次阅读 2017-06-06 19:15:13
    请编程实现下列操作: (1) 创建二叉树(完全前序或前序+中序); (2)遍历二叉树(深度、层次); (3)求给定元素的双亲; (4)求二叉树的高度; (5)计算叶子数; (6)判断是否完全二叉树 在这里我用了完全...
  • 源码下载地址: http://www.javaall.com/resource/news.rar 本文的目的是利用数据结构: 树 ,来实现一个分类表ADT, 这个分类表ADT可以实现无限级分类 本例程采用Structs 架构, 符合MVC设计模式 数据库采用SQL ...
  • 数据结构 C ++中数据结构/ ADT实现的集合。 包括二叉树,字典,双端队列,双向链接列表,图(使用邻接列表),哈希。 一些实现利用堆栈或队列ADT。
  • 链表ADT详解

    千次阅读 2011-12-29 14:14:18
    这里实现了单链表的ADT。主要的操作有: 节点结构提的定义: struct Node {  int element;  struct Node *next; }; 以及链表的常见操作  /*生成一个空,该链表只有头节点*/ List creatList(void) /*...
  • 的简单数组实现 分析: PrintList和Find操作线性时间 Find操作常数时间 Insert和Delete操作效率低下 所以一般不用数组实现 链表的指针实现 设计思路 在内存中不必相连 每个结构包含元素和指向该元素后继...
  • 队列ADT实现

    千次阅读 2011-12-29 23:35:44
    流行的做法也是用数组实现。 结构体如下: struct Queue {  int capacity;  int front;  int rear;  int size;  int *num; };   直接上参考代码了: #include #include struct Queue {  int ...
  • 线性表ADT实现的大部分代码已经给出,请补充写出类的两个成员函数insert和reverse。 注意:只需提交需要补充的函数代码,其他代码不能自己重写和修改。 insert函数:在元素值从小到大有序的线性表中插入一 个元素...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,008
精华内容 12,003
关键字:

表adt实现