线性表的顺序表示和实现

-----------------------------------------main.c-------------------------------------------------

#include <stdio.h>

#include "sqlist.h"

int main(int argc, char *argv[])

{

SqList *La = (SqList*) malloc(sizeof(SqList));

SqList *Lb = (SqList*) malloc(sizeof(SqList));

SqList *Lc = (SqList*) malloc(sizeof(SqList));

InitList_Sq(La);

InitList_Sq(Lb);

InitList_Sq(Lc);

ElemType *e;

e = (ElemType*) malloc(sizeof(ElemType));

int i;

for (i = 1; i <= LIST_INIT_SIZE; i += 2)

{

e->idx = i;

e->value = i;

ListInsert_Sq(La, La->length + 1, e);

}

printf("初始化后，顺序表La的状态为：\n");

PrintStatus_Sq(La);

for (i = 2; i <= LIST_INIT_SIZE; i += 3)

{

e->idx = i;

e->value = i;

ListInsert_Sq(Lb, Lb->length + 1, e);

}

printf("初始化后，顺序表Lb的状态为：\n");

PrintStatus_Sq(Lb);

MergeList_Sq(La, Lb, Lc);

printf("合并两表后，顺序表Lc的状态为：\n");

PrintStatus_Sq(Lc);

return OK;

}

-----------------------------------------sqlist.h-------------------------------------------------

#ifndef SQLIST_H_

#define SQLIST_H_

#include <malloc.h>

#include <stdlib.h>

#define TRUE                (1)

#define FALSE                (0)

#define OK                    (1)

#define ERROR                (0)

#define INFEAZIBLE            (-1)

#define OVERFLOW            (-2)

#define LIST_INIT_SIZE        (10)

#define LISTINCREMENT        (10)

typedef int Status;

/*

* 定义表中的元素

*/

typedef struct

{

int idx;

int value;

} ElemType;

/*

* 定义线性表

*/

typedef struct

{

ElemType *elem; //存储空间基址

int length; //当前长度

int listsize; //当前分配的存储容量，以sizeof(ElemType)为单位

} SqList;

Status InitList_Sq(SqList* const L);

Status ListInsert_Sq(SqList* const L, const int i, ElemType const *e);

Status ListDelete_Sq(SqList* const L, const int i, ElemType* const e);

int LocateElem_Sq(const SqList *L, const ElemType *e, Status(*compare)(

const ElemType*, const ElemType*));

Status equalElem_Sq(const ElemType *e1, const ElemType *e2);

int ListLength_Sq(const SqList *L);

void PrintStatus_Sq(const SqList *L);

Status MergeList_Sq(const SqList *a, const SqList *b, SqList *c);

#endif /* SQLIST_H_ */

-----------------------------------------sqlist.c-------------------------------------------------

#include "sqlist.h"

#include <stdio.h>

/*

* 线性表的初始化，初始化后，线性表可容纳LIST_INT_SIZE，即10个元素

*/

Status InitList_Sq(SqList* const L)

{

L->elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType));

if (!L->elem)

exit(OVERFLOW); //存储分配失败

L->length = 0; //空表长度为0

L->listsize = LIST_INIT_SIZE; //初始存储容量

return OK;

}//InitList_Sq()

/*

* 求表长，也即元素个数

*/

int ListLength_Sq(const SqList *L)

{

return L->length;

}//ListLength_Sq

/*

* 判断两个元素是否相同，是则返回真，否则返回假

*/

Status equalElem_Sq(const ElemType *e1, const ElemType *e2)

{

if (e1->idx == e2->idx && e1->value == e2->value)

return TRUE;

else

return FALSE;

}//equalElem_Sq

/*

* 按compare函数所表示的条件查找元素在线性表中的位置

*/

int LocateElem_Sq(const SqList *L, const ElemType *e, Status(*compare)(

const ElemType*, const ElemType*))

{

return 0;

}//LocateElem_Sq

/*

* 在顺序线性表L的第i个位置前插入新的元素e，这里i的合法值为：1 <= i <= ListLength_Sq(L) + 1

*/

Status ListInsert_Sq(SqList* const L, const int i, ElemType const *e)

{

if (i < 1 || i > ListLength_Sq(L) + 1)

return ERROR; //i值不合法

if (L->length >= L->listsize)

{

ElemType *newbase;

newbase = (ElemType*) realloc(L->elem, (L->listsize

+ LISTINCREMENT) * sizeof(ElemType));

if (!newbase)

exit(OVERFLOW); //存储分配失败

L->elem = newbase; //新基址

L->listsize += LISTINCREMENT; //增加存储容量

}

ElemType *q = &(L->elem[i - 1]); //q为插入点位置

ElemType *p;

for (p = &(L->elem[L->length - 1]); p >= q; --p)

*(p + 1) = *p; //插入位置及其以后的元素右移一位

*q = *e; //插入e

++L->length; //表长增1

return OK;

}//ListInsert_Sq

/*

* 在顺序线性表中删除第i个元素，并用e返回其值

*/

Status ListDelete_Sq(SqList* const L, const int i, ElemType* const e)

{

if (i < 1 || i > L->length)

return ERROR; //i值不合法

ElemType *p = &(L->elem[i - 1]);

*e = *p;

ElemType *last = L->elem + L->length - 1;

for (; p < last; ++p)

*p = *(p + 1);

--L->length;

return OK;

}//ListDelete_Sq

/*

* 打印线性表L中的所有元素

*/

void PrintStatus_Sq(const SqList *L)

{

printf("当前顺序线性表中共有元素%d个，分别为：\n", L->length);

int i;

for (i = 1; i <= L->length; ++i)

{

int j;

for (j = 0; j < 10; ++j)

putchar('-');

printf("%d", i);

for (j = 0; j < 10; ++j)

putchar('-');

printf("\n%d\n%d\n", L->elem[i - 1].idx, L->elem[i - 1].value);

}

}

/*

* 已知顺序线性表La和Lb的元素按值非递减排列，归并La和Lb得到新的顺序线性表Lc，Lc的元素也按值非递减排列

*/

Status MergeList_Sq(const SqList *La, const SqList *Lb, SqList *Lc)

{

ElemType *pa, *pb, *pa_last, *pb_last;

pa = La->elem, pb = Lb->elem;

pa_last = pa + La->length - 1;

pb_last = pb + Lb->length - 1;

while (pa <= pa_last && pb <= pb_last)

if (pa->value <= pb->value)

ListInsert_Sq(Lc, Lc->length + 1, pa++);

else

ListInsert_Sq(Lc, Lc->length + 1, pb++);

while (pa <= pa_last)

ListInsert_Sq(Lc, Lc->length + 1, pa++);

while (pb <= pb_last)

ListInsert_Sq(Lc, Lc->length + 1, pb++);

return OK;

}//MergeList_Sq