顺序表示的线性表的基本操作

1. /* ********************************************************
2.  * 科目； 顺序表示的线性表的基本操作
3.  * 描述；用C实现线性表；
4.  *作者；刘柏燊
5.  *2008年12月14日
6. ***********************************************************/
8.  void InitList(SqList *L) 
10.  { /* 操作结果：构造一个空的顺序线性表L */
12.    (*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
14.    if(!(*L).elem)
16.      exit(OVERFLOW); /* 存储分配失败 */
18.    (*L).length=0; /* 空表长度为0 */
20.    (*L).listsize=LIST_INIT_SIZE; /* 初始存储容量 */
22.  }
26.  
27. 
    
28. void DestroyList(SqList *L)
30.  { /* 初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表L */
32.    free((*L).elem);
34.    (*L).elem=NULL;
36.    (*L).length=0;
38.    (*L).listsize=0;
40.  }
44.  
45. 
    
46. void ClearList(SqList *L)
48.  { /* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
50.    (*L).length=0;
52.  }
56.  
57. 
    
58. Status ListEmpty(SqList L)
60.  { /* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
62.    if(L.length==0)
64.      return TRUE;
66.    else
68.      return FALSE;
70.  }
74. 
    
75. 
    
76.  int ListLength(SqList L)
78.  { /* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
80.    return L.length;
82.  }
86. 
    
87. 
    
88.  Status GetElem(SqList L,int i,ElemType *e)
90.  { /* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)。操作结果：用e返回L中第i个数据元素的值 */
92.    if(i<1||i>L.length)
94.      return ERROR;
96.    *e=*(L.elem+i-1);
98.    return OK;
100.  }
104. 
     
105. 
     
106.  int LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType))
108.  { /* 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0) */
110.    /* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。 */
112.    /*           若这样的数据元素不存在，则返回值为0。算法2.6 */
114.    ElemType *p;
116.    int i=1; /* i的初值为第1个元素的位序 */
118.    p=L.elem; /* p的初值为第1个元素的存储位置 */
120.    while(i<=L.length&&!compare(*p++,e))
122.      ++i;
124.    if(i<=L.length)
126.      return i;
128.    else
130.      return 0;
132.  }
136. 
     
137. 
     
138.  Status PriorElem(SqList L,ElemType cur_e,ElemType *pre_e)
140.  { /* 初始条件：顺序线性表L已存在 */
142.    /* 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱， */
144.    /*           否则操作失败，pre_e无定义 */
146.    int i=2;
148.    ElemType *p=L.elem+1;
150.    while(i<=L.length&&*p!=cur_e)
152.    {
154.      p++;
156.      i++;
158.    }
160.    if(i>L.length)
162.      return INFEASIBLE; /* 操作失败 */
164.    else
166.    {
168.      *pre_e=*--p;
170.      return OK;
172.    }
174.  }
178. 
     
179. 
     
180.  Status NextElem(SqList L,ElemType cur_e,ElemType *next_e)
182.  { /* 初始条件：顺序线性表L已存在 */
184.    /* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */
186.    /*           否则操作失败，next_e无定义 */
188.    int i=1;
190.    ElemType *p=L.elem;
192.    while(i<L.length&&*p!=cur_e)
194.    {
196.      i++;
198.      p++;
200.    }
202.    if(i==L.length)
204.      return INFEASIBLE; /* 操作失败 */
206.    else
208.    {
210.      *next_e=*++p;
212.      return OK;
214.    }
216.  }
220. 
     
221. 
     
222.  Status ListInsert(SqList *L,int i,ElemType e) /* 算法2.4 */
224.  { /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 */
226.    /* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
228.    ElemType *newbase,*q,*p;
230.    if(i<1||i>(*L).length+1) /* i值不合法 */
232.      return ERROR;
234.    if((*L).length>=(*L).listsize) /* 当前存储空间已满,增加分配 */
236.    {
238.      newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LIST_INCREMENT)*sizeof(ElemType));
240.      if(!newbase)
242.        exit(OVERFLOW); /* 存储分配失败 */
244.      (*L).elem=newbase; /* 新基址 */
246.      (*L).listsize+=LIST_INCREMENT; /* 增加存储容量 */
248.    }
250.    q=(*L).elem+i-1; /* q为插入位置 */
252.    for(p=(*L).elem+(*L).length-1;p>=q;--p) /* 插入位置及之后的元素右移 */
254.      *(p+1)=*p;
256.    *q=e; /* 插入e */
258.    ++(*L).length; /* 表长增1 */
260.    return OK;
262.  }
266. 
     
267. 
     
268.  Status ListDelete(SqList *L,int i,ElemType *e) /* 算法2.5 */
270.  { /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
272.    /* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
274.    ElemType *p,*q;
276.    if(i<1||i>(*L).length) /* i值不合法 */
278.      return ERROR;
280.    p=(*L).elem+i-1; /* p为被删除元素的位置 */
282.    *e=*p; /* 被删除元素的值赋给e */
284.    q=(*L).elem+(*L).length-1; /* 表尾元素的位置 */
286.    for(++p;p<=q;++p) /* 被删除元素之后的元素左移 */
288.      *(p-1)=*p;
290.    (*L).length--; /* 表长减1 */
292.    return OK;
294.  }
298. 
     
299. 
     
300.  void ListTraverse(SqList L,void(*vi)(ElemType*))
302.  { /* 初始条件：顺序线性表L已存在 */
304.    /* 操作结果：依次对L的每个数据元素调用函数vi() */
306.    /*           vi()的形参加'&'，表明可通过调用vi()改变元素的值 */
308.    ElemType *p;
310.    int i;
312.    p=L.elem;
314.    for(i=1;i<=L.length;i++)
316.      vi(p++);
318.    printf("/n");
320.  }

以上每一个函数可以单独组合。