Init List L Destroy List L List Empty

基本操作： Init. List( &L ) 结构初始化操作 Destroy. List( &L ) 结构销毁操作 List. Empty( L ) List. Length( L ) Prior. Elem( L, cur_e, &pre_e ) 引用型操作 Next. Elem( L, cur_e, &next_e ) Get. Elem( L, i, &e ) List. Traverse(L, visit( )) Locate. Elem( L, e, compare( ) ) Clear. List( &L ) Put. Elem( &L, i, &e ) List. Insert( &L, i, e ) List. Delete(&L, i, &e) } ADT List 加 型操作

V数组下标 内存 元素序号 0 a 0 1 1 a 1 2 n-1 an-1 n 备 用 空 间 maxsize-1 #define maxsize 1000 int data[maxsize]; 例 typedef struct card { int num; char name[20]; char author[10]; char publisher[30]; float price; }DATATYPE; DATATYPE library[maxsize]; 数据元素不是简单类型时, 可定义结构体数组

Status Init. List_Sq( Sq. List & L) { // 构造一个最大容量为 LIST_INIT_SIZE 的顺序表 L. elem = (Elem. Type*)malloc(LIST_INIT_SIZE *sizeof( Elem. Type)); // 为顺序表分配大小为 LIST_INIT_SIZE 的数组空间 if (!L. elem) exit(OVERFLOW); L. length = 0; L. listsize = LIST_INIT_SIZE; return OK; } // Init. List_Sq

Status List. Insert_Sq(Sq. List &L, int i, Elem. Type e) { // 在顺序表L的第 i 个元素之前插入新的元素e, // i 的合法范围为 1≤i≤L. length+1 Elem. Type * newbase, *q, *p; //所需变量的定义 if(i<1||i>L. length +1) return ERROR//i值不合法 if(L. length>=L. listsize{ //当前存储空间已满，增加分配 newbase=(Elem. Type*)realloc(L. elem, (L. listsize+LISTINCREMET)*sizeof(Elem. Type))}); if(newbase)exit(OVERFLOW); //存储分配失败 L. elem=newbase; //新基址 L. listsize+=LISTINCREMENT; //增加存储容量 } // }List. Insert_Sq

(a 1, …, ai-1, ai+1, …, an) 改变为 (a 1, …, ai-1, ai+1, …, an) <ai-1, ai>, <ai, ai+1> <ai-1, ai+1> a 1 a 2 … ai-1 ai ai+1 … an a 1 a 2 … ai-1 ai+1 … an 表的长度减少

v La v h i Lb y i v a i v c v f i c i e v z i d v b i v e d

void unionlist(Sq. List &La, Sq. List Lb) { //将所有在线性表Lb中但不在La中的数据元素插入到La中 int La_len, Lb_len, i; Elem. Type e; La_len=List. Length(La); Lb_len=List. Length(Lb); //求线性表的长度 for (i = 1; i<=Lb_len; i++){ Get. Elem(Lb, i, e); //取Lb中第i个数据元素赋给e if(!Locate. Elem(La, e)) List. Insert(La, ++La_len, e); //La中不存在和e相同的数据元素，则插入之 } }

int main() //主程序用来验证unionlist算法以及部分基本操作 { int i; Sq. List Lc, Ld; Init. List(Lc); //构造空的顺序表Lc和Ld Init. List(Ld); for(i=1; i<5; i++) List. Insert(Lc, i, i); //构造顺序表Lc=(1, 2, 3, 4) for(i=1; i<5; i++) List. Insert(Ld, i, 2*i); //构造顺序表Ld=(2, 4, 6, 8) unionlist(Lc, Ld) //验证Lc∪Ld算法 for(i=0; i<Lc. length; i++) printf("%d ", Lc. elem[i]); return 0; }

2 Lc 3 5 6 8 8 La 3 i Lb 5 i 2 j 8 i 6 j 11 i 8 j 9 j 11 j 8 9 11 11

void Merge. List(Sq. List La, Sq. List Lb, Sq. List &Lc) { //归并La和Lb得到新的线性表Lc，Lc的数据元素按值从小到 大升序排列 int i=1, j=1, k=1; int La_len, Lb_len; Elem. Type ai, bj; La_len=List. Length(La); Lb_len = List. Length(Lb); while( (i<=La_len)&&(j<=Lb_len)){//La和Lb均非空 Get. Elem(La, i, ai); Get. Elem(Lb, j, bj); if (ai<=bj){List. Insert(Lc, k++, ai); i++; } else{List. Insert(Lc, k++, bj); j++; } } while(i<=La_len) {//插入La中剩下的元素 Get. Elem(La, i++, ai); List. Insert(Lc, k++, ai); } while (j<=Lb_len) { //插入Lb中剩下的元素 Get. Elem(Lb, j++, bj); List. Insert(Lc, k++, bj); } }

int main() //主程序用来验证Merge. List算法的实现 { int i; Sq. List Lc, Ld, Le; Init. List(Lc); //构造空的顺序表Lc、Ld和 Init. List(Ld); Init. List(Le); for(i=1; i<5; i++) List. Insert(Lc, i, i); //构造升序顺序表Lc=(1, 2, 3, 4) for(i=1; i<5; i++) List. Insert(Ld, i, 2*i); //构造升序顺序表Ld=(2, 4, 6, 8) Merge. List(Lc, Ld, Le); //验证Lc和Ld归并算法 printf("Lc和Ld归并的结果为: n"); for(i=0; i<Le. length; i++) printf(" %d ", Le. elem[i]); printf("n"); return 0; }

2. 3. 2 单链表基本操作实现 void Init. List(Link. List &L) //构造一个空单链表 int List. Length(Link. List L) //求单链表长度 List. Insert(&L, i, e) // 插入数据元素 List. Delete(&L, i, e) Get. Elem(L, i, e) // 删除数据元素 // 取第i个数据元素 List. Empty(Link. List L) // 单链表是否为空 Locat. Elem(Link. List L, Elem. Type e) // 按值查找单链表

Status List. Insert_L(Link. List L, int i, Elem. Type e) { // L 为带头结点的单链表的头指针，本算法 // 在链表中第i 个结点之前插入新的元素 e Link. List p=L, s; int j=0; while (p && j < i-1) { p = p->next; j ++; } // 寻找第 i-1 个结点 if (!p || j > i-1) return ERROR; // i 大于表长或者小于1 s = （Link. List）malloc(sizeof(Lnode)) ; // 生成新结点 if ( s == NULL) return ERROR; s->data = e; s->next = p->next; p->next = s; // 插入 return OK; } // Linst. Insert_L 算法的时间复杂度为: O(List. Length(L))

L a 1 P …. . ai-1 p ai …. . an

s = （Link. List）malloc(sizeof(Lnode)) ; // 生成新结点 if ( s == NULL) return ERROR; s->data = e; s->next = p->next; p->next = s; // 插入 return OK; p ai-1 s ai e

Status List. Delete_L(Link. List L, int i, Elem. Type &e) { // 删除以 L 为头指针(带头结点)的单链表中第 i 个结点 Link. List p=L, q; int j=0; while (p && j < i-1) { p = p->next; ++j; } // 寻找第 i-1 个结点，并令 p 指向其前趋 if (!(p->next) || j > i-1) return ERROR; // 删除位置不合理 q = p->next; p->next = q->next; e = q->data; free(q); return OK; } // List. Delete_L // 删除并释放结点 算法的时间复杂度为: O(List. Length(L))

L a 1 P j=0 …. . ai-1 P j=i-2 ai …. . an

void Create. List_L(Link. List &L, int n) { // 逆序输入 n 个数据元素，建立带头结点的单链表 Link. List p, int i; //算法所需变量的定义 L = (Link. List)malloc(sizeof(LNode)) L->next = NULL; // 先建立一个带头结点的单链表 for (i = n; i > 0; i --) { p = (Link. List)malloc(sizeof(Lnode)) ; scanf(“%d”, &p->data); // 输入元素值 p->next = L->next; L->next = p; // 插入 } 算法的时间复杂度为: O(Listlength(L)) } // Create. List_L

n n n n n int main() //主程序用来验证 unionlist算法以及部分基本操作 { int i; Link. List Lc, Ld; Init. List(Lc); //构造空的单链表Lc和Ld Init. List(Ld); for(i=1; i<5; i++) List. Insert(Lc, i, i); //构造单链表Lc=(1, 2, 3, 4) for(i=1; i<5; i++) List. Insert(Ld, i, 2*i); //构造单链表表Ld=(2, 4, 6, 8) unionlist(Lc, Ld) //验证Lc∪Ld算法 printf(" 归并后的结果为: n "); for(i=1; i<=List. Length(Lc); i++) { Get. Elem(Lc, i, e); //用e返回单链表的第i个元素，并打印输出 printf("%d ", e); } return 0; }

n n n n n 将两表合并成一表的算法实现如下： #include"head 1 -1. h" #include"mem 2 -2. cpp" #include"op 2 -2. cpp" void Merge. List(Link. List &La, Link. List &Lb, Link. List &Lc) { //已知单链线性表La和Lb的元素按值升序排列 //归并La和Lb得到新的单链线性表Lc , Lc的元素也按值升序排列 Link. List pa, pb, pc; pa=La->next; pb=Lb ->next ; Lc=pc=La; //用La的头结点作为Lc的头结点 while (pa&&pb){ if (pa ->data<= pb->data) { pc->next=pa; pc=pa; pa=pa->next; } else { pc->next=pb; pc=pb; pb=pb->next; } } pc->next = pa? pa: pb; //链上剩余链表段 free(Lb); //释放Lb的头结点 }

ai-1 ai ai+1 p p->next->prior=p p=p->prior->next

插入 p ai-1 ai e s s->next = p->next; p->next = s; s->next->prior = s; s->prior = p;

删除 ai-1 ai ai+1 p p->prior->next = p->next; p->next->prior = p->prior; free(p);