bo2-32.cpp 一个数组可生成若干静态链表(数据结构由c2-3.h定义)的基本操作(12个)

1.  // bo2-32.cpp 一个数组可生成若干静态链表(数据结构由c2-3.h定义)的基本操作(12个),包括算法2.14
2.  #define DestroyList ClearList // DestroyList()和ClearList()的操作是一样的
3.  void InitSpace(SLinkList L) // 算法2.14。另加
4.  { // 将一维数组L中各分量链成一个备用链表，L[0].cur为头指针。“0”表示空指针。
5.    int i;
6.    for(i=0;i<MAX_SIZE-1;i++)
7.      L[i].cur=i+1;
8.    L[MAX_SIZE-1].cur=0;
9.  }
11.  int InitList(SLinkList L)
12.  { // 构造一个空链表，返回值为空表在数组中的位序
13.    int i;
14.    i=Malloc(L); // 调用Malloc()，简化程序
15.    L[i].cur=0; // 空链表的表头指针为空(0)
16.    return i;
17.  }
19.  void ClearList(SLinkList L,int n)
20.  { // 初始条件：L中表头位序为n的静态链表已存在。操作结果：将此表重置为空表
21.    int j,k,i=L[n].cur; // 链表第一个结点的位置
22.    L[n].cur=0; // 链表空
23.    k=L[0].cur; // 备用链表第一个结点的位置
24.    L[0].cur=i; // 把链表的结点连到备用链表的表头
25.    while(i) // 没到链表尾
26.    {
27.      j=i;
28.      i=L[i].cur; // 指向下一个元素
29.    }
30.    L[j].cur=k; // 备用链表的第一个结点接到链表的尾部
31.  }
33.  Status ListEmpty(SLinkList L,int n)
34.  { // 判断L中表头位序为n的链表是否空，若是空表返回TRUE；否则返回FALSE
35.    if(L[n].cur==0) // 空表
36.      return TRUE;
37.    else
38.      return FALSE;
39.  }
41.  int ListLength(SLinkList L,int n)
42.  { // 返回L中表头位序为n的链表的数据元素个数
43.    int j=0,i=L[n].cur; // i指向第一个元素
44.    while(i) // 没到静态链表尾
45.    {
46.      i=L[i].cur; // 指向下一个元素
47.      j++;
48.    }
49.    return j;
50.  }
52.  Status GetElem(SLinkList L,int n, int i,ElemType &e)
53.  { // 用e返回L中表头位序为n的链表的第i个元素的值
54.    int l,k=n; // k指向表头序号
55.    if(i<1||i>ListLength(L,n)) // i值不合理
56.      return ERROR;
57.    for(l=1;l<=i;l++) // 移动i-1个元素
58.      k=L[k].cur;
59.    e=L[k].data;
60.    return OK;
61.  }
63.  int LocateElem(SLinkList L,int n,ElemType e) // 算法2.13(有改动)
64.  { // 在L中表头位序为n的静态单链表中查找第1个值为e的元素。
65.    // 若找到，则返回它在L中的位序，否则返回0。(与其它LocateElem()的定义不同)
66.    int i=L[n].cur; // i指示表中第一个结点
67.    while(i&&L[i].data!=e) // 在表中顺链查找(e不能是字符串)
68.      i=L[i].cur;
69.    return i;
70.  }
72.  Status PriorElem(SLinkList L,int n,ElemType cur_e,ElemType &pre_e)
73.  { // 初始条件：在L中表头位序为n的静态单链表已存在
74.    // 操作结果：若cur_e是此单链表的数据元素，且不是第一个，
75.    //           则用pre_e返回它的前驱，否则操作失败，pre_e无定义
76.    int j,i=L[n].cur; // i为链表第一个结点的位置
77.    do
78.    { // 向后移动结点
79.      j=i;
80.      i=L[i].cur;
81.    }while(i&&cur_e!=L[i].data);
82.    if(i) // 找到该元素
83.    {
84.      pre_e=L[j].data;
85.      return OK;
86.    }
87.    return ERROR;
88.  }
90.  Status NextElem(SLinkList L,int n,ElemType cur_e,ElemType &next_e)
91.  { // 初始条件：在L中表头位序为n的静态单链表已存在
92.    // 操作结果：若cur_e是此单链表的数据元素，且不是最后一个，
93.    // 则用next_e返回它的后继，否则操作失败，next_e无定义
94.    int i;
95.    i=LocateElem(L,n,cur_e); // 在链表中查找第一个值为cur_e的元素的位置
96.    if(i) // 在静态单链表中存在元素cur_e
97.    {
98.      i=L[i].cur; // cur_e的后继的位置
99.      if(i) // cur_e有后继
100.      {
101.        next_e=L[i].data;
102.        return OK; // cur_e元素有后继
103.      }
104.    }
105.    return ERROR; // L不存在cur_e元素,cur_e元素无后继
106.  }
108.  Status ListInsert(SLinkList L,int n,int i,ElemType e)
109.  { // 在L中表头位序为n的链表的第i个元素之前插入新的数据元素e
110.    int l,j,k=n; // k指向表头
111.    if(i<1||i>ListLength(L,n)+1)
112.      return ERROR;
113.    j=Malloc(L); // 申请新单元
114.    if(j) // 申请成功
115.    {
116.      L[j].data=e; // 赋值给新单元
117.      for(l=1;l<i;l++) // 游标向后移动i-1个元素
118.        k=L[k].cur;
119.      L[j].cur=L[k].cur;
120.      L[k].cur=j;
121.      return OK;
122.    }
123.    return ERROR;
124.  }
126.  Status ListDelete(SLinkList L,int n,int i,ElemType &e)
127.  { // 删除在L中表头位序为n的链表的第i个数据元素e，并返回其值
128.    int j,k=n; // k指向表头
129.    if(i<1||i>ListLength(L,n))
130.      return ERROR;
131.    for(j=1;j<i;j++) // 游标向后移动i-1个元素
132.      k=L[k].cur;
133.    j=L[k].cur;
134.    L[k].cur=L[j].cur;
135.    e=L[j].data;
136.    Free(L,j);
137.    return OK;
138.  }
140.  void ListTraverse(SLinkList L,int n,void(*vi)(ElemType))
141.  { // 依次对L中表头位序为n的链表的每个数据元素调用函数vi()
142.    int i=L[n].cur; // 指向第一个元素
143.    while(i) // 没到静态链表尾
144.    {
145.      vi(L[i].data); // 调用vi()
146.      i=L[i].cur; // 指向下一个元素
147.    }
148.    printf("/n");
149.  }