抽象数据类型之表（List）

最新推荐文章于 2022-08-18 10:44:22 发布
最新推荐文章于 2022-08-18 10:44:22 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： 数据结构算法 文章标签： 数据结构 adt LIST 单项链表 双向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ctios/article/details/53335581
版权

抽象数据类型之表（List）

本章主要讲的是顺序线性表的实现，以及单向链表，双向链表C语言实现

什么是抽象数据类型

抽象数据类型（ADT)是一些操作的集合

  • 数学的抽象
    • 数据上的抽象
    • 程序上的抽象

表ADT

表的定义：

ADT List
{
    Data object：D = {ai | ai∈Elemset, (i=1,2,…,n, n≥0)}
    Data relationshis：R1 = {＜ai-1,ai＞|ai-1,ai ∈D, (i=2,3,…,n) }
    operations： 
        InitList(&L);          
        DestroyList(&L);
        ListInsert(&L,i,e); 
        ListDelete(&L,i,&e);
        and so on
} ADT List

表的基本操作

(1) InitList(&L);      
    DestroyList(&L);
    ClearList(&L);  
(2) ListEmpty(L);
(3) GetElem(L, i, &e);
    LocateElem(L, e, compare());
    PriorElem(L, cur_e, &pre_e);
    NextElem(L, cur_e, &next_e);
(4) ListInsert(&L, i, e);   
    ListDelete(&L, i, &e);
(5) ListTraverse(&L, visited())

（一）List顺序线性表

定义：

 #include <ctype.h>
 #include <malloc.h> /* malloc()? */
 #include <limits.h> /* INT_MAX? */
 #include <stdio.h> /* EOF(=^Z?F6),NULL */
 #include <stdlib.h> /* atoi() */
 #include <io.h> /* eof() */
 #include <math.h> /* floor(),ceil(),abs() */
 #include <process.h> /* exit() */
 /* 函数结果状态代码 */
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
 #define INFEASIBLE -1
 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
 typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
 typedef int ElemType;
typedef ElemType *Triplet;
 typedef struct
 {
   ElemType *elem; /* ?????? */
   int length; /* ???? */
   int listsize; /* ?????????(?sizeof(ElemType)???) */
 }SqList;
void InitList(SqList *L) ;
void DestroyList(SqList *L);

 void ClearList(SqList *L);

 Status ListEmpty(SqList L);

 int ListLength(SqList L);

 Status GetElem(SqList L,int i,ElemType *e);

 int LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType)); 

 Status PriorElem(SqList L,ElemType cur_e,ElemType *pre_e);


 Status NextElem(SqList L,ElemType cur_e,ElemType *next_e);


 Status ListInsert(SqList *L,int i,ElemType e) ;


 Status ListDelete(SqList *L,int i,ElemType *e) ;


 void ListTraverse(SqList L,void(*vi)(ElemType*));
  Status equal(ElemType c1,ElemType c2); 

 int comp(ElemType a,ElemType b);

 void print(ElemType c);

 void print2(ElemType c);

 void print1(ElemType *c);

实现：

void InitList(SqList *L) /* 算法2.3 */
 { /* 操作结果：构造一个空的顺序线性表L */
   (*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
   if(!(*L).elem)
     exit(OVERFLOW); /* 存储分配失败 */
   (*L).length=0; /* 空表长度为0 */
   (*L).listsize=LIST_INIT_SIZE; /* 初始存储容量 */
 }

 void DestroyList(SqList *L)
 { /* 初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表L */
   free((*L).elem);
   (*L).elem=NULL;
   (*L).length=0;
   (*L).listsize=0;
 }

 void ClearList(SqList *L)
 { /* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
   (*L).length=0;
 }

 Status ListEmpty(SqList L)
 { /* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
   if(L.length==0)
     return TRUE;
   else
     return FALSE;
 }

 int ListLength(SqList L)
 { /* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
   return L.length;
 }

 Status GetElem(SqList L,int i,ElemType *e)
 { /* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)。操作结果：用e返回L中第i个数据元素的值 */
   if(i<1||i>L.length)
     return ERROR;
   *e=*(L.elem+i-1);
   return OK;
 }

 int LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType))
 { /* 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0) */
   /* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。 */
   /*           若这样的数据元素不存在，则返回值为0。算法2.6 */
   ElemType *p;
   int i=1; /* i的初值为第1个元素的位序 */
   p=L.elem; /* p的初值为第1个元素的存储位置 */
   while(i<=L.length&&!compare(*p++,e))
     ++i;
   if(i<=L.length)
     return i;
   else
     return 0;
 }

 Status PriorElem(SqList L,ElemType cur_e,ElemType *pre_e)
 { /* 初始条件：顺序线性表L已存在 */
   /* 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱， */
   /*           否则操作失败，pre_e无定义 */
   int i=2;
   ElemType *p=L.elem+1;
   while(i<=L.length&&*p!=cur_e)
   {
     p++;
     i++;
   }
   if(i>L.length)
     return INFEASIBLE; /* 操作失败 */
   else
   {
     *pre_e=*--p;
     return OK;
   }
 }

 Status NextElem(SqList L,ElemType cur_e,ElemType *next_e)
 { /* 初始条件：顺序线性表L已存在 */
   /* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */
   /*           否则操作失败，next_e无定义 */
   int i=1;
   ElemType *p=L.elem;
   while(i<L.length&&*p!=cur_e)
   {
     i++;
     p++;
   }
   if(i==L.length)
     return INFEASIBLE; /* 操作失败 */
   else
   {
     *next_e=*++p;
     return OK;
   }
 }

 Status ListInsert(SqList *L,int i,ElemType e) /* 算法2.4 */
 { /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 */
   /* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
   ElemType *newbase,*q,*p;
   if(i<1||i>(*L).length+1) /* i值不合法 */
     return ERROR;
   if((*L).length>=(*L).listsize) /* 当前存储空间已满,增加分配 */
   {
     newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LIST_INCREMENT)*sizeof(ElemType));
     if(!newbase)
       exit(OVERFLOW); /* 存储分配失败 */
     (*L).elem=newbase; /* 新基址 */
     (*L).listsize+=LIST_INCREMENT; /* 增加存储容量 */
   }
   q=(*L).elem+i-1; /* q为插入位置 */
   for(p=(*L).elem+(*L).length-1;p>=q;--p) /* 插入位置及之后的元素右移 */
     *(p+1)=*p;
   *q=e; /* 插入e */
   ++(*L).length; /* 表长增1 */
   return OK;
 }

 Status ListDelete(SqList *L,int i,ElemType *e) /* 算法2.5 */
 { /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
   /* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
   ElemType *p,*q;
   if(i<1||i>(*L).length) /* i值不合法 */
     return ERROR;
   p=(*L).elem+i-1; /* p为被删除元素的位置 */
   *e=*p; /* 被删除元素的值赋给e */
   q=(*L).elem+(*L).length-1; /* 表尾元素的位置 */
   for(++p;p<=q;++p) /* 被删除元素之后的元素左移 */
     *(p-1)=*p;
   (*L).length--; /* 表长减1 */
   return OK;
 }

 void ListTraverse(SqList L,void(*vi)(ElemType*))
 { /* 初始条件：顺序线性表L已存在 */
   /* 操作结果：依次对L的每个数据元素调用函数vi() */
   /*           vi()的形参加'&'，表明可通过调用vi()改变元素的值 */
   ElemType *p;
   int i;
   p=L.elem;
   for(i=1;i<=L.length;i++)
     vi(p++);
   printf("\n");
 }

链表

单项链表

定义：
 #include<string.h>
 #include<ctype.h>
 #include<malloc.h> /* malloc()? */
 #include<limits.h> /* INT_MAX? */
 #include<stdio.h> /* EOF(=^Z?F6),NULL */
 #include<stdlib.h> /* atoi() */
 #include<io.h> /* eof() */
 #include<math.h> /* floor(),ceil(),abs() */
 #include<process.h> /* exit() */
 /* ???????? */
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
 #define INFEASIBLE -1
 /* #define OVERFLOW -2 ???math.h????OVERFLOW???3,????? */
 typedef int Status; /* Status??????,???????????,?OK? */
 typedef int Boolean; /* Boolean?????,???TRUE?FALSE */
 typedef int ElemType;
 struct LNode
 {
   ElemType data;
   LNode *next;
 };
 typedef LNode *LinkList; // 另一种定义LinkList的方法
Status equal(ElemType c1,ElemType c2);
 int comp(ElemType a,ElemType b);
 void print(ElemType c);
 void print2(ElemType c);
 void print1(ElemType &c);
void MakeNode(Link &p,ElemType e);
 void FreeNode(Link &p);
 void InitList(LinkList &L);
 void ClearList(LinkList &L);
 void DestroyList(LinkList &L);
 void InsFirst(LinkList &L,Link h,Link s) ;
 Status DelFirst(LinkList &L,Link h,Link &q) ;
 void Append(LinkList &L,Link s);
 Position PriorPos(LinkList L,Link p);
 Status Remove(LinkList &L,Link &q);
 void InsBefore(LinkList &L,Link &p,Link s);
 void InsAfter(LinkList &L,Link &p,Link s);
 void SetCurElem(Link p,ElemType e);
 ElemType GetCurElem(Link p);
 Status ListEmpty(LinkList L);
 int ListLength(LinkList L);
 Position GetHead(LinkList L);
 Position GetLast(LinkList L);
 Position NextPos(Link p);
 Status LocatePos(LinkList L,int i,Link &p);
 Position LocateElem(LinkList L,ElemType e,Status (*compare)(ElemType,ElemType));
 void ListTraverse(LinkList L,void(*visit)(ElemType));
 void OrderInsert(LinkList &L,ElemType e,int (*comp)(ElemType,ElemType));
 Status LocateElem(LinkList L,ElemType e,Position &q,int(*compare)(ElemType,ElemType));
实现：
 void MakeNode(Link &p,ElemType e)
 { // 分配由p指向的值为e的结点。若分配失败，则退出
   p=(Link)malloc(sizeof(LNode));
   if(!p)
     exit(ERROR);
   p->data=e;
 }

 void FreeNode(Link &p)
 { // 释放p所指结点
   free(p);
   p=NULL;
 }

 void InitList(LinkList &L)
 { // 构造一个空的线性链表L
   Link p;
   p=(Link)malloc(sizeof(LNode)); // 生成头结点
   if(p)
   {
     p->next=NULL;
     L.head=L.tail=p;
     L.len=0;
   }
   else
     exit(ERROR);
 }

 void ClearList(LinkList &L)
 { // 将线性链表L重置为空表，并释放原链表的结点空间
   Link p,q;
   if(L.head!=L.tail) // 不是空表
   {
     p=q=L.head->next;
     L.head->next=NULL;
     while(p!=L.tail)
     {
       p=q->next;
       free(q);
       q=p;
     }
     free(q);
     L.tail=L.head;
     L.len=0;
   }
 }

 void DestroyList(LinkList &L)
 { // 销毁线性链表L，L不再存在
   ClearList(L); // 清空链表
   FreeNode(L.head);
   L.tail=NULL;
   L.len=0;
 }

 void InsFirst(LinkList &L,Link h,Link s) // 形参增加L,因为需修改L
 { // h指向L的一个结点，把h当做头结点，将s所指结点插入在第一个结点之前
   s->next=h->next;
   h->next=s;
   if(h==L.tail) // h指向尾结点
     L.tail=h->next; // 修改尾指针
   L.len++;
 }

 Status DelFirst(LinkList &L,Link h,Link &q) // 形参增加L,因为需修改L
 { // h指向L的一个结点，把h当做头结点，删除链表中的第一个结点并以q返回。
   // 若链表为空(h指向尾结点)，q=NULL，返回FALSE
   q=h->next;
   if(q) // 链表非空
   {
     h->next=q->next;
     if(!h->next) // 删除尾结点
       L.tail=h; // 修改尾指针
     L.len--;
     return OK;
   }
   else
     return FALSE; // 链表空
 }

 void Append(LinkList &L,Link s)
 { // 将指针s(s->data为第一个数据元素)所指(彼此以指针相链，以NULL结尾)的
   // 一串结点链接在线性链表L的最后一个结点之后，并改变链表L的尾指针指向新的尾结点
   int i=1;
   L.tail->next=s;
   while(s->next)
   {
     s=s->next;
     i++;
   }
   L.tail=s;
   L.len+=i;
 }

 Position PriorPos(LinkList L,Link p)
 { // 已知p指向线性链表L中的一个结点，返回p所指结点的直接前驱的位置。若无前驱，则返回NULL
   Link q;
   q=L.head->next;
   if(q==p) // 无前驱
     return NULL;
   else
   {
     while(q->next!=p) // q不是p的直接前驱
       q=q->next;
     return q;
   }
 }

 Status Remove(LinkList &L,Link &q)
 { // 删除线性链表L中的尾结点并以q返回，改变链表L的尾指针指向新的尾结点
   Link p=L.head;
   if(L.len==0) // 空表
   {
     q=NULL;
     return FALSE;
   }
   while(p->next!=L.tail)
     p=p->next;
   q=L.tail;
   p->next=NULL;
   L.tail=p;
   L.len--;
   return OK;
 }

 void InsBefore(LinkList &L,Link &p,Link s)
 { // 已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之前，
   // 并修改指针p指向新插入的结点
   Link q;
   q=PriorPos(L,p); // q是p的前驱
   if(!q) // p无前驱
     q=L.head;
   s->next=p;
   q->next=s;
   p=s;
   L.len++;
 }

 void InsAfter(LinkList &L,Link &p,Link s)
 { // 已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之后，
   // 并修改指针p指向新插入的结点
   if(p==L.tail) // 修改尾指针
     L.tail=s;
   s->next=p->next;
   p->next=s;
   p=s;
   L.len++;
 }

 void SetCurElem(Link p,ElemType e)
 { // 已知p指向线性链表中的一个结点，用e更新p所指结点中数据元素的值
   p->data=e;
 }

 ElemType GetCurElem(Link p)
 { // 已知p指向线性链表中的一个结点，返回p所指结点中数据元素的值
   return p->data;
 }

 Status ListEmpty(LinkList L)
 { // 若线性链表L为空表，则返回TRUE，否则返回FALSE
   if(L.len)
     return FALSE;
   else
     return TRUE;
 }

 int ListLength(LinkList L)
 { // 返回线性链表L中元素个数
   return L.len;
 }

 Position GetHead(LinkList L)
 { // 返回线性链表L中头结点的位置
   return L.head;
 }

 Position GetLast(LinkList L)
 { // 返回线性链表L中最后一个结点的位置
   return L.tail;
 }

 Position NextPos(Link p)
 { // 已知p指向线性链表L中的一个结点，返回p所指结点的直接后继的位置。若无后继，则返回NULL
   return p->next;
 }

 Status LocatePos(LinkList L,int i,Link &p)
 { // 返回p指示线性链表L中第i个结点的位置，并返回OK，i值不合法时返回ERROR。i=0为头结点
   int j;
   if(i<0||i>L.len)
     return ERROR;
   else
   {
     p=L.head;
     for(j=1;j<=i;j++)
       p=p->next;
     return OK;
   }
 }

 Position LocateElem(LinkList L,ElemType e,Status (*compare)(ElemType,ElemType))
 { // 返回线性链表L中第1个与e满足函数compare()判定关系的元素的位置，
   // 若不存在这样的元素，则返回NULL
   Link p=L.head;
   do
     p=p->next;
   while(p&&!(compare(p->data,e))); // 没到表尾且没找到满足关系的元素
   return p;
 }

 void ListTraverse(LinkList L,void(*visit)(ElemType))
 { // 依次对L的每个数据元素调用函数visit()
   Link p=L.head->next;
   int j;
   for(j=1;j<=L.len;j++)
   {
     visit(p->data);
     p=p->next;
   }
   printf("\n");
 }

 void OrderInsert(LinkList &L,ElemType e,int (*comp)(ElemType,ElemType))
 { // 已知L为有序线性链表，将元素e按非降序插入在L中。(用于一元多项式)
   Link o,p,q;
   q=L.head;
   p=q->next;
   while(p!=NULL&&comp(p->data,e)<0) // p不是表尾且元素值小于e
   {
     q=p;
     p=p->next;
   }
   o=(Link)malloc(sizeof(LNode)); // 生成结点
   o->data=e; // 赋值
   q->next=o; // 插入
   o->next=p;
   L.len++; // 表长加1
   if(!p) // 插在表尾
     L.tail=o; // 修改尾结点
 }

 Status LocateElem(LinkList L,ElemType e,Position &q,int(*compare)(ElemType,ElemType))
 { // 若升序链表L中存在与e满足判定函数compare()取值为0的元素，则q指示L中
   // 第一个值为e的结点的位置，并返回TRUE；否则q指示第一个与e满足判定函数
   // compare()取值>0的元素的前驱的位置。并返回FALSE。(用于一元多项式)
   Link p=L.head,pp;
   do
   {
     pp=p;
     p=p->next;
   }while(p&&(compare(p->data,e)<0)); // 没到表尾且p->data.expn<e.expn
   if(!p||compare(p->data,e)>0) // 到表尾或compare(p->data,e)>0
   {
     q=pp;
     return FALSE;
   }
   else // 找到
   {
     q=p;
     return TRUE;
   }
 }
 }

双向链表：

定义：
 #include<string.h>
 #include<ctype.h>
 #include<malloc.h> /* malloc()? */
 #include<limits.h> /* INT_MAX? */
 #include<stdio.h> /* EOF(=^Z?F6),NULL */
 #include<stdlib.h> /* atoi() */
 #include<io.h> /* eof() */
 #include<math.h> /* floor(),ceil(),abs() */
 #include<process.h> /* exit() */
 /* ???????? */
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
 #define INFEASIBLE -1
 /* #define OVERFLOW -2 ???math.h????OVERFLOW???3,????? */
 typedef int Status; /* Status??????,???????????,?OK? */
 typedef int Boolean; /* Boolean?????,???TRUE?FALSE */
 typedef int ElemType;
 typedef struct DuLNode
 {
   ElemType data;
   DuLNode *prior,*next;
 }DuLNode,*DuLinkList;
Status equal(ElemType c1,ElemType c2);
 int comp(ElemType a,ElemType b);
 void print(ElemType c);
 void print2(ElemType c);
 void print1(ElemType &c);
void InitList(DuLinkList &L);
 void DestroyList(DuLinkList &L);
 void ClearList(DuLinkList L) ;
 Status ListEmpty(DuLinkList L);
 int ListLength(DuLinkList L); 
 Status GetElem(DuLinkList L,int i,ElemType &e);
 int LocateElem(DuLinkList L,ElemType e,Status(*compare)(ElemType,ElemType));
 Status PriorElem(DuLinkList L,ElemType cur_e,ElemType &pre_e);
 Status NextElem(DuLinkList L,ElemType cur_e,ElemType &next_e);
 DuLinkList GetElemP(DuLinkList L,int i) ;
 Status ListInsert(DuLinkList L,int i,ElemType e);
 Status ListDelete(DuLinkList L,int i,ElemType &e) ;
 void ListTraverse(DuLinkList L,void(*visit)(ElemType));
 void ListTraverseBack(DuLinkList L,void(*visit)(ElemType));
实现：
void InitList(DuLinkList &L)
 { // 产生空的双向循环链表L
   L=(DuLinkList)malloc(sizeof(DuLNode));
   if(L)
     L->next=L->prior=L;
   else
     exit(OVERFLOW);
 }

 void DestroyList(DuLinkList &L)
 { // 操作结果：销毁双向循环链表L
   DuLinkList q,p=L->next; // p指向第一个结点
   while(p!=L) // p没到表头
   {
     q=p->next;
     free(p);
     p=q;
   }
   free(L);
   L=NULL;
 }

 void ClearList(DuLinkList L) // 不改变L
 { // 初始条件：L已存在。操作结果：将L重置为空表
   DuLinkList q,p=L->next; // p指向第一个结点
   while(p!=L) // p没到表头
   {
     q=p->next;
     free(p);
     p=q;
   }
   L->next=L->prior=L; // 头结点的两个指针域均指向自身
 }

 Status ListEmpty(DuLinkList L)
 { // 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
   if(L->next==L&&L->prior==L)
     return TRUE;
   else
     return FALSE;
 }

 int ListLength(DuLinkList L)
 { // 初始条件：L已存在。操作结果：返回L中数据元素个数
   int i=0;
   DuLinkList p=L->next; // p指向第一个结点
   while(p!=L) // p没到表头
   {
     i++;
     p=p->next;
   }
   return i;
 }

 Status GetElem(DuLinkList L,int i,ElemType &e)
 { // 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
   int j=1; // j为计数器
   DuLinkList p=L->next; // p指向第一个结点
   while(p!=L&&j<i) // 顺指针向后查找，直到p指向第i个元素或p指向头结点
   {
     p=p->next;
     j++;
   }
   if(p==L||j>i) // 第i个元素不存在
     return ERROR;
   e=p->data; // 取第i个元素
   return OK;
 }

 int LocateElem(DuLinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
 { // 初始条件：L已存在，compare()是数据元素判定函数
   // 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
   //           若这样的数据元素不存在，则返回值为0
   int i=0;
   DuLinkList p=L->next; // p指向第1个元素
   while(p!=L)
   {
     i++;
     if(compare(p->data,e)) // 找到这样的数据元素
       return i;
     p=p->next;
   }
   return 0;
 }

 Status PriorElem(DuLinkList L,ElemType cur_e,ElemType &pre_e)
 { // 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
   //           前驱，否则操作失败，pre_e无定义
   DuLinkList p=L->next->next; // p指向第2个元素
   while(p!=L) // p没到表头
   {
     if(p->data==cur_e)
     {
       pre_e=p->prior->data;
       return TRUE;
     }
     p=p->next;
   }
   return FALSE;
 }

 Status NextElem(DuLinkList L,ElemType cur_e,ElemType &next_e)
 { // 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
   //           否则操作失败，next_e无定义
   DuLinkList p=L->next->next; // p指向第2个元素
   while(p!=L) // p没到表头
   {
     if(p->prior->data==cur_e)
     {
       next_e=p->data;
       return TRUE;
     }
     p=p->next;
   }
   return FALSE;
 }

 DuLinkList GetElemP(DuLinkList L,int i) // 另加
 { // 在双向链表L中返回第i个元素的地址。i为0，返回头结点的地址。若第i个元素不存在，
   // 返回NULL(算法2.18、2.19要调用的函数)
   int j;
   DuLinkList p=L; // p指向头结点
   if(i<0||i>ListLength(L)) // i值不合法
     return NULL;
   for(j=1;j<=i;j++)
     p=p->next;
   return p;
 }

 Status ListInsert(DuLinkList L,int i,ElemType e)
 { // 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1
   // 改进算法2.18，否则无法在第表长+1个结点之前插入元素
   DuLinkList p,s;
   if(i<1||i>ListLength(L)+1) // i值不合法
     return ERROR;
   p=GetElemP(L,i-1); // 在L中确定第i个元素前驱的位置指针p
   if(!p) // p=NULL,即第i个元素的前驱不存在(设头结点为第1个元素的前驱)
     return ERROR;
   s=(DuLinkList)malloc(sizeof(DuLNode));
   if(!s)
     return OVERFLOW;
   s->data=e;
   s->prior=p; // 在第i-1个元素之后插入
   s->next=p->next;
   p->next->prior=s;
   p->next=s;
   return OK;
 }

 Status ListDelete(DuLinkList L,int i,ElemType &e) // 算法2.19
 { // 删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长
   DuLinkList p;
   if(i<1) // i值不合法
     return ERROR;
   p=GetElemP(L,i);  // 在L中确定第i个元素的位置指针p
   if(!p) // p=NULL,即第i个元素不存在
     return ERROR;
   e=p->data;
   p->prior->next=p->next;
   p->next->prior=p->prior;
   free(p);
   return OK;
 }

 void ListTraverse(DuLinkList L,void(*visit)(ElemType))
 { // 由双链循环线性表L的头结点出发，正序对每个数据元素调用函数visit()
   DuLinkList p=L->next; // p指向头结点
   while(p!=L)
   {
     visit(p->data);
     p=p->next;
   }
   printf("\n");
 }

 void ListTraverseBack(DuLinkList L,void(*visit)(ElemType))
 { // 由双链循环线性表L的头结点出发，逆序对每个数据元素调用函数visit()。另加
   DuLinkList p=L->prior; // p指向尾结点
   while(p!=L)
   {
     visit(p->data);
     p=p->prior;
   }
   printf("\n");
 }
Ctios
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编程实现ADT List 基本操作13个（一）顺序结构
宇宙观光巴士站
11-01 3868
编程实现 ADT List 基本操作13个（一） ADT List如下 ADT List { 数据对象:D = {ai|ai∈ElemSet,i=1, 2, …, n, n≥0} 数据关系:R = {<ai-1, a>|ai-1, ai∈D, i=2, …, n} 基本操作: //1.初始化、销毁和清空操作 InitList( &L ) 操作结果:构造一个空的线性表L DestroyList( &L ) 初始条件:线性表L已存在 操作结果:销毁线性
ADT线性表List的定义和顺序表示及实现
最新发布
m0_53360850的博客
03-06 1954
线性表是最常用且最简单的一种数据结构。简言之，一个线性表是n个数据元素的有限序列。至于每个数据元素的具体含义，在不同的情况下各不相同，它可以是一个数字或者一个符号，也可以是一列数字的集合(例如二维数组)，亦或是一串字符(例如字符串数组)，甚至其他更复杂的信息。例如，26个英文字母的字母表：（A，B，C，···，Z）是一个线性表，表中的数据元素是单个字母字符。又如：(6, 17, 28, 50, 92, 188)表中的数据元素是整数。在稍微复杂的线性表中，一个数据元素可以又若干个数据项。
抽象数据类型 ADT
FOR 的博客
08-25 4670
5. 抽象数据类型（ADT） 抽象数据类型 (ADT，Abstract Data Type)是指一个 数学模型 以及定义在此数学模型上的一组操作。 它通常是对数据的某种抽象，定义了数据的 取值范围 及其结构形式，以及对 数据操作 的集合 。抽象数据类型是描述数据结构的一种理论工具，其目的是使人们能够独立于程序的实现细节来理解数据结构的特性。 抽象数据类型 （ abstract data type ） 是从数据使用者的角度去看数据类型。抽象数据类型是对数据的一种抽象描述，是一种数学上的约束。数据结构是ADT的
数据结构（一） 顺序结构ADT List基本操作函数
m0_61598337的博客
08-18 449
完成任何一个操作，都需要函数的调用，而数据结构这本书在写算法前需要将基本操作函数写好
常见抽象数据类型
lllllaaa77的博客
03-27 5673
一、栈 结构：栈顶、栈底 特点：后进先出。从栈顶压入栈，从栈顶压出栈 二、队列 1、队列 结构：队头、队尾 特点：先进先出。从队尾入队列，从队头出队列 2、双端队列 结构：队头、队尾 特点：队头队尾均可入队/出队 3、优先级队列 三、树 1、二叉树 2、AVL树 3、伸展树 4、(2,4)树 5、红黑树 四、图 五、映射 1、哈希表 2、跳跃表 ...
List-ADT:整数列表抽象数据类型
04-29
List.java-双向链接列表ADT Lex.java-程序的主程序。 接受文件输入，按字母顺序输入字符串并打印-结果按字母顺序列出到指定的文件 Makefile-用于编译所有源文件的Makefile 自述文件-包含的程序和文件的描述。
数据结构实验：实现广义表抽象数据类型
11-13
本实验的目标是实现广义表的抽象数据类型（ADT），采用头尾链表和拓展性结构来设计。 首先，我们来理解广义表的定义。广义表是由零个或多个元素组成的，元素可以是原子（不可再分的数据）或者是其他广义表。这种...
AbstractDataTypes-：抽象数据类型
02-10
抽象数据类型（Abstract Data Type，简称ADT）是计算机科学中的一个重要概念，它是指通过一组操作来定义的数据结构。在编程语言中，ADT是一种逻辑上的数据结构，它定义了数据的操作集，而不涉及这些操作的具体实现。...
广义表的抽象数据类型的实现
07-02
广义表（Generalized List）是一种非常重要的抽象数据类型（ADT），在计算机科学中用于表示具有层次结构或树状结构的数据。它是由一对括号包含的零个或多个元素组成，元素可以是原子（不可再分的数据项）或者另一个...
List-Implementation:我自己的列表抽象数据类型的实现
05-02
在Java中，列表抽象数据类型（ADT）通常通过接口`java.util.List`来定义，它提供了丰富的操作方法，如添加、删除、查找元素等。在这个“List-Implementation”项目中，我们看到作者尝试实现自己的列表ADT，这有助于...
adt_list.txt
04-13
这是一个简单数据结构抽象数据类型的代码，用于作为底层开发的代码
单链表的类定义（初学者适用）
05-24
那些刚开始研究数据结构的同学很适合，这个是十分简单的用类写的链表
基于集合的抽象数据类型定义和实现（C++）
08-07
这是数据结构中的常见数据类型定义，里面实现了集合的一些基本操作，例如交并等。
如何理解数据结构中的抽象数据类型？
热门推荐
新海说
09-04 3万+
抽象数据类型的标准格式 ADT 抽象数据类型名 { Data: 数据元素之间逻辑关系的定义； Operation: 操作1； 操作2； ... } 什么是抽象数据类型？ 抽象数据类型（Abstract Data Type,ADT）是指一个数学模型以及定义在这个模型上的一组操作。 抽象数据类型的定义仅仅取决于它的一组逻辑特性，而与它在计算机中的表示和实现无关。 例如，int类型的数据表示的...
线性表ADT(List)
wkwk7600的博客
06-12 3838
线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。
数据结构与算法学习笔记——List ADT C++实现
weixin_46574339的博客
02-12 1064
这里写目录标题一级目录二级目录三级目录 一级目录 二级目录 三级目录
List ADT的两种实现方式
heyahuihh的博客
01-03 4785
ArrayList类和LinkedList类 List ADT 有两种流行的实现方式，ArrayList类与LinkedList类。
抽象数据类型线性表（顺序表）的定义构造
AKK188888881的博客
07-09 1843
抽象数据类型线性表（顺序表）的定义构造 main.cpp #include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASALBE -1 #define OVERFLOW -2 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define ElemType int
数据结构与算法课程笔记（二）
Motseturtle的博客
11-01 9292
实验二 线性表的顺序存储结构实现一、实验目的二、实验内容 一、实验目的 熟悉VC++工程项目的文件组织方式； 线性表中数据元素间的关系及其顺序存储结构方式表示方法； 顺序表的操作方法与接口函数的设计方法。 二、实验内容 1． 利用本次实验提供的文件（listinarray.h、listinarray.cpp、content.cpp），创建并观察项目，回答下面问题。 文件说明： 【listinarray.h】顺序表的类型声明和操作接口声明 【listinarray.cpp】顺序表的操作实现代码 【con
线性表的抽象数据类型与操作详解
"《数据结构》第二章讲义——线性表的抽象数据类型与实现" 线性表是数据结构中的基础概念，它是一个有序的数据元素集合，具有以下特性： 1. 存储数据的集合中有一个且仅有一个起始元素，称为第一个元素。 2. 存储...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值