精华内容
下载资源
问答
  • 超文本标记语言假设线性表ADT的数据元素类型为正整数,采用带头结点的单链式存储结构。线性表ADT实现的大部分代码已经给出,请补充写出类的两个成员函数insert和reverse。 注意:只需提交需要补充的函数代码,其他...

    题目描述:
    超文本标记语言假设线性表ADT的数据元素类型为正整数,采用带头结点的单链式存储结构。线性表ADT实现的大部分代码已经给出,请补充写出类的两个成员函数insert和reverse。 注意:只需提交需要补充的函数代码,其他代码不能自己重写和修改。

     insert函数:在元素值从小到大有序的线性表中插入一
     个元素,仍然保持有序。
     reverse函数:实现线性表元素的倒置,即将线性表中
     数据元素的顺序反转。
     线性表元素输入时,以 endTag 作为结束标志。
    	
    例如输入: 3 8 7 2 4 9 1 6 5 0
    则输出:9 8 7 6 5 4 3 2 1
    
    预置代码如下: (其中/*   */ 部分是要补充的insert和reverse函数)
    
    #include<iostream>
    #include<stdlib.h>
    using namespace std;
    typedef int ElemType;  //数据元素类型
    class List; //前视定义,否则友元无法定义
    //结点类定义
    class LinkNode
    {  friend  class List; 
       private: 
         LinkNode *link; 
         ElemType data;  
       public: 
         LinkNode (LinkNode *ptr = NULL)    {link=ptr;}
         LinkNode(const ElemType & item, LinkNode *ptr = NULL){  data=item;link=ptr;} 
         ~LinkNode(){}; 
    }; 
    //单链表类定义 
    
    class List   
    
    {  private:    
    
         LinkNode *first; //指向链表头结点的指针          
    
       public:
    
         List (ElemType x) { first = new LinkNode (x);}   // 带头结点
    
         ~List (){ MakeEmpty();}         //析构函数
    
         void MakeEmpty ( );      //线性表置空    
    
         void insert(ElemType val);   //在有序线性表中插入元素val
    
         void reverse();   //线性表的倒置
    
         void output();    //线性表的输出               
    
    }; 
    
    void List:: MakeEmpty ( )
     { LinkNode *q;
       while (  first->link != NULL ) 
    	{ q = first->link;  //指向别摘下结点 
         first->link = q->link;//从链中摘下结点
         delete q;        //释放摘下的结点 
        }
    };	
    void List ::output ( )
    {  LinkNode  *p=first->link; 
       while(p!=NULL)
       { if(p==first->link) cout<<p->data;
    
         else  cout<<" "<<p->data;
         p=p->link;
       }
       cout<<endl;
    }
    /*
    
    **************************************************
    
    请写出 insert 成员函数
    
    **************************************************
    
    **************************************************
    
    请写出 reverse 成员函数
    
    **************************************************
    
    */
    
    int  main()
    {   List list(0);
        ElemType endTag=0;
        ElemType val;
        //下面通过不断读入元素,插入到有序单链表中,建立从小到大的有序单链表
        cin>>val;
        while(val!=endTag) 
         {  list.insert(val);     //在有序表中插入一个元素
    
            cin>>val;  
    
          }
        list.reverse ();   //线性表倒置
        cout<<"The result is:"<<endl;
        list.output ();
        return 0;
    }
    
    

    解题思路:
    1.补全代码insert
    插入排序按照从小到 一边插入一边排序
    2.reverse()
    正序遍历用辅助数组记录数值反序输入原线性表

    实现代码

    void List::insert(ElemType val) {
    	LinkNode *p = new LinkNode(val);
    	LinkNode *tem = first->link;
        LinkNode *pritem = first;//tem的前驱
    	if(first->link == NULL) {
    	//初始adl为空直接插入
    		first->link = p;
    		return;
    	}
    	while(tem && p->data > tem->data) {
    	   插入结点数据大于指针tem指向数据或tem到数据最后
    		pritem = pritem->link;
    		tem =tem->link;
    	}
    	p->link = pritem->link;//插入
    	pritem->link=p;
    }
    
    void List::reverse() {
    	LinkNode *p = first->link;
    	ElemType num=0,*n;
    	while(p!=NULL) {
    		num++;
    		p=p->link;
    	}//确定辅助数组大小
    	p = first->link;
    	n = new ElemType[num]();
    	num = 0;
    	while(p!=NULL)  {
    		n[num] = p->data;//正序记录
    		num++;
    		p = p->link;
    	}
    	p = first->link;
    	for(int i =num-1; i>=0; i-- ) {
    		p->data = n[i];//反序覆盖
    		p=p->link;
    	}
    }
    
    
    展开全文
  • 假设线性表ADT的数据元素类型为正整数,采用带头结点的单链式存储结构。线性表ADT实现的大部分代码已经给出,请补充写出类的两个成员函数insert和reverse。 注意:只需提交需要补充的函数代码,其他代码不能自己重写...

    假设线性表ADT的数据元素类型为正整数,采用带头结点的单链式存储结构。线性表ADT实现的大部分代码已经给出,请补充写出类的两个成员函数insert和reverse。 注意:只需提交需要补充的函数代码,其他代码不能自己重写和修改。
    insert函数:在元素值从小到大有序的线性表中插入一个元素,仍然保持有序。
    reverse函数:实现线性表元素的倒置,即将线性表中数据元素的顺序反转。
    线性表元素输入时,以 endTag 作为结束标志。
    例如输入: 3 8 7 2 4 9 1 6 5 0
    则输出:9 8 7 6 5 4 3 2 1
    预置代码如下: (其中/* */ 部分是要补充的insert和reverse函数)

    #include< iostream >
    #include<stdlib.h>
    using namespace std;
    typedef int ElemType; //数据元素类型 class List; //前视定义,否则友元无法定义 //结点类定义 class LinkNode { friend
    class List;
    private:
    LinkNode *link;
    ElemType data; public:
    LinkNode (LinkNode *ptr = NULL) {link=ptr;}
    LinkNode(const ElemType & item, LinkNode *ptr = NULL){ data=item;link=ptr;}
    ~LinkNode(){}; }; //单链表类定义 class List { private:
    LinkNode *first; //指向链表头结点的指针 public:
    List (ElemType x) { first = new LinkNode (x);} // 带头结点
    ~List (){ MakeEmpty();} //析构函数
    void MakeEmpty ( ); //线性表置空
    void insert(ElemType val); //在有序线性表中插入元素val
    void reverse(); //线性表的倒置
    void output(); //线性表的输出 };
    void List:: MakeEmpty ( ) { LinkNode *q; while ( first->link != NULL ) { q =first->link; //指向别摘下结点
    first->link = q->link;//从链中摘下结点
    delete q; //释放摘下的结点
    }
    };
    void List ::output ( ) {
    LinkNode p=first->link;
    while(p!=NULL) { if(p==first->link) cout<< p->data;
    else cout<<" "<< p->data;
    p=p->link; }
    cout<<endl; } /

    请写出 insert 成员函数
    请写出 reverse 成员函数
    */ int main() {
    List list(0);
    ElemType endTag=0;
    ElemType val;
    //下面通过不断读入元素,插入到有序单链表中,建立从小到大的有序单链表
    cin>>val;
    while(val!=endTag)
    { list.insert(val); //在有序表中插入一个元素
    cin>>val;
    }
    list.reverse (); //线性表倒置
    cout<<“The result is:”<<endl;
    list.output ();
    return 0; }

    void List::insert(ElemType val)
    {
        LinkNode *p1,*t;
        t=new LinkNode(val);
        if(first->link==NULL)
        {
            first->link=t;
            return;
        }
        if(first->link->data>=val)
        {
            t->link=first->link;
            first->link=t;
            return;
        }
        p1=first;
        while(p1->link!=NULL&&p1->data<val)
        {
            if(p1->link->data<=val)p1=p1->link;
            else break;
        }
        t->link=p1->link;
        p1->link=t;
    }
    void List::reverse()//严格上来说应该采用链表倒转的方法,但这个题中原来的元素是升序的,顺序反转后一定是降序的,因此只需要实现降序排序就可以
    {
        LinkNode *p,*q;
        p=first->link;
        ElemType t;
        while(p!=NULL)
        {
            q=p->link;
            while(q!=NULL)
            {
                if(p->data<q->data)
                {
                    t=p->data;
                    p->data=q->data;
                    q->data=t;
                }
                q=q->link;
            }
            p=p->link;
        }
    }
    

    链表反转的正确做法:头删+头插

    void List::reverse()
    {
        LinkNode*newfirst=new LinkNode();//反转后的链表的头结点
        LinkNode*temp;
        first=first->link;
        while(first!=NULL)
        {
            temp=first;
            first=first->link;//原链表头删
            temp->link=newfirst->link;
            newfirst->link=temp;//新链表头插
        }
        first=newfirst;//一定别忘记将反转后链表的头结点指针赋给原来的头结点指针
    }
    
    展开全文
  • 队列ADT+实现代码

    2018-12-08 17:55:44
    代码实现 链接:https://blog.csdn.net/qq_29350001/article/details/55261466 队列 队列是一种先进先出的线性表,他只允许在表一端进行插入,另一端进行删除 队头(front):允许删除一端 队尾(rear):...

    目录

     

    队列

    ADT 

    代码实现

    链接:https://blog.csdn.net/qq_29350001/article/details/55261466


    队列

    队列是一种先进先出的线性表,他只允许在表的一端进行插入,另一端进行删除

    队头(front):允许删除的一端

    队尾(rear):允许插入的一端

    ADT 

    ADT Queue{
        数据对象:D = {ai|ai∈ElemSet,i = 1,2,...,n, n>= 0}
        数据关系:R1 = {<ai-1,ai>|ai-1,ai∈D,i = 2,...,n}
            约定其中a1端为队列头,an端为队列尾
        基本操作:
        InitQueue(*Q):初始化操作,建立一个空队列Q。
    	DestroyQueue(*Q):若队列Q存在,則销毀它。
    	ClearQueue(*Q):将队列 Q 清空。
    	QueueEmpty(Q):若队列Q为空,送回true,否則退回false。
    	GetHead(Q, *e):若队列Q存在且非空,用e返因队列Q的队头元素。
    	EnQueue(*Q,e):若队列Q存在,插入新元素e到队列Q中并成为队尾元素。 
    	DeQueue(*Q, *e):刪除队列Q中队头元素,并用e返回其值。	
    	QueueLength(Q):送回队列Q的元素个教。
    }ADT Queue;

    代码实现

    链式存储结构 

    // 队列.cpp : 定义控制台应用程序的入口点。
    //队列的链式存储结构
    
    #include <stdio.h>
    # include<stdlib.h>
    
    # define Status int
    # define QElemType int 
    # define OVERFLOW -1
    # define OK 1
    # define ERROR 0
    # define TRUE 1
    # define FALSE 0
    
    typedef struct QNode
    {
    	QElemType data;
    	struct QNode *next;
    }QNode,*QueuePtr;
    
    typedef struct
    {
    	QueuePtr front, rear;
    }LinkQueue;
    
    //初始化队列
    Status InitQueue(LinkQueue *q)
    {
    	if (!q)
    	{
    		printf("队列不存在!\n");
    		return ERROR;
    	}
    
    	q->front = q->rear = (QueuePtr)malloc(1 * sizeof(QNode));
    
    	if (!q->front)
    	{
    		printf("内存分配失败!\n");
    		exit(OVERFLOW);
    	}
    
    	q->front->next = NULL;
    
    	return OK;
    }
    
    //清空队列
    Status ClearQueue(LinkQueue *q)
    {
    	if (!q)
    	{
    		printf("队列不存在!\n");
    		return ERROR;
    	}
    
    	QueuePtr p = q->front->next, tmp;
    
    	while (p)
    	{
    		tmp = p->next;
    		free(p);
    		p = tmp;
    	}
    	q->front = q->rear;
    
    	return OK;
    }
    
    //销毁队列
    Status DestoryQueue(LinkQueue *queue)
    {
    	if (!queue)
    	{
    		printf("队列不存在!\n");
    		return ERROR;
    	}
    
    	while (queue->front != NULL) {
    		queue->rear = queue->front->next;
    		free(queue->front);
    		queue->front = queue->rear;
    	}
    
    	return OK;
    }
    
    //空队列
    Status QueueEmpty(LinkQueue q)
    {
    	if (!&q)
    	{
    		printf("空队列!\n");
    		return ERROR;
    	}
    
    	if (q.front == q.rear)
    		return TRUE;
    	else
    		return FALSE;
    }
    
    //插入元素e为q的新队尾元素
    Status EnQueue(LinkQueue *q, QElemType e)
    {
    	QueuePtr p = (QueuePtr)malloc(1 * sizeof(QNode));
    	if (!q)
    	{
    		printf("内存分配失败!\n");
    		return ERROR;
    	}
    
    	p->data = e;
    	p->next = NULL;
    	q->rear->next = p;
    	q->rear = p;
    
    	return OK;
    }
    
    //出队
    Status DeQueue(LinkQueue *q, QElemType *e)
    {
    	if (!q)
    	{
    		printf("队列不存在!\n");
    		return ERROR;
    	}
    
    	if (QueueEmpty(*q))
    	{
    		printf("空队列!\n");
    		return ERROR;
    	}
    
    	QueuePtr p = (*q).front->next;
    	*e = p->data;
    	(*q).front->next = p->next;
    	if ((*q).front == (*q).rear)
    	{
    		(*q).rear = (*q).front;
    	}
    	free(p);
    
    	return OK;
    }
    
    //队列长度
    Status QueueLength(LinkQueue q)
    {
    	if (!&q)
    	{
    		printf("不存在!\n");
    		return ERROR;
    	}
    
    	int len = 0;
    	QueuePtr p = q.front->next;
    
    	while (p)
    	{
    		len++;
    		p = p->next;
    	}
    
    	return len;
    }
    
    //获取队首元素
    Status GetHead(LinkQueue q, QElemType *e)
    {
    	if (!(&q))
    	{
    		printf("队列不存在!\n");
    		return ERROR;
    	}
    
    	if (QueueEmpty(q))
    	{
    		printf("空队列!\n");
    		return ERROR;
    	}
    
    	*e = q.front->next->data;
    
    	return OK;
    }
    
    //访问函数
    Status visit(QElemType e)
    {
    	printf("%d ",e);
    	return OK;
    }
    
    //遍历队列
    Status QueueTraverse(LinkQueue q, Status(*visit)(QElemType e))
    {
    	if (!(&q))
    	{
    		printf("队列不存在!\n");
    		return ERROR;
    	}
    	if (QueueEmpty(q))
    	{
    		printf("队列为空!\n");
    		return ERROR;
    	}
    
    	QueuePtr p = q.front->next;
    	while (p)
    	{
    		visit(p->data);
    		p = p->next;
    	}
    
    	return OK;
    }
    
    int main()
    {
    	LinkQueue que;
    	QElemType data;
    	int n;
    
    	InitQueue(&que);
    	
    	printf("输入队列元素数量:\n");
    	scanf_s("%d", &n);
    	printf("输入队列中元素:\n");
    	while (n--)
    	{
    		scanf_s("%d",&data);
    		EnQueue(&que, data);
    	}
    
    	printf("遍历队列:\n");
    	QueueTraverse(que, visit);
    	printf("\n");
    
    	
    	/*
    	DestoryQueue(&que);
    
    	printf("遍历队列:\n");
    	QueueTraverse(que, visit);
    	printf("\n");
    
    	DeQueue(&que, &data);
    	printf("队首部元素是:%d\n", data);
    	printf("遍历队列:\n");
    	QueueTraverse(que, visit);
    	
    	GetHead(que, &data);
    	printf("队列首元素是:%d\n",data);
    	printf("长度:%d\n", QueueLength(que));
    	DeQueue(&que, &data);
    	printf("%d\n", que.front->next->next->data);
    	*/
        return 0;
    }

    顺序存储结构(循环队列)

    // 循环队列.cpp : 定义控制台应用程序的入口点。
    // 牺牲一个元素的空间,队列头指针在队列尾指针的下一位置上 最为队列满的标志
    
    #include <stdio.h>
    # include<stdlib.h>
    
    # define Status int
    # define ElemType int
    # define OK 1
    # define ERROR 0
    # define OVERFLOW -1
    # define TRUE 1
    # define FALSE 0
    # define MAXSIZE 10
    # define MAXRC 10
    
    typedef struct
    {
    	QElemType *base;
    	int front;
    	int rear;
    }SqQueue;
    
    //初始化队列
    Status InitQueue(SqQueue *q)
    {
    	q->base = (QElemType *)malloc(MAXQSIZE * sizeof(QElemType));
    	if (!q->base)
    	{
    		printf("内存分配失败!\n");
    		exit(OVERFLOW);
    	}
    
    	q->front = q->rear = 0;
    
    	return OK;
    }
    
    //空队列
    Status EmptyQueue(SqQueue q)
    {
    	if (q.front == q.rear)
    		return TRUE;
    	else
    		return FALSE;
    }
    
    //入队
    Status EnQueue(SqQueue *q, QElemType e)
    {
    	if ((q->rear + 1) % MAXQSIZE == q->front)
    	{
    		printf("队列满!\n");
    		return ERROR;
    	}
    
    	q->base[q->rear] = e;
    	q->rear = (q->rear + 1) % MAXQSIZE;
    
    	return OK;
    }
    
    //出队
    Status DeQueue(SqQueue *q, QElemType *e)
    {
    	if (q->front == q->rear)
    		return ERROR;
    
    	*e = q->base[q->front];
    	q->front = (q->front + 1) % MAXQSIZE;
    
    	return OK;
    }
    
    //访问函数
    Status visit(QElemType e)
    {
    	printf("%d ",e);
    
    	return OK;
    }
    
    //遍历
    Status Traverse(SqQueue q, Status(*visit)(QElemType e))
    {
    	if (!&q)
    	{
    		printf("队列不存在!\n");
    		return ERROR;
    	}
    
    	QElemType *t = &q.base[q.front];
    
    	while (t != &q.base[q.rear])
    	{
    		visit(*t);
    		t++;
    	}
    
    	return OK;
    }
    
    //求队列长度
    Status QueueLength(SqQueue q)
    {
    	return (q.rear - q.front + MAXQSIZE) % MAXQSIZE;
    }
    
    int main()
    {
    	int n;
    	QElemType data;
    	SqQueue q;
    
    	InitQueue(&q);
    	if (EmptyQueue(q))
    	{
    		printf("空队列\n");
    	}
    
    	printf("输入队列中元素个数:\n");
    	scanf_s("%d",&n);
    	printf("输入队列元素\n");
    	while (n--)
    	{
    		scanf_s("%d",&data);
    		EnQueue(&q, data);
    	}
    	printf("遍历队列!\n");
    	Traverse(q, visit);
    	printf("\n");
    	printf("队列长度为:%d\n",QueueLength(q));
    
    /*
    	DeQueue(&q, &data);
    	printf("删除的队首元素是:%d\n",data);
    	printf("遍历队列!\n");
    	Traverse(q, visit);
    	printf("\n");
    	*/
        return 0;
    }
    
    

    链接:https://blog.csdn.net/qq_29350001/article/details/55261466

     

    展开全文
  • 实验报告&源代码见链接 题目描述:线性表的实现   问题描述实验要求 : ...需要基于顺序表(数组)或链表来实现线性表ADT 需要实现线性表的各个基本操作 编写一个demo程序,测试线性表的各个基本操作的功能是否正常

    题目描述:线性表的实现
     
    问题描述实验要求 :

    基于教材内容(shaffer),实现线性表。
     
    基本要求

    需要基于顺序表(数组)或链表来实现线性表ADT 需要实现线性表的各个基本操作 编写一个demo程序,测试线性表的各个基本操作的功能是否正常 
     

    #include<iostream>
    #define ListSize 100
    using namespace std;
    typedef int DataType;
    typedef struct
    {
    	DataType data[ListSize];
    	int length;
    }SeqList;
    void InitList(SeqList *sl)
    {
    	sl->length=0;
    }
    void CreateList(SeqList *sl,DataType x[],int n)
    {
    	int i;
    	for(i=0;i<n;i++)
    	{
    		sl->data[i]=x[i];
    		sl->length++;
    	}
    }
    int LengthList(SeqList *sl)
    {
    	return sl->length;
    }
    DataType GetList(SeqList *sl,int k)
    {
    	return sl->data[k-1];
    }
    int InsertList(SeqList *sl,DataType x,int i)
    {
    	int j;
    	if(i<0||i>sl->length+1)
    	{
    		cout<<"Position error."<<endl;
    		return 0;
    	}
    	if(sl->length>=ListSize)
    	{
    		cout<<"Overflow."<<endl;
    		return 0;
    	}
    	for(j=sl->length-1;j>=i-1;j--)
    	    sl->data[j+1]=sl->data[j];
    	sl->data[i-1]=x;
    	sl->length++;
    	return 1;
    }
    int DeleteList(SeqList *sl,int i)
    {
    	int j;
    	if(i<1||i>sl->length)
    	{
    		cout<<"Position error";
    		return 0;
    	}
    	if(sl->length==0)
    	{
    		cout<<"Position error";
    		return 0;
    	}
    	for(j=i;j<=sl->length-1;j++)
    	    sl->data[j-1]=sl->data[j];
    	sl->length--;
    	return 1;
    }
    int SearchList(SeqList *sl,DataType x)
    {
    	int i=1;
    	while(i<=sl->length&&sl->data[i-1]!=x)
    	    i++;
    	if(sl->data[i-1]==x)
    	    return i;
    	else 
    	    return -1;
    }
    void PrintList(SeqList *sl)
    {
    	int i;
    	for(i=0;i<LengthList(sl);i++)
    	{
    		cout<<sl->data[i]<<"    ";
    	}
    	cout<<endl;
    }
    int main()
    {
    	SeqList *seq;
    	cout<<"The sequence list length is:"<<endl;
    	int n;
    	cin>>n;
    	cout<<"The sequence list is:"<<endl;
    	int arr[n];
    	for(int i=0;i<n;i++)
    	{
    		cin>>arr[i];
    	}
    	seq=(SeqList *)malloc(ListSize * sizeof(SeqList));
    	InitList(seq);
    	CreateList(seq,arr,n);
    	int s;
        cin>>s;
    	cout<<"The "<<s<<" node is "<<GetList(seq,s)<<endl;
    	cout<<"Insert a node,the sequence list is:"<<endl;
    	int m,x;
    	cin>>m>>x;
    	InsertList(seq,m,x);
    	cout<<"The sequence list is:"<<endl;
    	PrintList(seq);
    	int q;
    	cin>>q;
    	DeleteList(seq,q);
    	cout<<"Delete a node,the sequence list is:"<<endl;
    	PrintList(seq);
    	int p;
    	cin>>p;
    	if(SearchList(seq,p)!=-1)
    	   cout<<"The search data"<<p<<"  has been found. The code is "<<SearchList(seq,p)<<endl;
    	else 
        	cout<<"The search data not found."<<endl;
        
    	cout<<"The sequence list length is "<<LengthList(seq);
    	return 0;
    }



    展开全文
  • 刚学了数据结构,根据书上每个ADT操作都谢了代码,测试通过~ 可以说很详细了! int InitList(LinkList &L) int DestroyList(LinkList &L) int ClearList(LinkList &L) int ListEmpty(LinkList L) int ListLength...
  • ADT 线性表(List) Data 线性表的数据对象集合为{a1,a2,...,an},每个元素类型均为DataType。其中,除了第一个元素a1外, 每个元素有且只有一个直接前驱,除了最后一个元素,每个元素有且只有一个直接后继元素...
  • 实验1 线性表的实现(基于链表)

    千次阅读 2018-07-26 18:16:31
    需要基于顺序表(数组)或链表来实现线性表ADT 需要实现线性表各个基本操作 编写一个demo程序,测试线性表各个基本操作功能是否正常 一、实验分析: ADT就是抽象数据结构,线性表有两种,顺序表也就是我们...
  • a. 线性表(List):零个或多个数据元素有序序列。 b. 线性表的长度n=LIstLenght(L);当n=0时,线性表为空,即空表。... ADT 线性表 (List) Data Operation Initlist (*L ) 初始化建立一个空链表
  • 本文实例为大家分享了python实现线性表顺序具体代码,供大家参考,具体内容如下 线性表 1.抽象数据类型表示(ADT) 类型名称:线性表 数据对象集:线性表是n(>=0)个元素构成有序序列(a1,a2,….,an) 操作集:...
  • java数据结构:线性表之数组实现

    千次阅读 2013-08-07 17:47:38
    今天我们来复习一下如何使用数组来实现线性表 设计抽象数据类型ADT 数据结构实际上就是针对一系列数据,设计一系列针对这些数据操作方法,由于这些数据和操作方法一般来说是共性特征,所以我们可以使用接口来...
  • ADT 线性表(List) data ... Operation ... endADT 线性表的数据对象集合为 {a1, a2, …, an} ,每个元素类型均为 DataType 除第一个元素 a1 外,每个元素有且只有一个直接前驱元素 除最后一个元素 an 外,每个...
  • 自己写用C#语言实现的数据结构线性表的ADT;在Visual Studio 2010IDE运行成功。
  • 本文实例为大家分享了python实现线性表顺序具体代码,供大家参考,具体内容如下线性表1.抽象数据类型表示(ADT)类型名称:线性表数据对象集:线性表是n(>=0)个元素构成有序序列(a1,a2,….,an)操作集:2....
  • ADT+实现

    2018-12-08 17:47:57
    仅在队尾进行插入或删除操作的线性表【后进后出的线性表】 栈顶(Top):线性表表尾 栈底(Base):线性表表头 ADT ADT Stack { 数据对象:D = {ai|ai∈ElemSet,i = 1,2,...,n, n&gt;= 0} 数据关系:R1 = ...
  • 线性表的顺序表示:顺序表ADT_SeqList

    千次阅读 2015-09-06 22:48:35
    包含函数:Isempty(), Length(), Find(), Search(), Insert(), Delete(), Update(), Output()...实现代码: #include "iostream" #include "cstdio" #include "cstring" #include "algorithm" using namespace std;
  • 请基于线性表ADT完成程序设计。 【问题分析】 ① 处理对象:n个正整数 ② 实现的功能:通过线性表功能找出n个数据中相差(差绝对值)最小两个数,并输出它们差值绝对值。 ③ 处理后数据结果以一个整数...
  • C++实现线性表(顺序表和链表)

    千次阅读 2019-06-11 23:48:28
    下面代码显示了线性表ADT的定义。 //声明List基类 template <typename E> class List { private: void operator = (const List &){ }//protect assignment List(const List&){...
  • 线性表线性表定义抽象数据类型数据类型:原子类型:结构类型:抽象抽象数据类型(Abstract Data Type,ADT)标准格式:线性表的抽象数据类型定义:并集的实现线性表的物理存储结构线性表的顺序存储结构结构代码:顺序...
  • 数据结构:线性表

    2016-02-08 21:28:37
    声明:本文为学习数据结构与算法分析(第三版) Clifford A.Shaffer 著的学习笔记,代码有参考该...对于线性表的实现有两种方法,数组或者链表。 首先定义线性表ADTtemplate class List { List(const List& list) {}
  • 【注解】正如我在线性表中基本操作中所叙述所示,当你想定义一个自定义新功能函数时,在头文件ADT.H中添加函数声明,最后在自己source代码中定义该函数即可实现函数全局使用。我把void MergeList(List L1,...
  • 开学快一个月,终于自己写成功线性表的代码了!!!!好开心!!!!!!!!!! 期间查看了无数其他人博客,又把谭浩强老师C++翻了好几遍!! 该代码在codeblocks17.12上面测试。 其实应该感谢是以为...
  • 假设线性表ADT的数据元素类型为正整数,采用带头结点的单链式存储结构。线性表ADT实现的大部分代码已经给出,请补充写出类的两个成员函数insert和reverse。 注意:只需提交需要补充的函数代码,其他代码不能自己重写...
  • 本文重点讨论线性表的数组描述,通过利用C++语言从零开始实现数组描述的线性表,对其进行学习(所使用函数名和签名与STL代码相同)。 线性表也称有序表,其每一个实例均为元素一个有序集合。元素被看做原子,其...
  • ADT 线性表(List) Data 线性表的数据对象集合为{a~1~,a~2~,……,a~n~},每个元素类型均为DataType。其中,除第一个元素a1外,每一个元素有且只有一个直接前驱元素,除了最后一个元素a~n~外,每一个元素有且...
  • ADT 线性表(List) Data 线性表的数据对象集合为{a1,a2,…,an},每个元素类型均为DataType。其中,除了第一个元素a1外, 每个元素有且只有一个直接前驱,除了最后一个元素,每个元素有且只有一个直接后继元素。...
  • ADT 队列(Queue) Data 同线性表。元素具有相同类型,相邻元素具有前驱和后继关系 Operator InitQueue(*Q):初始化操作,建立一个空队列Q DestroyQueue(*Q):若队列存在则销毁他 ClearQueue(*Q):将...
  • ADT 栈(stack) Data 同线性表。元素具有相同地方类型,相邻元素具有前驱和后继关系 Operation InitStack(*S):初始化操作,建立一个空栈S DestroyStack(*S):若栈存在,则销毁他 ClearStack(*S):将栈...
  • 带表头结点单链表ADT_HeaderList

    千次阅读 2015-09-27 21:08:26
    单链表的衍生,许多函数和单链表想同,多了一个first表头结点。 带表头结点的数据域element不存放线性表...给出构造函数,插入函数以及删除函数的实现代码。 实现代码: template HeaderList::HeaderList() { Node *
  • 数据结构之队列 ADT

    2019-02-20 17:55:59
    版权声明 本文为博主随手笔记,欢迎评论和转载 ...- 相关代码的实现(这是此公众号写数据结构篇章的意义所在)。 线性表简介 线性表(linear_list)是最常用且最简单的一种数据结构。它的特点是...

空空如也

空空如也

1 2 3
收藏数 50
精华内容 20
关键字:

线性表adt的实现代码