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.  }