1.3 链表

1.3.1 头插法建立单链表

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. typedef   char  datatype;
  4. typedef   struct node{
  5.     datatype data;
  6.     struct  node *next;
  7. } listnode;
  8. typedef  listnode  *linklist;
  9. listnode  *p;
  10. linklist  createlist(void)
  11. {
  12.       char ch;
  13.       linklist  head;
  14.       listnode  *p;
  15.       head=NULL;/*初始化为空*/
  16.       ch=getchar( );
  17.       while (ch!='\n'){
  18.            p=(listnode*)malloc(sizeof(listnode));/*分配空间*/
  19.            p->data=ch;/*数据域赋值*/
  20.            p->next=head;/*指定后继指针*/
  21.            head=p;/*head指针指定到新插入的结点上*/
  22.               ch=getchar( );
  23.       }
  24.       return (head);
  25. }
  26. int main()
  27. {
  28.     linklist newlist=createlist();
  29.     do
  30.     {
  31.        printf("%c\n",newlist->data);
  32.        newlist=newlist->next;
  33.     }while(newlist!=NULL);
  34.     printf("\n");
  35.     return 0;
  36. }

运行结果

1.3.2 限制链表长度建立单链表

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #define N    4
  4. typedef   char  datatype;
  5. typedef   struct node{
  6. datatype  data;
  7. struct  node *next;
  8. } listnode;
  9. typedef  listnode  *linklist;
  10. listnode  *p;
  11. linklist  createlist(int n)
  12. {
  13.     int i;
  14.     linklist  head;
  15.     listnode *p;
  16.     head=NULL;
  17.     for(i=n;i>0;--i)/*指定长度为n,插入次数受限制*/
  18.     {
  19.         p=(listnode*)malloc(sizeof(listnode));
  20.         scanf("%c",&p->data);
  21.         p->next=head;
  22.         head=p;
  23.     }
  24.     return(head);
  25. }
  26. int main()
  27. {
  28.     linklist newlist=createlist(N);
  29.     do
  30.     {
  31.        printf("%c",newlist->data);
  32.        newlist=newlist->next;
  33.     }while(newlist!=NULL);
  34.     printf("\n");
  35.     return 0;
  36. }

运行结果

1.3.3 尾插法建立单链表

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #define N    4
  4. typedef   char  datatype;
  5. typedef      struct    node{
  6. datatype      data;
  7. struct     node  *next;
  8. } listnode;
  9. typedef  listnode  *linklist;
  10. listnode  *p;
  11.  linklist  creater()
  12. {
  13.     char  ch;
  14.     linklist  head;
  15.     listnode  *p,*r;
  16.     head=NULL;
  17.     r=NULL;/*r为尾指针*/
  18.     while((ch=getchar())!='\n'){
  19.         p=(listnode *)malloc(sizeof(listnode));
  20.         p->data=ch;
  21.         if(head==NULL)
  22.             head=p;/*head 指向第一个插入结点*/
  23.         else
  24.             r->next=p;/*插入到链表尾部*/
  25.         r=p;/*r指向最新结点，即最后结点*/
  26.      }
  27.      if (r!=NULL)
  28.           r->next=NULL;/*链表尾部结点的后继指针指定为空*/
  29.      return(head);
  30.  }
  31. int main()
  32. {
  33.     linklist newlist=creater();
  34.     do
  35.     {
  36.        printf("%c",newlist->data);
  37.        newlist=newlist->next;
  38.     }while(newlist!=NULL);
  39.     printf("\n");
  40.     return 0;
  41. }

运行结果

1.3.4 按序号查找单链表

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef char datatype;
  5. typedef struct node {
  6.     datatype data;
  7.     struct node *next;
  8. } listnode;
  9. typedef listnode *linklist;
  10. listnode *p;
  12. linklist createlist(void) {
  13.     char ch;
  14.     linklist head;
  15.     listnode *p;
  16.     head = NULL;/*初始化为空*/
  17.     ch = getchar();
  18.     while (ch != '\n') {
  19.         p = (listnode *) malloc(sizeof(listnode));/*分配空间*/
  20.         p->data = ch;/*数据域赋值*/
  21.         p->next = head;/*指定后继指针*/
  22.         head = p;/*head指针指定到新插入的结点上*/
  23.         ch = getchar();
  24.     }
  25.     return (head);
  26. }
  28. listnode *getnode(linklist head, int i) {
  29.     int j;
  30.     listnode *p;
  31.     p = head;
  32.     j = 0;
  33.     while (p->next && j < i) {/*遍历第i个结点前的所有结点*/
  34.         p = p->next;
  35.         j++;
  36.     }
  37.     if (i == j) {
  38.         printf("%c\n", p->data);
  39.         return p;
  40.     } else
  41.         return NULL;
  42. }
  44. int main() {
  45.     linklist list;
  46.     listnode *node;
  47.     int i = 0;
  48.     list = createlist();
  49.     node = getnode(list, i);
  50.     return 0;
  51. }

运行结果

1.3.5 按值查找单链表

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef char datatype;
  5. typedef struct node {
  6.     datatype data;
  7.     struct node *next;
  8. } listnode;
  9. typedef listnode *linklist;
  10. listnode *p;
  12. linklist createlist(void) {
  13.     char ch;
  14.     linklist head;
  15.     listnode *p;
  16.     head = NULL;/*初始化为空*/
  17.     ch = getchar();
  18.     while (ch != '\n') {
  19.         p = (listnode *) malloc(sizeof(listnode));/*分配空间*/
  20.         p->data = ch;/*数据域赋值*/
  21.         p->next = head;/*指定后继指针*/
  22.         head = p;/*head指针指定到新插入的结点上*/
  23.         ch = getchar();
  24.     }
  25.     return (head);
  26. }
  28. listnode *locatenode(linklist head, char key) {
  29.     listnode *p = head;
  30.     while (p->next && p->data != key)
  31.         p = p->next;
  32.     if (p != NULL)
  33.         printf("%c\n", p->data);
  34.     return p;
  35. }
  37. int main() {
  38.     linklist list;
  39.     listnode *node;
  40.     char key = 'c';
  41.     list = createlist();
  42.     node = locatenode(list, key);
  43.     return 0;
  44. }

运行结果

1.3.6 链表的插入

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef char datatype;
  5. typedef struct node {
  6.     datatype data;
  7.     struct node *next;
  8. } listnode;
  9. typedef listnode *linklist;
  10. listnode *p;
  12. linklist createlist(void) {
  13.     char ch;
  14.     linklist head;
  15.     listnode *p;
  16.     head = NULL;/*初始化为空*/
  17.     ch = getchar();
  18.     while (ch != '\n') {
  19.         p = (listnode *) malloc(sizeof(listnode));/*分配空间*/
  20.         p->data = ch;/*数据域赋值*/
  21.         p->next = head;/*指定后继指针*/
  22.         head = p;/*head指针指定到新插入的结点上*/
  23.         ch = getchar();
  24.     }
  25.     return (head);
  26. }
  28. void insertnode(linklist head, char x, int i) {
  29.     int j = 0;
  30.     listnode *p, *s;
  31.     p = head;
  32.     while (p && j < i - 1) {
  33.         p = p->next;
  34.         ++j;
  35.     }
  36.     if (!p || j > i - 1)
  37.         exit(1);
  38.     s = (linklist) malloc(sizeof(listnode));
  39.     s->data = x;
  40.     s->next = p->next;
  41.     p->next = s;
  42. }
  44. int main() {
  45.     linklist list;
  46.     int i = 1;
  47.     char x = 'c';
  48.     list = createlist();
  49.     insertnode(list, x, i);
  50.     do {
  51.         printf("%c", list->data);
  52.         list = list->next;
  53.     } while (list != NULL);
  54.     printf("\n");
  55.     return 0;
  56. }

运行结果

1.3.7 链表的删除

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. typedef   char  datatype;
  4. typedef      struct    node{
  5.     datatype      data;
  6.     struct     node  *next;
  7. } listnode;
  8. typedef  listnode  *linklist;
  9. listnode  *p;
  10. linklist  createlist(void)
  11. {
  12.       char ch;
  13.       linklist  head;
  14.       listnode  *p;
  15.       head=NULL;/*初始化为空*/
  16.       ch=getchar( );
  17.       while (ch!='\n'){
  18.            p=(listnode*)malloc(sizeof(listnode));/*分配空间*/
  19.            p->data=ch;/*数据域赋值*/
  20.            p->next=head;/*指定后继指针*/
  21.            head=p;/*head指针指定到新插入的结点上*/
  22.               ch=getchar( );
  23.       }
  24.       return (head);
  25. }
  26. void  deletelist(linklist head,int i)
  27. {
  28. int j=0;
  29.     listnode * p,*r;
  30.     p=head;
  31.     while(p&&j<i-1){
  32.         p=p->next;
  33.         ++j;
  34.     }
  35.     if(!p->next||j>i-1)
  36.         exit(1);
  37.     r=p->next;
  38.     p->next=r->next;
  39.     free(r) ;
  40. }
  42. int main()
  43. {
  44.     linklist    list;
  45.     int i=1;
  46.     list=createlist();
  47.     deletelist(list,i);
  48.     do
  49.     {
  50.        printf("%c",list->data);
  51.        list=list->next;
  52.     }while(list!=NULL);
  53.     printf("\n");
  54.     return 0;
  55. }

1.3.8 归并两个单链表

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef char datatype;
  5. typedef struct node {
  6.     datatype data;
  7.     struct node *next;
  8. } listnode;
  9. typedef listnode *linklist;
  10. listnode *p;
  12. linklist createlist(void) {
  13.     char ch;
  14.     linklist head;
  15.     listnode *p;
  16.     head = NULL;/*初始化为空*/
  17.     ch = getchar();
  18.     while (ch != '\n') {
  19.         p = (listnode *) malloc(sizeof(listnode));/*分配空间*/
  20.         p->data = ch;/*数据域赋值*/
  21.         p->next = head;/*指定后继指针*/
  22.         head = p;/*head指针指定到新插入的结点上*/
  23.         ch = getchar();
  24.     }
  25.     return (head);
  26. }
  28. linklist concatenate(linklist list1, linklist list2) {
  29.     listnode *temp;
  30.     if (list1 == NULL)
  31.         return list2;
  32.     else {
  33.         if (list2 != NULL) {
  34.             for (temp = list1; temp->next; temp = temp->next); /*遍历到list1的末尾*/
  35.             temp->next = list2;/*将list2链接到list1末尾*/
  36.         }
  37.     }
  38.     return list1;
  39. }
  41. int main() {
  42.     linklist list1, list2, list3;
  43.     list1 = createlist();
  44.     list2 = createlist();
  45.     list3 = concatenate(list1, list2);
  46.     do {
  47.         printf("%c", list3->data);
  48.         list3 = list3->next;
  49.     } while (list3 != NULL);
  50.     printf("\n");
  51.     return 0;
  52. }

1.3.9 初始化单循环链表

  1. #include<stdio.h> /* EOF(=^Z或F6),NULL */
  2. #include<stdlib.h>
  3. #include<math.h> /* floor(),ceil(),abs() */
  5. #define TRUE 1
  6. #define FALSE 0
  7. #define OK 1
  8. #define ERROR 0
  9. #define OVERFLOW -1
  10. typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
  11. typedef int ElemType;
  12. /* c2-2.h 线性表的单链表存储结构 */
  13. struct LNode {
  14.     ElemType data;
  15.     struct LNode *next;
  16. };
  17. typedef struct LNode *LinkList; /* 另一种定义LinkList的方法 */
  18. Status InitList_CL(LinkList *L) { /* 操作结果：构造一个空的线性表L */
  19.     *L = (LinkList) malloc(sizeof(struct LNode)); /* 产生头结点,并使L指向此头结点 */
  20.     if (!*L) /* 存储分配失败 */
  21.         exit(OVERFLOW);
  22.     (*L)->next = *L; /* 指针域指向头结点 */
  23.     return OK;
  24. }
  26. Status ListEmpty_CL(LinkList L) { /* 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
  27.     if (L->next == L) /* 空 */
  28.         return TRUE;
  29.     else
  30.         return FALSE;
  31. }
  33. int ListLength_CL(LinkList L) { /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */
  34.     int i = 0;
  35.     LinkList p = L->next; /* p指向头结点 */
  36.     while (p != L) /* 没到表尾 */
  37.     {
  38.         i++;
  39.         p = p->next;
  40.     }
  41.     return i;
  42. }
  44. Status GetElem_CL(LinkList L, int i, ElemType *e) { /* 当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR */
  45.     int j = 1; /* 初始化,j为计数器 */
  46.     LinkList p = L->next->next; /* p指向第一个结点 */
  47.     if (i <= 0 || i > ListLength_CL(L)) /* 第i个元素不存在 */
  48.         return ERROR;
  49.     while (j < i) { /* 顺指针向后查找,直到p指向第i个元素 */
  50.         p = p->next;
  51.         j++;
  52.     }
  53.     *e = p->data; /* 取第i个元素 */
  54.     return OK;
  55. }
  57. Status ListInsert_CL(LinkList *L, int i, ElemType e) /* 改变L */
  58. { /* 在L的第i个位置之前插入元素e */
  59.     LinkList p = (*L)->next, s; /* p指向头结点 */
  60.     int j = 0;
  61.     if (i <= 0 || i > ListLength_CL(*L) + 1) /* 无法在第i个元素之前插入 */
  62.         return ERROR;
  63.     while (j < i - 1) /* 寻找第i-1个结点 */
  64.     {
  65.         p = p->next;
  66.         j++;
  67.     }
  68.     s = (LinkList) malloc(sizeof(struct LNode)); /* 生成新结点 */
  69.     s->data = e; /* 插入L中 */
  70.     s->next = p->next;
  71.     p->next = s;
  72.     if (p == *L) /* 改变尾结点 */
  73.         *L = s;
  74.     return OK;
  75. }
  77. Status ListTraverse_CL(LinkList L, void(*vi)(ElemType)) { /* 初始条件:L已存在。操作结果:依次对L的每个数据元素调用函数vi()。一旦vi()失败,则操作失败 */
  78.     LinkList p = L->next->next;
  79.     while (p != L->next) {
  80.         vi(p->data);
  81.         p = p->next;
  82.     }
  83.     printf("\n");
  84.     return OK;
  85. }
  87. void visit(ElemType c) {
  88.     printf("%d ", c);
  89. }
  91. int main() {
  92.     LinkList L;
  93.     ElemType e;
  94.     int j;
  95.     Status i;
  96.     i = InitList_CL(&L); /* 初始化单循环链表L */
  97.     printf("初始化单循环链表L i=%d (1:初始化成功)\n", i);
  98.     i = ListEmpty_CL(L);
  99.     printf("L是否空 i=%d(1:空 0:否)\n", i);
  100.     ListInsert_CL(&L, 1, 3); /* 在L中依次插入3,5 */
  101.     ListInsert_CL(&L, 2, 5);
  102.     i = GetElem_CL(L, 1, &e);
  103.     j = ListLength_CL(L);
  104.     printf("L中数据元素个数=%d,第1个元素的值为%d。\n", j, e);
  105.     printf("L中的数据元素依次为：");
  106.     ListTraverse_CL(L, visit);
  107.     return 0;
  108. }

运行结果

1.3.10 查询元素的前驱和后继

  1. #include<stdio.h> /* EOF(=^Z或F6),NULL */
  2. #include<stdlib.h>
  3. #include<math.h> /* floor(),ceil(),abs() */
  5. #define TRUE 1
  6. #define FALSE 0
  7. #define OK 1
  8. #define ERROR 0
  9. #define OVERFLOW -1
  10. typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
  11. typedef int ElemType;
  12. struct LNode {
  13.     ElemType data;
  14.     struct LNode *next;
  15. };
  16. typedef struct LNode *LinkList; /* 另一种定义LinkList的方法 */
  17. Status InitList_CL(LinkList *L) { /* 操作结果：构造一个空的线性表L */
  18.     *L = (LinkList) malloc(sizeof(struct LNode)); /* 产生头结点,并使L指向此头结点 */
  19.     if (!*L) /* 存储分配失败 */
  20.         exit(OVERFLOW);
  21.     (*L)->next = *L; /* 指针域指向头结点 */
  22.     return OK;
  23. }
  25. Status ListEmpty_CL(LinkList L) { /* 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
  26.     if (L->next == L) /* 空 */
  27.         return TRUE;
  28.     else
  29.         return FALSE;
  30. }
  32. int ListLength_CL(LinkList L) { /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */
  33.     int i = 0;
  34.     LinkList p = L->next; /* p指向头结点 */
  35.     while (p != L) /* 没到表尾 */
  36.     {
  37.         i++;
  38.         p = p->next;
  39.     }
  40.     return i;
  41. }
  43. Status GetElem_CL(LinkList L, int i, ElemType *e) { /* 当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR */
  44.     int j = 1; /* 初始化,j为计数器 */
  45.     LinkList p = L->next->next; /* p指向第一个结点 */
  46.     if (i <= 0 || i > ListLength_CL(L)) /* 第i个元素不存在 */
  47.         return ERROR;
  48.     while (j < i) { /* 顺指针向后查找,直到p指向第i个元素 */
  49.         p = p->next;
  50.         j++;
  51.     }
  52.     *e = p->data; /* 取第i个元素 */
  53.     return OK;
  54. }
  56. Status ListInsert_CL(LinkList *L, int i, ElemType e) /* 改变L */
  57. { /* 在L的第i个位置之前插入元素e */
  58.     LinkList p = (*L)->next, s; /* p指向头结点 */
  59.     int j = 0;
  60.     if (i <= 0 || i > ListLength_CL(*L) + 1) /* 无法在第i个元素之前插入 */
  61.         return ERROR;
  62.     while (j < i - 1) /* 寻找第i-1个结点 */
  63.     {
  64.         p = p->next;
  65.         j++;
  66.     }
  67.     s = (LinkList) malloc(sizeof(struct LNode)); /* 生成新结点 */
  68.     s->data = e; /* 插入L中 */
  69.     s->next = p->next;
  70.     p->next = s;
  71.     if (p == *L) /* 改变尾结点 */
  72.         *L = s;
  73.     return OK;
  74. }
  76. Status PriorElem_CL(LinkList L, ElemType cur_e, ElemType *pre_e) { /* 初始条件：线性表L已存在 */
  77.     /* 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱， */
  78.     /*           否则操作失败，pre_e无定义 */
  79.     LinkList q, p = L->next->next; /* p指向第一个结点 */
  80.     q = p->next;
  81.     while (q != L->next) /* p没到表尾 */
  82.     {
  83.         if (q->data == cur_e) {
  84.             *pre_e = p->data;
  85.             return TRUE;
  86.         }
  87.         p = q;
  88.         q = q->next;
  89.     }
  90.     return FALSE;
  91. }
  93. Status NextElem_CL(LinkList L, ElemType cur_e, ElemType *next_e) { /* 初始条件：线性表L已存在 */
  94.     /* 操作结果：若cur_e是L的数据元素,且不是最后一个,则用next_e返回它的后继， */
  95.     /*           否则操作失败，next_e无定义 */
  96.     LinkList p = L->next->next; /* p指向第一个结点 */
  97.     while (p != L) /* p没到表尾 */
  98.     {
  99.         if (p->data == cur_e) {
  100.             *next_e = p->next->data;
  101.             return TRUE;
  102.         }
  103.         p = p->next;
  104.     }
  105.     return FALSE;
  106. }
  108. void visit(ElemType c) {
  109.     printf("%d ", c);
  110. }
  112. int main() {
  113.     LinkList L;
  114.     ElemType e;
  115.     int j;
  116.     Status i;
  117.     i = InitList_CL(&L); /* 初始化单循环链表L */
  118.     printf("初始化单循环链表L i=%d (1:初始化成功)\n", i);
  119.     i = ListEmpty_CL(L);
  120.     printf("L是否空 i=%d(1:空 0:否)\n", i);
  121.     ListInsert_CL(&L, 1, 3); /* 在L中依次插入3,5 */
  122.     ListInsert_CL(&L, 2, 5);
  123.     printf("依次插入元素3和5\n");
  124.     PriorElem_CL(L, 5, &e); /* 求元素5的前驱 */
  125.     printf("5前面的元素的值为%d。\n", e);
  126.     NextElem_CL(L, 3, &e); /* 求元素3的后继 */
  127.     printf("3后面的元素的值为%d。\n", e);
  128.     return 0;
  129. }

运行结果

1.3.11 单循环链表中元素的删除

  1. #include<stdio.h> /* EOF(=^Z或F6),NULL */
  2. #include<math.h> /* floor(),ceil(),abs() */
  3. #include<stdlib.h>
  4. /* 函数结果状态代码 */
  5. #define TRUE 1
  6. #define FALSE 0
  7. #define OK 1
  8. #define ERROR 0
  9. #define OVERFLOW 3
  10. typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
  11. typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
  12. typedef int ElemType;
  13. struct LNode {
  14.     ElemType data;
  15.     struct LNode *next;
  16. };
  17. typedef struct LNode *LinkList; /* 另一种定义LinkList的方法 */
  18. Status InitList_CL(LinkList *L) { /* 操作结果：构造一个空的线性表L */
  19.     *L = (LinkList) malloc(sizeof(struct LNode)); /* 产生头结点,并使L指向此头结点 */
  20.     if (!*L) /* 存储分配失败 */
  21.         exit(OVERFLOW);
  22.     (*L)->next = *L; /* 指针域指向头结点 */
  23.     return OK;
  24. }
  26. int ListLength_CL(LinkList L) { /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */
  27.     int i = 0;
  28.     LinkList p = L->next; /* p指向头结点 */
  29.     while (p != L) /* 没到表尾 */
  30.     {
  31.         i++;
  32.         p = p->next;
  33.     }
  34.     return i;
  35. }
  37. int LocateElem_CL(LinkList L, ElemType e, Status(*compare)(ElemType, ElemType)) { /* 初始条件：线性表L已存在，compare()是数据元素判定函数 */
  38.     /* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。 */
  39.     /*           若这样的数据元素不存在，则返回值为0 */
  40.     int i = 0;
  41.     LinkList p = L->next->next; /* p指向第一个结点 */
  42.     while (p != L->next) {
  43.         i++;
  44.         if (compare(p->data, e)) /* 满足关系 */
  45.             return i;
  46.         p = p->next;
  47.     }
  48.     return 0;
  49. }
  51. Status ListInsert_CL(LinkList *L, int i, ElemType e) /* 改变L */
  52. { /* 在L的第i个位置之前插入元素e */
  53.     LinkList p = (*L)->next, s; /* p指向头结点 */
  54.     int j = 0;
  55.     if (i <= 0 || i > ListLength_CL(*L) + 1) /* 无法在第i个元素之前插入 */
  56.         return ERROR;
  57.     while (j < i - 1) /* 寻找第i-1个结点 */
  58.     {
  59.         p = p->next;
  60.         j++;
  61.     }
  62.     s = (LinkList) malloc(sizeof(struct LNode)); /* 生成新结点 */
  63.     s->data = e; /* 插入L中 */
  64.     s->next = p->next;
  65.     p->next = s;
  66.     if (p == *L) /* 改变尾结点 */
  67.         *L = s;
  68.     return OK;
  69. }
  71. Status ListDelete_CL(LinkList *L, int i, ElemType *e) /* 改变L */
  72. { /* 删除L的第i个元素,并由e返回其值 */
  73.     LinkList p = (*L)->next, q; /* p指向头结点 */
  74.     int j = 0;
  75.     if (i <= 0 || i > ListLength_CL(*L)) /* 第i个元素不存在 */
  76.         return ERROR;
  77.     while (j < i - 1) /* 寻找第i-1个结点 */
  78.     {
  79.         p = p->next;
  80.         j++;
  81.     }
  82.     q = p->next; /* q指向待删除结点 */
  83.     p->next = q->next;
  84.     *e = q->data;
  85.     if (*L == q) /* 删除的是表尾元素 */
  86.         *L = p;
  87.     free(q); /* 释放待删除结点 */
  88.     return OK;
  89. }
  91. Status ListTraverse_CL(LinkList L, void(*vi)(ElemType)) { /* 初始条件:L已存在。操作结果:依次对L的每个数据元素调用函数vi()。一旦vi()失败,则操作失败 */
  92.     LinkList p = L->next->next;
  93.     while (p != L->next) {
  94.         vi(p->data);
  95.         p = p->next;
  96.     }
  97.     printf("\n");
  98.     return OK;
  99. }
  101. Status compare(ElemType c1, ElemType c2) {
  102.     if (c1 == c2)
  103.         return TRUE;
  104.     else
  105.         return FALSE;
  106. }
  108. void visit(ElemType c) {
  109.     printf("%d ", c);
  110. }
  112. int main() {
  113.     LinkList L;
  114.     ElemType e;
  115.     int j;
  116.     Status i;
  117.     i = InitList_CL(&L); /* 初始化单循环链表L */
  118.     printf("依次在单循环链表中插入3,5\n");
  119.     ListInsert_CL(&L, 1, 3); /* 在L中依次插入3,5 */
  120.     ListInsert_CL(&L, 2, 5);
  121.     j = LocateElem_CL(L, 5, compare);
  122.     if (j)
  123.         printf("L的第%d个元素为5。\n", j);
  124.     else
  125.         printf("不存在值为5的元素\n");
  126.     i = ListDelete_CL(&L, 2, &e);
  127.     printf("删除L的第2个元素：\n");
  128.     if (i) {
  129.         printf("删除的元素值为%d,现在L中的数据元素依次为：", e);
  130.         ListTraverse_CL(L, visit);
  131.     } else
  132.         printf("删除不成功！\n");
  133.     return 0;
  134. }

运行结果

1.3.12 单循环链表的清除和销毁

  1. #include<stdio.h> /* EOF(=^Z或F6),NULL */
  2. #include<math.h> /* floor(),ceil(),abs() */
  3. #include<stdlib.h>
  4. /* 函数结果状态代码 */
  5. #define TRUE 1
  6. #define FALSE 0
  7. #define OK 1
  8. #define ERROR 0
  9. #define OVERFLOW 1
  10. typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
  11. typedef int ElemType;
  12. struct LNode {
  13.     ElemType data;
  14.     struct LNode *next;
  15. };
  16. typedef struct LNode *LinkList; /* 另一种定义LinkList的方法 */
  17. Status InitList_CL(LinkList *L) { /* 操作结果：构造一个空的线性表L */
  18.     *L = (LinkList) malloc(sizeof(struct LNode)); /* 产生头结点,并使L指向此头结点 */
  19.     if (!*L) /* 存储分配失败 */
  20.         exit(OVERFLOW);
  21.     (*L)->next = *L; /* 指针域指向头结点 */
  22.     return OK;
  23. }
  25. Status DestroyList_CL(LinkList *L) { /* 操作结果：销毁线性表L */
  26.     LinkList q, p = (*L)->next; /* p指向头结点 */
  27.     while (p != *L) /* 没到表尾 */
  28.     {
  29.         q = p->next;
  30.         free(p);
  31.         p = q;
  32.     }
  33.     free(*L);
  34.     *L = NULL;
  35.     return OK;
  36. }
  38. Status ClearList_CL(LinkList *L) /* 改变L */
  39. { /* 初始条件：线性表L已存在。操作结果：将L重置为空表 */
  40.     LinkList p, q;
  41.     *L = (*L)->next; /* L指向头结点 */
  42.     p = (*L)->next; /* p指向第一个结点 */
  43.     while (p != *L) /* 没到表尾 */
  44.     {
  45.         q = p->next;
  46.         free(p);
  47.         p = q;
  48.     }
  49.     (*L)->next = *L; /* 头结点指针域指向自身 */
  50.     return OK;
  51. }
  53. Status ListEmpty_CL(LinkList L) { /* 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
  54.     if (L->next == L) /* 空 */
  55.         return TRUE;
  56.     else
  57.         return FALSE;
  58. }
  60. int ListLength_CL(LinkList L) { /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */
  61.     int i = 0;
  62.     LinkList p = L->next; /* p指向头结点 */
  63.     while (p != L) /* 没到表尾 */
  64.     {
  65.         i++;
  66.         p = p->next;
  67.     }
  68.     return i;
  69. }
  71. Status ListInsert_CL(LinkList *L, int i, ElemType e) /* 改变L */
  72. { /* 在L的第i个位置之前插入元素e */
  73.     LinkList p = (*L)->next, s; /* p指向头结点 */
  74.     int j = 0;
  75.     if (i <= 0 || i > ListLength_CL(*L) + 1) /* 无法在第i个元素之前插入 */
  76.         return ERROR;
  77.     while (j < i - 1) /* 寻找第i-1个结点 */
  78.     {
  79.         p = p->next;
  80.         j++;
  81.     }
  82.     s = (LinkList) malloc(sizeof(struct LNode)); /* 生成新结点 */
  83.     s->data = e; /* 插入L中 */
  84.     s->next = p->next;
  85.     p->next = s;
  86.     if (p == *L) /* 改变尾结点 */
  87.         *L = s;
  88.     return OK;
  89. }
  91. Status compare(ElemType c1, ElemType c2) {
  92.     if (c1 == c2)
  93.         return TRUE;
  94.     else
  95.         return FALSE;
  96. }
  98. void visit(ElemType c) {
  99.     printf("%d ", c);
  100. }
  102. int main() {
  103.     LinkList L;
  104.     ElemType e;
  105.     int j;
  106.     Status i;
  107.     i = InitList_CL(&L); /* 初始化单循环链表L */
  108.     printf("依次在单循环链表中插入3,5\n");
  109.     ListInsert_CL(&L, 1, 3); /* 在L中依次插入3,5 */
  110.     ListInsert_CL(&L, 2, 5);
  111.     printf("清空L：%d(1: 成功)\n", ClearList_CL(&L));
  112.     printf("清空L后，L是否空：%d(1:空 0:否)\n", ListEmpty_CL(L));
  113.     printf("销毁L：%d(1: 成功)\n", DestroyList_CL(&L));
  114.     return 0;
  115. }

运行结果

1.3.13 仅设表尾指针循环链表的合并

  1. #include<stdio.h> /* EOF(=^Z或F6),NULL */
  2. #include<math.h> /* floor(),ceil(),abs() */
  3. #include <stdlib.h>
  5. #define OVERFLOW 3
  6. #define TRUE 1
  7. #define FALSE 0
  8. #define OK 1
  9. #define ERROR 0
  10. typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
  11. typedef int ElemType;
  12. struct LNode {
  13.     ElemType data;
  14.     struct LNode *next;
  15. };
  16. typedef struct LNode *LinkList; /* 另一种定义LinkList的方法 */
  17. Status InitList_CL(LinkList *L) { /* 操作结果：构造一个空的线性表L */
  18.     *L = (LinkList) malloc(sizeof(struct LNode)); /* 产生头结点,并使L指向此头结点 */
  19.     if (!*L) /* 存储分配失败 */
  20.         exit(OVERFLOW);
  21.     (*L)->next = *L; /* 指针域指向头结点 */
  22.     return OK;
  23. }
  25. int ListLength_CL(LinkList L) { /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */
  26.     int i = 0;
  27.     LinkList p = L->next; /* p指向头结点 */
  28.     while (p != L) /* 没到表尾 */
  29.     {
  30.         i++;
  31.         p = p->next;
  32.     }
  33.     return i;
  34. }
  36. Status ListInsert_CL(LinkList *L, int i, ElemType e) /* 改变L */
  37. { /* 在L的第i个位置之前插入元素e */
  38.     LinkList p = (*L)->next, s; /* p指向头结点 */
  39.     int j = 0;
  40.     if (i <= 0 || i > ListLength_CL(*L) + 1) /* 无法在第i个元素之前插入 */
  41.         return ERROR;
  42.     while (j < i - 1) /* 寻找第i-1个结点 */
  43.     {
  44.         p = p->next;
  45.         j++;
  46.     }
  47.     s = (LinkList) malloc(sizeof(struct LNode)); /* 生成新结点 */
  48.     s->data = e; /* 插入L中 */
  49.     s->next = p->next;
  50.     p->next = s;
  51.     if (p == *L) /* 改变尾结点 */
  52.         *L = s;
  53.     return OK;
  54. }
  56. Status ListTraverse_CL(LinkList L, void(*vi)(ElemType)) { /* 初始条件:L已存在。操作结果:依次对L的每个数据元素调用函数vi()。一旦vi()失败,则操作失败 */
  57.     LinkList p = L->next->next;
  58.     while (p != L->next) {
  59.         vi(p->data);
  60.         p = p->next;
  61.     }
  62.     printf("\n");
  63.     return OK;
  64. }
  66. void MergeList_CL(LinkList *La, LinkList Lb) {
  67.     LinkList p = Lb->next;
  68.     Lb->next = (*La)->next;
  69.     (*La)->next = p->next;
  70.     free(p);
  71.     *La = Lb;
  72. }
  74. void visit(ElemType c) {
  75.     printf("%d ", c);
  76. }
  78. int main() {
  79.     int n = 5, i;
  80.     LinkList La, Lb;
  81.     InitList_CL(&La);
  82.     for (i = 1; i <= n; i++)
  83.         ListInsert_CL(&La, i, i);
  84.     printf("La="); /* 输出链表La的内容 */
  85.     ListTraverse_CL(La, visit);
  86.     InitList_CL(&Lb);
  87.     for (i = 1; i <= n; i++)
  88.         ListInsert_CL(&Lb, 1, i * 2);
  89.     printf("Lb="); /* 输出链表Lb的内容 */
  90.     ListTraverse_CL(Lb, visit);
  91.     MergeList_CL(&La, Lb);
  92.     printf("La+Lb="); /* 输出合并后的链表的内容 */
  93.     ListTraverse_CL(La, visit);
  94.     return 0;
  95. }

1.3.14 正序输出双向链表

  1. #include<stdio.h> /* EOF(=^Z或F6),NULL */
  2. #include<math.h> /* floor(),ceil(),abs() */
  4. #define TRUE 1
  5. #define FALSE 0
  6. #define OK 1
  7. #define ERROR 0
  8. #define OVERFLOW 3
  9. typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
  10. typedef int ElemType;
  11. typedef struct DuLNode {
  12.     ElemType data;
  13.     struct DuLNode *prior, *next;
  14. } DuLNode, *DuLinkList;
  16. /* bo2-5.c 双链循环线性表(存储结构由c2-4.h定义)的基本操作(14个) */
  17. Status InitList(DuLinkList *L) { /* 产生空的双向循环链表L */
  18.     *L = (DuLinkList) malloc(sizeof(DuLNode));
  19.     if (*L) {
  20.         (*L)->next = (*L)->prior = *L;
  21.         return OK;
  22.     } else
  23.         return OVERFLOW;
  24. }
  26. int ListLength(DuLinkList L) { /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */
  27.     int i = 0;
  28.     DuLinkList p = L->next; /* p指向第一个结点 */
  29.     while (p != L) /* p没到表头 */
  30.     {
  31.         i++;
  32.         p = p->next;
  33.     }
  34.     return i;
  35. }
  37. DuLinkList GetElemP(DuLinkList L, int i) /* 另加 */
  38. { /* 在双向链表L中返回第i个元素的位置指针*/
  39.     int j;
  40.     DuLinkList p = L;
  41.     for (j = 1; j <= i; j++)
  42.         p = p->next;
  43.     return p;
  44. }
  46. Status ListInsert(DuLinkList L, int i, ElemType e) { /* 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1 */
  47.     DuLinkList p, s;
  48.     if (i < 1 || i > ListLength(L) + 1) /* i值不合法 */
  49.         return ERROR;
  50.     p = GetElemP(L, i - 1); /* 在L中确定第i-1个元素的位置指针p */
  51.     if (!p) /* p=NULL,即第i-1个元素不存在 */
  52.         return ERROR;
  53.     s = (DuLinkList) malloc(sizeof(DuLNode));
  54.     if (!s)
  55.         return OVERFLOW;
  56.     s->data = e; /* 在第i-1个元素之后插入 */
  57.     s->prior = p;
  58.     s->next = p->next;
  59.     p->next->prior = s;
  60.     p->next = s;
  61.     return OK;
  62. }
  64. void ListTraverse(DuLinkList L, void(*visit)(ElemType)) { /* 由双链循环线性表L的头结点出发,正序对每个数据元素调用函数visit() */
  65.     DuLinkList p = L->next; /* p指向头结点 */
  66.     while (p != L) {
  67.         visit(p->data);
  68.         p = p->next;
  69.     }
  70.     printf("\n");
  71. }
  73. void vd(ElemType c) /* ListTraverse()调用的函数(类型一致) */
  74. {
  75.     printf("%d ", c);
  76. }
  78. int main() {
  79.     DuLinkList L;
  80.     int i;
  81.     InitList(&L);
  82.     for (i = 1; i <= 5; i++)
  83.         ListInsert(L, i, i); /* 在第i个结点之前插入i */
  84.     printf("正序输出链表：");
  85.     ListTraverse(L, vd); /* 正序输出 */
  86.     return 0;
  87. }

1.3.15 逆向输出双向链表

  1. #include<stdio.h> /* EOF(=^Z或F6),NULL */
  2. #include<math.h> /* floor(),ceil(),abs() */
  4. #define TRUE 1
  5. #define FALSE 0
  6. #define OK 1
  7. #define ERROR 0
  8. #define OVERFLOW 3
  9. typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
  10. typedef int ElemType;
  11. typedef struct DuLNode {
  12.     ElemType data;
  13.     struct DuLNode *prior, *next;
  14. } DuLNode, *DuLinkList;
  16. Status InitList(DuLinkList *L) { /* 产生空的双向循环链表L */
  17.     *L = (DuLinkList) malloc(sizeof(DuLNode));
  18.     if (*L) {
  19.         (*L)->next = (*L)->prior = *L;
  20.         return OK;
  21.     } else
  22.         return OVERFLOW;
  23. }
  25. int ListLength(DuLinkList L) { /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */
  26.     int i = 0;
  27.     DuLinkList p = L->next; /* p指向第一个结点 */
  28.     while (p != L) /* p没到表头 */
  29.     {
  30.         i++;
  31.         p = p->next;
  32.     }
  33.     return i;
  34. }
  36. DuLinkList GetElemP(DuLinkList L, int i) /* 另加 */
  37. { /* 在双向链表L中返回第i个元素的位置指针*/
  38.     int j;
  39.     DuLinkList p = L;
  40.     for (j = 1; j <= i; j++)
  41.         p = p->next;
  42.     return p;
  43. }
  45. Status ListInsert(DuLinkList L, int i, ElemType e) { /* 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1 */
  46.     DuLinkList p, s;
  47.     if (i < 1 || i > ListLength(L) + 1) /* i值不合法 */
  48.         return ERROR;
  49.     p = GetElemP(L, i - 1); /* 在L中确定第i-1个元素的位置指针p */
  50.     if (!p) /* p=NULL,即第i-1个元素不存在 */
  51.         return ERROR;
  52.     s = (DuLinkList) malloc(sizeof(DuLNode));
  53.     if (!s)
  54.         return OVERFLOW;
  55.     s->data = e; /* 在第i-1个元素之后插入 */
  56.     s->prior = p;
  57.     s->next = p->next;
  58.     p->next->prior = s;
  59.     p->next = s;
  60.     return OK;
  61. }
  63. void ListTraverseBack(DuLinkList L, void(*visit)(ElemType)) { /* 由双链循环线性表L的头结点出发,逆序对每个数据元素调用函数visit()。另加 */
  64.     DuLinkList p = L->prior; /* p指向尾结点 */
  65.     while (p != L) {
  66.         visit(p->data);
  67.         p = p->prior;
  68.     }
  69.     printf("\n");
  70. }
  72. void vd(ElemType c) /* ListTraverse()调用的函数(类型一致) */
  73. {
  74.     printf("%d ", c);
  75. }
  77. int main() {
  78.     DuLinkList L;
  79.     int i;
  80.     InitList(&L);
  81.     for (i = 1; i <= 5; i++)
  82.         ListInsert(L, i, i); /* 在第i个结点之前插入i */
  83.     printf("逆序输出链表：");
  84.     ListTraverseBack(L, vd); /* 逆序输出 */
  85. }

运行结果

1.3.16 删除双向链表中的节点

  1. #include<stdio.h> /* EOF(=^Z或F6),NULL */
  2. #include<math.h> /* floor(),ceil(),abs() */
  3. #include<stdlib.h>
  5. #define OVERFLOW 3
  6. #define TRUE 1
  7. #define FALSE 0
  8. #define OK 1
  9. #define ERROR 0
  10. typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
  11. typedef int ElemType;
  12. typedef struct DuLNode {
  13.     ElemType data;
  14.     struct DuLNode *prior, *next;
  15. } DuLNode, *DuLinkList;
  17. Status InitList(DuLinkList *L) { /* 产生空的双向循环链表L */
  18.     *L = (DuLinkList) malloc(sizeof(DuLNode));
  19.     if (*L) {
  20.         (*L)->next = (*L)->prior = *L;
  21.         return OK;
  22.     } else
  23.         return OVERFLOW;
  24. }
  26. int ListLength(DuLinkList L) { /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */
  27.     int i = 0;
  28.     DuLinkList p = L->next; /* p指向第一个结点 */
  29.     while (p != L) /* p没到表头 */
  30.     {
  31.         i++;
  32.         p = p->next;
  33.     }
  34.     return i;
  35. }
  37. DuLinkList GetElemP(DuLinkList L, int i) /* 另加 */
  38. { /* 在双向链表L中返回第i个元素的位置指针*/
  39.     int j;
  40.     DuLinkList p = L;
  41.     for (j = 1; j <= i; j++)
  42.         p = p->next;
  43.     return p;
  44. }
  46. Status ListInsert(DuLinkList L, int i, ElemType e) { /* 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1 */
  47.     DuLinkList p, s;
  48.     if (i < 1 || i > ListLength(L) + 1) /* i值不合法 */
  49.         return ERROR;
  50.     p = GetElemP(L, i - 1); /* 在L中确定第i-1个元素的位置指针p */
  51.     if (!p) /* p=NULL,即第i-1个元素不存在 */
  52.         return ERROR;
  53.     s = (DuLinkList) malloc(sizeof(DuLNode));
  54.     if (!s)
  55.         return OVERFLOW;
  56.     s->data = e; /* 在第i-1个元素之后插入 */
  57.     s->prior = p;
  58.     s->next = p->next;
  59.     p->next->prior = s;
  60.     p->next = s;
  61.     return OK;
  62. }
  64. void ListTraverse(DuLinkList L, void(*visit)(ElemType)) { /* 由双链循环线性表L的头结点出发,正序对每个数据元素调用函数visit() */
  65.     DuLinkList p = L->next; /* p指向头结点 */
  66.     while (p != L) {
  67.         visit(p->data);
  68.         p = p->next;
  69.     }
  70.     printf("\n");
  71. }
  73. Status ListDelete(DuLinkList L, int i, ElemType *e) { /* 删除带头结点的双链循环线性表L的第i个元素,i的合法值为1≤i≤表长+1 */
  74.     DuLinkList p;
  75.     if (i < 1 || i > ListLength(L)) /* i值不合法 */
  76.         return ERROR;
  77.     p = GetElemP(L, i);  /* 在L中确定第i个元素的位置指针p */
  78.     if (!p) /* p=NULL,即第i个元素不存在 */
  79.         return ERROR;
  80.     *e = p->data;
  81.     p->prior->next = p->next;
  82.     p->next->prior = p->prior;
  83.     free(p);
  84.     return OK;
  85. }
  87. void vd(ElemType c) /* ListTraverse()调用的函数(类型一致) */
  88. {
  89.     printf("%d ", c);
  90. }
  92. int main() {
  93.     DuLinkList L;
  94.     int i, n = 2;
  95.     ElemType e;
  96.     InitList(&L);
  97.     printf("初始化链表依次输入1，2，3，4，5\n");
  98.     for (i = 1; i <= 5; i++)
  99.         ListInsert(L, i, i); /* 在第i个结点之前插入i */
  100.     ListDelete(L, n, &e); /* 删除并释放第n个结点 */
  101.     printf("删除第%d个结点，值为%d，其余结点为：", n, e);
  102.     ListTraverse(L, vd); /* 正序输出 */
  103. }

运行结果

1.3.17 双向链表的元素个数

  1. #include<stdio.h> /* EOF(=^Z或F6),NULL */
  2. #include<math.h> /* floor(),ceil(),abs() */
  4. #define TRUE 1
  5. #define FALSE 0
  6. #define OK 1
  7. #define ERROR 0
  8. #define OVERFLOW 3
  9. typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
  10. typedef int ElemType;
  11. typedef struct DuLNode {
  12.     ElemType data;
  13.     struct DuLNode *prior, *next;
  14. } DuLNode, *DuLinkList;
  16. Status InitList(DuLinkList *L) { /* 产生空的双向循环链表L */
  17.     *L = (DuLinkList) malloc(sizeof(DuLNode));
  18.     if (*L) {
  19.         (*L)->next = (*L)->prior = *L;
  20.         return OK;
  21.     } else
  22.         return OVERFLOW;
  23. }
  25. int ListLength(DuLinkList L) { /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */
  26.     int i = 0;
  27.     DuLinkList p = L->next; /* p指向第一个结点 */
  28.     while (p != L) /* p没到表头 */
  29.     {
  30.         i++;
  31.         p = p->next;
  32.     }
  33.     return i;
  34. }
  36. DuLinkList GetElemP(DuLinkList L, int i) /* 另加 */
  37. { /* 在双向链表L中返回第i个元素的位置指针(算法2.18、2.19要调用的函数) */
  38.     int j;
  39.     DuLinkList p = L;
  40.     for (j = 1; j <= i; j++)
  41.         p = p->next;
  42.     return p;
  43. }
  45. Status ListInsert(DuLinkList L, int i, ElemType e) /* 改进算法2.18 */
  46. { /* 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1 */
  47.     DuLinkList p, s;
  48.     if (i < 1 || i > ListLength(L) + 1) /* i值不合法 */
  49.         return ERROR;
  50.     p = GetElemP(L, i - 1); /* 在L中确定第i-1个元素的位置指针p */
  51.     if (!p) /* p=NULL,即第i-1个元素不存在 */
  52.         return ERROR;
  53.     s = (DuLinkList) malloc(sizeof(DuLNode));
  54.     if (!s)
  55.         return OVERFLOW;
  56.     s->data = e; /* 在第i-1个元素之后插入 */
  57.     s->prior = p;
  58.     s->next = p->next;
  59.     p->next->prior = s;
  60.     p->next = s;
  61.     return OK;
  62. }
  64. void vd(ElemType c) /* ListTraverse()调用的函数(类型一致) */
  65. {
  66.     printf("%d ", c);
  67. }
  69. int main() {
  70.     DuLinkList L;
  71.     int i, n = 2;
  72.     ElemType e;
  73.     InitList(&L);
  74.     printf("初始化链表依次输入1，2，3，4，5\n");
  75.     for (i = 1; i <= 5; i++)
  76.         ListInsert(L, i, i); /* 在第i个结点之前插入i */
  77.     printf("链表的元素个数为%d\n", ListLength(L));
  78.     return 0;
  79. }

运行结果

1.3.18 判断双向链表是否为空

  1. #include<stdio.h> /* EOF(=^Z或F6),NULL */
  2. #include<math.h> /* floor(),ceil(),abs() */
  4. #define TRUE 1
  5. #define FALSE 0
  6. #define OK 1
  7. #define ERROR 0
  8. #define OVERFLOW 3
  9. typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
  10. typedef int ElemType;
  11. typedef struct DuLNode {
  12.     ElemType data;
  13.     struct DuLNode *prior, *next;
  14. } DuLNode, *DuLinkList;
  16. Status InitList(DuLinkList *L) { /* 产生空的双向循环链表L */
  17.     *L = (DuLinkList) malloc(sizeof(DuLNode));
  18.     if (*L) {
  19.         (*L)->next = (*L)->prior = *L;
  20.         return OK;
  21.     } else
  22.         return OVERFLOW;
  23. }
  25. Status ClearList(DuLinkList L) /* 不改变L */
  26. { /* 初始条件：L已存在。操作结果：将L重置为空表 */
  27.     DuLinkList q, p = L->next; /* p指向第一个结点 */
  28.     while (p != L) /* p没到表头 */
  29.     {
  30.         q = p->next;
  31.         free(p);
  32.         p = q;
  33.     }
  34.     L->next = L->prior = L; /* 头结点的两个指针域均指向自身 */
  35.     return OK;
  36. }
  38. int ListLength(DuLinkList L) { /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */
  39.     int i = 0;
  40.     DuLinkList p = L->next; /* p指向第一个结点 */
  41.     while (p != L) /* p没到表头 */
  42.     {
  43.         i++;
  44.         p = p->next;
  45.     }
  46.     return i;
  47. }
  49. DuLinkList GetElemP(DuLinkList L, int i) /* 另加 */
  50. { /* 在双向链表L中返回第i个元素的位置指针(算法2.18、2.19要调用的函数) */
  51.     int j;
  52.     DuLinkList p = L;
  53.     for (j = 1; j <= i; j++)
  54.         p = p->next;
  55.     return p;
  56. }
  58. Status ListInsert(DuLinkList L, int i, ElemType e) /* 改进算法2.18 */
  59. { /* 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1 */
  60.     DuLinkList p, s;
  61.     if (i < 1 || i > ListLength(L) + 1) /* i值不合法 */
  62.         return ERROR;
  63.     p = GetElemP(L, i - 1); /* 在L中确定第i-1个元素的位置指针p */
  64.     if (!p) /* p=NULL,即第i-1个元素不存在 */
  65.         return ERROR;
  66.     s = (DuLinkList) malloc(sizeof(DuLNode));
  67.     if (!s)
  68.         return OVERFLOW;
  69.     s->data = e; /* 在第i-1个元素之后插入 */
  70.     s->prior = p;
  71.     s->next = p->next;
  72.     p->next->prior = s;
  73.     p->next = s;
  74.     return OK;
  75. }
  77. Status ListEmpty(DuLinkList L) { /* 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
  78.     if (L->next == L && L->prior == L)
  79.         return TRUE;
  80.     else
  81.         return FALSE;
  82. }
  84. void vd(ElemType c) /* ListTraverse()调用的函数(类型一致) */
  85. {
  86.     printf("%d ", c);
  87. }
  89. int main() {
  90.     DuLinkList L;
  91.     int i, n = 2;
  92.     ElemType e;
  93.     InitList(&L);
  94.     printf("初始化链表依次输入1，2，3，4，5\n");
  95.     for (i = 1; i <= 5; i++)
  96.         ListInsert(L, i, i); /* 在第i个结点之前插入i */
  97.     printf("链表是否空：%d(1:是 0:否)\n", ListEmpty(L));
  98.     ClearList(L); /* 清空链表 */
  99.     printf("清空后，链表是否空：%d(1:是 0:否)\n", ListEmpty(L));
  100.     return 0;
  101. }

运行结果

1.3.19 双向链表元素值的查询

  1. #include<stdio.h> /* EOF(=^Z或F6),NULL */
  2. #include<math.h> /* floor(),ceil(),abs() */
  4. #define TRUE 1
  5. #define FALSE 0
  6. #define OK 1
  7. #define ERROR 0
  8. #define OVERFLOW 3
  9. typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
  10. typedef int ElemType;
  11. typedef struct DuLNode {
  12.     ElemType data;
  13.     struct DuLNode *prior, *next;
  14. } DuLNode, *DuLinkList;
  16. Status InitList(DuLinkList *L) { /* 产生空的双向循环链表L */
  17.     *L = (DuLinkList) malloc(sizeof(DuLNode));
  18.     if (*L) {
  19.         (*L)->next = (*L)->prior = *L;
  20.         return OK;
  21.     } else
  22.         return OVERFLOW;
  23. }
  25. Status ClearList(DuLinkList L) /* 不改变L */
  26. { /* 初始条件：L已存在。操作结果：将L重置为空表 */
  27.     DuLinkList q, p = L->next; /* p指向第一个结点 */
  28.     while (p != L) /* p没到表头 */
  29.     {
  30.         q = p->next;
  31.         free(p);
  32.         p = q;
  33.     }
  34.     L->next = L->prior = L; /* 头结点的两个指针域均指向自身 */
  35.     return OK;
  36. }
  38. int ListLength(DuLinkList L) { /* 初始条件：L已存在。操作结果：返回L中数据元素个数 */
  39.     int i = 0;
  40.     DuLinkList p = L->next; /* p指向第一个结点 */
  41.     while (p != L) /* p没到表头 */
  42.     {
  43.         i++;
  44.         p = p->next;
  45.     }
  46.     return i;
  47. }
  49. Status GetElem(DuLinkList L, int i, ElemType *e) { /* 当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR */
  50.     int j = 1; /* j为计数器 */
  51.     DuLinkList p = L->next; /* p指向第一个结点 */
  52.     while (p != L && j < i) /* 顺指针向后查找,直到p指向第i个元素或p指向头结点 */
  53.     {
  54.         p = p->next;
  55.         j++;
  56.     }
  57.     if (p == L || j > i) /* 第i个元素不存在 */
  58.         return ERROR;
  59.     *e = p->data; /* 取第i个元素 */
  60.     return OK;
  61. }
  63. DuLinkList GetElemP(DuLinkList L, int i) /* 另加 */
  64. { /* 在双向链表L中返回第i个元素的位置指针*/
  65.     int j;
  66.     DuLinkList p = L;
  67.     for (j = 1; j <= i; j++)
  68.         p = p->next;
  69.     return p;
  70. }
  72. Status ListInsert(DuLinkList L, int i, ElemType e) {
  73.     DuLinkList p, s;
  74.     if (i < 1 || i > ListLength(L) + 1) /* i值不合法 */
  75.         return ERROR;
  76.     p = GetElemP(L, i - 1); /* 在L中确定第i-1个元素的位置指针p */
  77.     if (!p) /* p=NULL,即第i-1个元素不存在 */
  78.         return ERROR;
  79.     s = (DuLinkList) malloc(sizeof(DuLNode));
  80.     if (!s)
  81.         return OVERFLOW;
  82.     s->data = e; /* 在第i-1个元素之后插入 */
  83.     s->prior = p;
  84.     s->next = p->next;
  85.     p->next->prior = s;
  86.     p->next = s;
  87.     return OK;
  88. }
  90. Status ListEmpty(DuLinkList L) { /* 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
  91.     if (L->next == L && L->prior == L)
  92.         return TRUE;
  93.     else
  94.         return FALSE;
  95. }
  97. void vd(ElemType c) /* ListTraverse()调用的函数(类型一致) */
  98. {
  99.     printf("%d ", c);
  100. }
  102. int main() {
  103.     DuLinkList L;
  104.     int i, n, j;
  105.     ElemType e;
  106.     InitList(&L);
  107.     printf("初始化链表依次输入1，2，3，4，5\n");
  108.     for (i = 1; i <= 5; i++)
  109.         ListInsert(L, i, i); /* 在第i个结点之前插入i */
  110.     n = 3;
  111.     j = GetElem(L, n, &e); /* 将链表的第n个元素赋值给e */
  112.     if (j)
  113.         printf("链表的第%d个元素值为%d\n", n, e);
  114.     else
  115.         printf("不存在第%d个元素\n", n);
  116. }

运行结果

1.3.20 稀疏矩阵的建立

  1. #include "stdio.h"
  2. #include "stdlib.h"
  3. #define MAX_SIZE  50   /* 最大的稀疏矩阵 */
  4. typedef enum  {head, entry} tagfield;
  5. struct entry_node  {
  6.     int  row;
  7.     int  col;
  8.     int  value;
  9. };
  10. typedef struct Matrix  {
  11.     struct Matrix    *  down;
  12.     struct Matrix  *    right;
  13.     tagfield  tag;
  14.     union   {
  15.         struct Matrix  *  next;
  16.         struct entry_node  entry;
  17.     } u;
  18. }matrix_node;
  19. typedef matrix_node * matrix_pointer;
  20. matrix_pointer  hdnode [ MAX_SIZE ];
  21. matrix_pointer new_node(void)
  22. {
  23.     matrix_pointer temp;
  24.     temp = (matrix_pointer)malloc(sizeof(matrix_node));
  25.     if (temp==NULL) {
  26.         printf("The memory is full\n");
  27.         exit(1);
  28.     }
  29.     return temp;
  30. }
  31. matrix_pointer Create(void)
  32. {
  33.     int num_rows, num_cols, num_terms, num_heads, i,current_row;
  34.     int col,  value,row;
  35.     matrix_pointer    node,temp,last;
  36.     printf("Enter the number of rows, columns and number of nonzero terms: ");
  37.     scanf("%d%d%d",&num_rows,&num_cols,&num_terms);
  38.     num_heads = (num_cols > num_rows) ? num_cols :num_rows;
  39.     /* 建立新结点 */
  40.     node = new_node();
  41.     node->tag = entry;
  42.     node->u.entry.row = num_rows;
  43.     node->u.entry.col = num_cols;
  44.     if ( !num_heads )
  45.         node->right = node;
  46.     else {
  47.         for ( i = 0; i<num_heads; i++ ) {
  48.             temp = new_node();
  49.             hdnode[i] = temp;
  50.             hdnode[i]->tag = head;
  51.             hdnode[i]->right = temp;
  52.             hdnode[i]->u.next = temp;
  53.         }
  54.         current_row = 0;
  55.         last = hdnode[0];
  56.         for ( i = 0; i < num_terms; i++ ) {
  57.             printf("Enter row, column and value: ");
  58.             scanf("%d%d%d",&row,&col,&value);
  59.             if ( row > current_row ) {
  60.                 /* 转到row所在行去*/
  61.                 last->right = hdnode[current_row];
  62.                 current_row = row;
  63.                 last = hdnode[row];
  64.             }
  65.             temp = new_node();
  66.             temp->tag = entry;
  67.             temp->u.entry.row = row;
  68.             temp->u.entry.col = col;
  69.             temp->u.entry.value = value;
  70.             last->right = temp;
  71.             last = temp;
  72.             /*链接到列结点上 */
  73.             hdnode[col]->u.next->down = temp;
  74.             hdnode[col]->u.next = temp;
  75.         }
  76.         /* 结束上一行结点 */
  77.         last->right = hdnode[current_row];
  78.         /*结束所有行结点*/
  79.         for ( i=0; i<num_cols; i++ )
  80.             hdnode[i]->u.next->down= hdnode[i];
  81.         /*链接所有的头结点 */
  82.         for ( i=0; i<num_heads-1; i++ )
  83.             hdnode[i]->u.next = hdnode[i+1];
  84.         hdnode[num_heads-1]->u.next = node;
  85.         node->right = hdnode[0];
  86.     }
  87.     return node;
  88. }
  89. int main()
  90. {
  91.     matrix_pointer matric=Create();
  92.     return 0;
  93. }

运行结果

1.3.21 稀疏矩阵的删除

  1. #include <cstdlib>
  2. #include "stdio.h"
  4. #define MAX_SIZE  50   /* 最大的稀疏矩阵 */
  5. typedef enum {
  6.     head, entry
  7. } tagfield;
  8. struct entry_node {
  9.     int row;
  10.     int col;
  11.     int value;
  12. };
  13. typedef struct Matrix {
  14.     struct Matrix *down;
  15.     struct Matrix *right;
  16.     tagfield tag;
  17.     union {
  18.         struct Matrix *next;
  19.         struct entry_node entry;
  20.     } u;
  21. } matrix_node;
  22. typedef matrix_node *matrix_pointer;
  23. matrix_pointer hdnode[MAX_SIZE];
  25. matrix_pointer new_node(void) {
  26.     matrix_pointer temp;
  27.     temp = (matrix_pointer) malloc(sizeof(matrix_node));
  28.     if (temp == NULL) {
  29.         printf("The memory is full\n");
  30.         exit(1);
  31.     }
  32.     return temp;
  33. }
  35. matrix_pointer Create(void) {
  36.     int num_rows, num_cols, num_terms, num_heads, i, current_row;
  37.     int col, value, row;
  38.     matrix_pointer node, temp, last;
  39.     printf("Enter the number of rows, columns and number of nonzero terms: ");
  40.     scanf("%d%d%d", &num_rows, &num_cols, &num_terms);
  41.     num_heads = (num_cols > num_rows) ? num_cols : num_rows;
  42.     /* 建立新结点 */
  43.     node = new_node();
  44.     node->tag = entry;
  45.     node->u.entry.row = num_rows;
  46.     node->u.entry.col = num_cols;
  47.     if (!num_heads)
  48.         node->right = node;
  49.     else {    /*初始化头结点如图5-5-4*/
  50.         for (i = 0; i < num_heads; i++) {
  51.             temp = new_node();
  52.             hdnode[i] = temp;
  53.             hdnode[i]->tag = head;
  54.             hdnode[i]->right = temp;
  55.             hdnode[i]->u.next = temp;
  56.         }
  57.         current_row = 0;
  58.         last = hdnode[0];
  59.         for (i = 0; i < num_terms; i++) {
  60.             printf("Enter row, column and value: ");
  61.             scanf("%d%d%d", &row, &col, &value);
  62.             if (row > current_row) {
  63.                 /* 转到row所在行去*/
  64.                 last->right = hdnode[current_row];
  65.                 current_row = row;
  66.                 last = hdnode[row];
  67.             }
  68.             temp = new_node();
  69.             temp->tag = entry;
  70.             temp->u.entry.row = row;
  71.             temp->u.entry.col = col;
  72.             temp->u.entry.value = value;
  73.             /* 链接到行结点上如图5-5-5所示 */
  74.             last->right = temp;
  75.             last = temp;
  76.             /*链接到列结点上 */
  77.             hdnode[col]->u.next->down = temp;
  78.             hdnode[col]->u.next = temp;
  79.         }
  80.         /* 结束上一行结点 */
  81.         last->right = hdnode[current_row];
  82.         /*结束所有行结点*/
  83.         for (i = 0; i < num_cols; i++)
  84.             hdnode[i]->u.next->down = hdnode[i];
  85.         /*链接所有的头结点 */
  86.         for (i = 0; i < num_heads - 1; i++)
  87.             hdnode[i]->u.next = hdnode[i + 1];
  88.         hdnode[num_heads - 1]->u.next = node;
  89.         node->right = hdnode[0];
  90.     }
  91.     return node;
  92. }
  94. void erase(matrix_pointer *node) {
  95.     matrix_pointer x, y, head = (*node)->right;
  96.     int i;
  97.     /* 遍历每行，删除元素结点和头结点 */
  98.     for (i = 0; i < (*node)->u.entry.row; i++) {
  99.         y = head->right;
  100.         while (y != head) {
  101.             x = y;
  102.             y = y->right;
  103.             free(x);
  104.         }
  105.         x = head;
  106.         head = head->u.next;
  107.         free(x);
  108.     }
  109.     /* 删除剩余的头结点*/
  110.     y = head;
  111.     while (y != *node) {
  112.         x = y;
  113.         y = y->u.next;
  114.         free(x);
  115.     }
  116.     free(*node);
  117.     *node = NULL;
  118. }
  120. int main() {
  121.     matrix_pointer matric = Create();
  122.     erase(&matric);
  123.     return 0;
  124. }

[数据结构]链表LinkList的更多相关文章

  1. [数据结构]链表相关的实现LinkList.cpp

    目录 LinkList.cpp //链表相关操作的实现 LinkList.h LinkListManager.cpp //链表相关实现函数的调用 LinkListManager.h LinkList. ...

  2. [PHP] 数据结构-链表创建-插入-删除-查找的PHP实现

    链表获取元素1.声明结点p指向链表第一个结点,j初始化1开始2.j<i,p指向下一结点,因为此时p是指向的p的next,因此不需要等于3.如果到末尾了,p还为null,就是没有查找到 插入元素1 ...

  3. Python—数据结构——链表

    数据结构——链表 一.简介 链表是一种物理存储上非连续,数据元素的逻辑顺序通过链表中的指针链接次序,实现的一种线性存储结构.由一系列节点组成的元素集合.每个节点包含两部分,数据域item和指向下一个节 ...

  4. (js描述的)数据结构[链表](4)

    (js描述的)数据结构 [链表](4) 一.基本结构 二.想比于数组,链表的一些优点 1.内存空间不是必须连续的,可以充分利用计算机的内存,事项灵活的内存动态管理. 2.链表不必再创建时就确定大小,并 ...

  5. 数据结构和算法(Golang实现)(12)常见数据结构-链表

    链表 讲数据结构就离不开讲链表.因为数据结构是用来组织数据的,如何将一个数据关联到另外一个数据呢?链表可以将数据和数据之间关联起来,从一个数据指向另外一个数据. 一.链表 定义: 链表由一个个数据节点 ...

  6. Redis数据结构—链表与字典的结构

    目录 Redis数据结构-链表与字典的结构 链表 Redis链表节点的结构 Redis链表的表示 Redis链表用在哪 字典 Redis字典结构总览 Redis字典结构分解 Redis字典的使用 Re ...

  7. Redis数据结构—链表与字典

    目录 Redis数据结构-链表与字典 链表 Redis链表节点的结构 Redis链表的表示 Redis链表用在哪 字典 Redis字典结构总览 Redis字典结构分解 哈希算法 解决键冲突 rehas ...

  8. Java数据结构与算法(5) - ch05链表(LinkList)

    双端链表与传统链表非常相似,但是它有一个新增的特性:即对最后一个链节点的引用,就像对第一个连接点的引用一样.注意与双向链表进行区别.

  9. Python 数据结构 链表

    什么是时间复杂度 时间频度:一个算法执行所耗费的时间,从理论上是不能算出来的,必须上机运行测试才知道.但是我们不可能也没有必要对每一个算法都进行上机测试,只需要知道那个算法花费的时间多,那个算法花费得 ...

随机推荐

  1. 14. GLIBCXX_3.4.9' not found - 解决办法

    在Linux中安装交叉编译器arm-linux-gcc 4.4.3,然后编译mini2440内核出错: /usr/lib/libstdc++.so.6: version GLIBCXX_3.4.9' ...

  2. Win7部署Yapi

    1.安装node 下载地址:https://nodejs.org/zh-cn/download/ (win7要下载v12.16之前的版本) 安装目录在D:\nodejs,配置地址(文件目录不能有特殊符 ...

  3. git 日志技术

    1.git log, 在一个分支下, 以时间的倒序方式显示你制造的所有commit列表,包含创建人,时间,提交了什么等信息: 2. git reflog, 获取您在本地repo上还原commit所做工 ...

  4. CentOS 7.3安装完整开发环境

    系统版本CentOS 7.3(1611) 安装开发环境1) 通过group安装 yum groups mark install "Development Tools" yum gr ...

  5. vscode高效管理不同项目文件

    vscode作为一个轻量级编辑器,深受大家喜爱,这其中当然也囊括了本人.我同时使用vscode写c++.java.python以及markdown文档,每次打开vscode都要切换到对应的文件夹,非常 ...

  6. 安全刻不容缓「GitHub 热点速览 v.21.50」

    作者:HelloGitHub-小鱼干 本周最热的事件莫过于 Log4j 漏洞,攻击者仅需向目标输入一段代码,不需要用户执行任何多余操作即可触发该漏洞,使攻击者可以远程控制用户受害者服务器,90% 以上 ...

  7. log4j漏洞的产生原因和解决方案，小白都能看懂！！！！

    核弹级bug Log4j,相信很多人都有所耳闻了,这两天很多读者都在问我关于这个bug的原理等一些问题,今天咱们就专门写一篇文章,一起聊一聊这个核弹级别的bug的产生原理以及怎么防止 产生原因 其实这 ...

  8. 【JAVA今法修真】 第四章 redis特性 击穿雪崩！

    感谢这段时间大家的支持,关注我的微信号:南橘ryc ,回复云小霄,就可以获取到最新的福利靓照一张,还等什么,赶快来加入我们吧~ "明日便是决赛了,咋只会用法器没练过法术呢.". 选 ...

  9. [BUUCTF]REVERSE——CrackRTF

    CrackRTF 附件 步骤: 例行查壳儿,32位程序,无壳儿 32位ida载入,main函数开始分析程序 破解第一个密码 sub_40100A()是一个加密函数,具体的写的算法没去分析,但是Cryp ...

  10. BUUCFT pwn asis2016_b00ks

    看师傅们wp的时候,我才知道这个道题是wiki上面的例题.我看了一些师傅的wp,发现大家都是一种做法,都是通过mmap堆地址,来找libc基地址的.而我试了一下fastbisn attack,发现也可 ...