1. #define ElemType int
    2. #include"LinkNode.h"
    4. int main(){
    5.     int i;
    6.     ElemType a[] = {1,2,3,4,5,6,7,8};
    7.     LinkNode * 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.     return 0;
    54. }
    1. //链式表
    3. #include<stdlib.h>
    4. #include<stdio.h>
    5. typedef struct LNode{
    6.         ElemType data;
    7.         struct LNode * next;
    8. }LinkNode;
    11. //0.整体创建 头插法
    12. void CreateListF(LinkNode ** L,ElemType a[],int n){
    13.         LinkNode * s;
    14.         int i = 0;
    15.         (*L) = (LinkNode *)malloc(sizeof(LinkNode));
    16.         (*L)->next = NULL;
    18.         while(i<n){
    19.             s = (LinkNode *)malloc(sizeof(LinkNode));
    20.             s->data = a[i];
    21.             s->next = (*L)->next;
    22.             (*L)->next = s;
    23.             i++;
    24.         }
    26. }
    27. //0.整体创建 尾插法
    28. void CreateListR(LinkNode ** L,ElemType a[],int n){
    29.         LinkNode * s,* r;
    30.         int i = 0;
    31.         (*L) = (LinkNode *)malloc(sizeof(LinkNode));
    32.         r = (*L);
    34.         while(i<n){
    35.             s = (LinkNode *)malloc(sizeof(LinkNode));
    36.             s->data = a[i];
    37.             r->next = s;
    38.             r = s;
    39.             i++;
    40.         }
    41.         r->next = NULL;
    42. }
    44. //1.初始化顺序表
    45. void InitList(LinkNode ** L){
    46.         (*L) = (LinkNode *)malloc(sizeof(LinkNode));
    47.         (*L)->next = NULL;
    48. }
    50. //2.销毁顺序表
    51. void DestroyList(LinkNode ** L){
    52.         LinkNode * pre = *L,*p = (*L)->next;
    53.         while(p != NULL){
    54.             free(pre);
    55.             pre = p;
    56.             p = pre->next;
    57.         }
    58.         free(pre);
    59. }
    60. //3.判断顺序表是否为空
    61. int ListEmpty(LinkNode * L){
    62.         return (L->next == NULL);
    63. }
    64. //4.返回顺序表长度
    65. int ListLength(LinkNode * L){
    66.         int i = 0;
    67.         LinkNode * p = L;
    68.         while(p->next != NULL){
    69.             i++;
    70.             p = p->next;
    71.         }
    72.         return i;
    73. }
    75. //5.输出顺序表
    76. void DisplayList(LinkNode * L){
    77.         LinkNode * p = L->next;
    78.         while(p != NULL){
    79.             printf("%d\t",p->data);//顺序表的元素类型不一定为int，故此处语句用 %d 并不合适，还需做处理，此处仅当演示作用,后面的判断对比处，也不要计较，理解思路即可
    80.             p = p->next;
    81.         }
    82.         printf("\n");
    84. }
    86. //6.求顺序表中的某个元素
    87. int GetElem(LinkNode * L,int i,ElemType * e){
    88.         int j = 0;
    89.         LinkNode * p = L;
    90.         if(i<1){
    91.             return 0;
    92.         }
    93.         while(j<i && p->next != NULL){
    94.             p = p->next;
    95.             j++;
    96.         }
    97.         if(p == NULL){
    98.             return 0;
    99.         }else{
    100.             *e = p->data;
    101.             return 1;
    102.         }
    103. }
    104. //7.找元素返回序号
    105. int LocateElem(LinkNode * L,ElemType e){
    106.         int i = 0;
    107.         LinkNode * p = L;
    109.         while(p->next != NULL && p->data != e){
    110.             p = p->next;
    111.             i++;
    112.         }
    114.         if(p->next == NULL){
    115.             return 0;
    116.         }else{
    117.             return i;
    118.         }
    120. }
    121. //8.插入元素
    122. int ListInsert(LinkNode ** L,int i,ElemType e){
    123.         int j = 0;
    124.         LinkNode * p = (*L),*s;
    126.         if(i<0){
    127.             return 0;
    128.         }
    130.         while(j<i-1 && p->next != NULL){
    131.             j++;
    132.             p = p->next;
    133.         }
    134.         if(p->next == NULL){
    135.             return 0;
    136.         }else{
    137.             s = (LinkNode *)malloc(sizeof(LinkNode));
    138.             s->data = e;
    139.             s->next = p->next;
    140.             p->next = s;
    141.             return 1;
    142.         }
    143. }
    144. //9.删除元素
    145. int ListDelete(LinkNode ** L,int i,ElemType *e){
    146.         int j = 0;
    147.         LinkNode * p = *L, * s;
    149.         if(i<1){
    150.             return 0;
    151.     }
    153.         while(j < i-1 && p->next != NULL){
    154.             j++;
    155.             p = p->next;
    156.         }
    157.         if(p == NULL){
    158.             return 0;
    159.         }else{
    160.             s = p->next;
    161.             if(s == NULL){
    162.                 return 0;
    163.             }
    164.             *e = s->data;
    165.             p->next =s->next;
    166.             free(s);
    167.             return 1;
    168.         }
    170. }