数据结构（线性表——链表1）

Posted 2021-02-20 tianliang-2000

单链表

• 创建单链表的过程是一个动态生成表的过程，从“空表”的初始转态起，依次建立各元素结点，并逐个插入链表
• 单链表的创建分为“头插法”和“尾插法”

1. 头插法：把新加进的元素放在表头（头结点）后的第一个位置
2. 尾插法：新加进的元素放在表中最后一个位置

• 单链表的正表删除

1. 声明结点 p,q
2. 将第一个结点（不算头结点）赋值给 p，下一个结点赋值给 q
3. 循环执行释放 p 和将 q 赋值给 p 的操作

静态链表

　　所谓的静态链表就是在结点数组中模拟链表结构

• 数组的第一个和最后一个元素不存放数据
• 未使用的数组元素称为备用链表
• 数组的第一个元素，即下标为 0 的那个元素的游标（cur）存储备用链表第一个结点的下标（相当于备用链表的头结点）
• 数组的最后一个元素，即下标为 [MAXSIZE-1] 的那个元素的游标（cur）存储第一个有数值的下标（相当于头结点）
• 有数据结点的游标指向下一个有数据结点的坐标；备用链表结点的游标指向下一个备用链表的结点的坐标
• 有数据结点的最后一个结点的游标存储 0 ;备用链表的最后一个结点的游标存储 [MAXSIZE-1]

  1 #include <stdio.h>
  2 #include <malloc.h>
  3 #define MAXSIZE 10
  4 typedef int ElemType;
  5 
  6 struct Node{
  7     ElemType data;//数据
  8     int cur;//游标（cursor）
  9 }Component,StaticLinkList[MAXSIZE];
 10 
 11 void initList(struct Node *);
 12 int insert(struct Node *,ElemType,int);
 13 void printList(struct Node *);
 14 void add(struct Node *,ElemType);
 15 int del(struct Node *,int);
 16 void delAll(struct Node *);
 17 
 18 void delAll(struct Node *L){
 19     initList(L);
 20 }
 21 
 22 int del(struct Node *L,int n){
 23     int i=MAXSIZE-1,j;
 24     while(n>1){
 25         i=L[i].cur;
 26         if(i == 0){
 27             printf("删除位置有误！
");
 28             return -1;
 29         }
 30         n--;
 31     }
 32     j=L[i].cur;
 33     L[i].cur=L[j].cur;
 34     L[j].cur=L[0].cur;
 35     L[0].cur=j;
 36     return 1;
 37 }
 38 
 39 int insert(struct Node *L,ElemType val,int n){
 40     int i=MAXSIZE-1,j;
 41     if(L[0].cur == MAXSIZE-1){
 42         printf("已经存满！
");
 43         return -1;
 44     }
 45     while(n>1){
 46         i=L[i].cur;
 47         if(i == 0){
 48             printf("插入位置有误！
");
 49             return -1;
 50         }
 51         n--;
 52     }
 53     j=L[0].cur;
 54     L[0].cur=L[j].cur;
 55     L[j].cur=L[i].cur;
 56     L[i].cur=j;
 57     L[j].data=val;
 58     return 1;
 59 }
 60 
 61 void printList(struct Node *L){
 62     int i=L[MAXSIZE-1].cur;
 63     while(i != 0){
 64         printf("%d   ",L[i].data);
 65         i=L[i].cur;
 66     }
 67     printf("
");
 68 }
 69 
 70 void add(struct Node *L,ElemType val){
 71     int i=L[MAXSIZE-1].cur,j;
 72     if(L[0].cur == MAXSIZE-1){
 73         printf("已经存满！");
 74     }else if(i == 0){
 75         i=L[0].cur;
 76         L[0].cur=L[i].cur;
 77         L[i].data=val;
 78         L[i].cur=0;
 79         L[MAXSIZE-1].cur=i;
 80     }else{
 81         while(L[i].cur != 0)
 82             i=L[i].cur;
 83         j=L[0].cur;
 84         L[i].cur=j;
 85         L[0].cur = L[j].cur;
 86         L[j].data=val;
 87         L[j].cur=0;
 88     }
 89 }
 90 
 91 void initList(struct Node *space){
 92     int i;
 93     for(i=0;i<MAXSIZE-1;i++)
 94         space[i].cur=i+1;
 95     space[MAXSIZE-1].cur=0;
 96 }
 97 
 98 void main(){
 99     ElemType val;
100     int n;
101     struct Node *L=StaticLinkList;
102     initList(L);
103     printf("请输入要添加的值（-1结束）：");
104     scanf("%d",&val);
105     while(val != -1){
106         add(L,val);
107         printf("请输入要添加的值（-1结束）：");
108         scanf("%d",&val);
109     }
110     printList(L);
111 
112     printf("请输入要插入的值（-1结束）：");
113     scanf("%d",&val);
114     printf("请输入要插入的位置：");
115     scanf("%d",&n);
116     n=insert(L,val,n);
117     if(n == 1)
118         printf("插入成功！
");
119     printList(L);
120 
121     printf("请输入要删除的位置：");
122     scanf("%d",&n);
123     n=del(L,n);
124     if(n==1)
125         printf("删除成功！
");
126     printList(L);
127 
128     delAll(L);
129     printList(L);
130 }

优点：

　　插入、删除操作只需要修改游标，不需要跟数组一样移动元素

　　 改进了在顺序存储中的插入和删除操作

缺点：

　　没有解决连续存储分配（数组）带来的表长难以确定的问题

　　 失去了链式存随机结构随机存储的特性