1. #define ElemType int
    2. #include"LinkNodeD.h"
    4. int main(){
    5.     int i;
    6.     ElemType a[] = {1,2,3,4,5,6,7,8};
    7.     LinkNodeD * L;
    8.     ElemType e;
    10.     CreateListF(&L,a,8);
    12.     printf("打印顺序表:\n");
    13.     DisplayList(L);
    15.     printf("顺序表是否(1/0)为空:%d\n",ListEmpty(L));
    16.     printf("顺序表长度:%d\n",ListLength(L));
    18.     if(GetElem(L,4,&e)){
    19.         printf("打印第4个元素:%d\n",e);
    20.     }else{
    21.         printf("输入序号不正确!\n");
    22.     }
    24.     if(LocateElem(L,7)){
    25.         printf("第%d个元素为7\n",LocateElem(L,7));
    26.     }else
    27.     {
    28.         printf("没有该元素!\n");
    29.     }
    31.     i = ListInsert(&L,4,0);
    32.     if(i){
    33.         printf("插入成功!\n");
    34.     }else
    35.     {
    36.         printf("插入失败!\n");
    37.     }
    39.     printf("打印顺序表:\n");
    40.     DisplayList(L);
    42.     i = ListDelete(&L,4,&e);
    43.     if(i){
    44.         printf("删除成功!\n");
    45.     }else
    46.     {
    47.         printf("删除失败!\n");
    48.     }
    50.     printf("打印顺序表:\n");
    51.     DisplayList(L);
    53.     printf("逆置顺序表:\n");
    54.     reverse(&L);
    55.     printf("打印顺序表:\n");
    56.     DisplayList(L);
    57.     return 0;
    58. }
    1. //双向链式表
    3. #include<stdlib.h>
    4. #include<stdio.h>
    5. typedef struct LNode{
    6.         ElemType data;
    7.         struct LNode * prior;
    8.         struct LNode * next;
    9. }LinkNodeD;
    12. //0.整体创建 头插法
    13. void CreateListF(LinkNodeD ** L,ElemType a[],int n){
    14.         LinkNodeD * s;
    15.         int i = 0;
    16.         (*L) = (LinkNodeD *)malloc(sizeof(LinkNodeD));
    17.         (*L)->prior = NULL;
    18.         (*L)->next = NULL;
    20.         while(i<n){
    21.             s = (LinkNodeD *)malloc(sizeof(LinkNodeD));
    22.             s->data = a[i];
    23.             if((*L)->next != NULL){
    24.                 (*L)->next->prior = s;//针对如果L表上本来就有节点的情况
    25.             }
    26.             s->prior = (*L);
    27.             s->next = (*L)->next;
    28.             (*L)->next = s;
    29.             i++;
    30.         }
    32. }
    33. //0.整体创建 尾插法
    34. void CreateListR(LinkNodeD ** L,ElemType a[],int n){
    35.         LinkNodeD * s,* r;
    36.         int i = 0;
    37.         (*L) = (LinkNodeD *)malloc(sizeof(LinkNodeD));
    38.         (*L)->prior = NULL;
    39.         r = (*L);
    41.         while(i<n){
    42.             s = (LinkNodeD *)malloc(sizeof(LinkNodeD));
    43.             s->data = a[i];
    45.             r->next = s;
    46.             s->prior = r;
    47.             r = s;
    48.             i++;
    49.         }
    50.         r->next = NULL;
    51. }
    53. //1.初始化顺序表
    54. void InitList(LinkNodeD ** L){
    55.         (*L) = (LinkNodeD *)malloc(sizeof(LinkNodeD));
    56.         (*L)->prior = NULL;
    57.         (*L)->next = NULL;
    58. }
    60. //2.销毁顺序表
    61. void DestroyList(LinkNodeD ** L){
    62.         LinkNodeD * pre = *L,*p = (*L)->next;
    63.         while(p != NULL){
    64.             free(pre);
    65.             pre = p;
    66.             p = pre->next;
    67.         }
    68.         free(pre);
    69. }
    70. //3.判断顺序表是否为空
    71. int ListEmpty(LinkNodeD * L){
    72.         return (L->next == NULL);
    73. }
    74. //4.返回顺序表长度
    75. int ListLength(LinkNodeD * L){
    76.         int i = 0;
    77.         LinkNodeD * p = L;
    78.         while(p->next != NULL){
    79.             i++;
    80.             p = p->next;
    81.         }
    82.         return i;
    83. }
    85. //5.输出顺序表
    86. void DisplayList(LinkNodeD * L){
    87.         LinkNodeD * p = L->next;
    88.         while(p != NULL){
    89.             printf("%d\t",p->data);//顺序表的元素类型不一定为int，故此处语句用 %d 并不合适，还需做处理，此处仅当演示作用,后面的判断对比处，也不要计较，理解思路即可
    90.             p = p->next;
    91.         }
    92.         printf("\n");
    94. }
    96. //6.求顺序表中的某个元素
    97. int GetElem(LinkNodeD * L,int i,ElemType * e){
    98.         int j = 0;
    99.         LinkNodeD * p = L;
    100.         if(i<1){
    101.             return 0;
    102.         }
    103.         while(j<i && p->next != NULL){
    104.             p = p->next;
    105.             j++;
    106.         }
    107.         if(p == NULL){
    108.             return 0;
    109.         }else{
    110.             *e = p->data;
    111.             return 1;
    112.         }
    113. }
    114. //7.找元素返回序号
    115. int LocateElem(LinkNodeD * L,ElemType e){
    116.         int i = 0;
    117.         LinkNodeD * p = L;
    119.         while(p->next != NULL && p->data != e){
    120.             p = p->next;
    121.             i++;
    122.         }
    124.         if(p->next == NULL){
    125.             return 0;
    126.         }else{
    127.             return i;
    128.         }
    130. }
    131. //8.插入元素
    132. int ListInsert(LinkNodeD ** L,int i,ElemType e){
    133.         int j = 0;
    134.         LinkNodeD * p = (*L),*s;
    136.         if(i<0){
    137.             return 0;
    138.         }
    140.         while(j<i-1 && p->next != NULL){
    141.             j++;
    142.             p = p->next;
    143.         }
    144.         if(p->next == NULL){
    145.             return 0;
    146.         }else{
    147.             s = (LinkNodeD *)malloc(sizeof(LinkNodeD));
    148.             s->data = e;
    149.             s->next = p->next;
    150.             p->next = s;
    151.             return 1;
    152.         }
    153. }
    154. //9.删除元素
    155. int ListDelete(LinkNodeD ** L,int i,ElemType *e){
    156.         int j = 0;
    157.         LinkNodeD * p = *L, * s;
    159.         if(i<1){
    160.             return 0;
    161.     }
    163.         while(j < i-1 && p->next != NULL){
    164.             j++;
    165.             p = p->next;
    166.         }
    167.         if(p == NULL){
    168.             return 0;
    169.         }else{
    170.             s = p->next;
    171.             if(s == NULL){
    172.                 return 0;
    173.             }
    174.             *e = s->data;
    175.             p->next =s->next;
    176.             free(s);
    177.             return 1;
    178.         }
    180. }
    181. //10节点逆置
    182. void reverse(LinkNodeD ** L){
    183.     LinkNodeD * p = (*L)->next,* q;
    184.     p->prior = NULL;
    185.     while(p->next != NULL){
    186.         q = p->next;
    187.         p->next = p->prior;
    188.         p->prior = q;
    189.         p = q;
    190.     }
    191.     q->next = q->prior;
    192.     q->prior = (*L);
    193.     (*L)->next = q;
    195. }