数据结构C语言实现系列[1]——线性表

#include <stdio.h>


#include <stdlib.h>


typedef int elemType;




/**//************************************************************************/




/**//* 以下是关于线性表顺序存储操作的16种算法 */




/**//************************************************************************/




struct List...{


elemType *list;


int size;


int maxSize;


};




void againMalloc(struct List *L)




...{




/**//* 空间扩展为原来的2倍，并由p指针所指向，原内容被自动拷贝到p所指向的存储空间 */


elemType *p = realloc(L->list, 2 * L->maxSize * sizeof(elemType));




if(!p)...{ /**//* 分配失败则退出运行 */


printf("存储空间分配失败！ ");


exit(1);


}




L->list = p; /**//* 使list指向新线性表空间 */




L->maxSize = 2 * L->maxSize; /**//* 把线性表空间大小修改为新的长度 */


}






/**//* 1.初始化线性表L，即进行动态存储空间分配并置L为一个空表 */


void initList(struct List *L, int ms)




...{




/**//* 检查ms是否有效，若无效的则退出运行 */




if(ms <= 0)...{


printf("MaxSize非法！ ");




exit(1); /**//* 执行此函数中止程序运行，此函数在stdlib.h中有定义 */


}




L->maxSize = ms; /**//* 设置线性表空间大小为ms */


L->size = 0;


L->list = malloc(ms * sizeof(elemType));




if(!L->list)...{


printf("空间分配失败！ ");


exit(1);


}


return;


}






/**//* 2.清除线性表L中的所有元素，释放存储空间，使之成为一个空表 */


void clearList(struct List *L)




...{




if(L->list != NULL)...{


free(L->list);


L->list = 0;


L->size = L->maxSize = 0;


}


return;


}






/**//* 3.返回线性表L当前的长度，若L为空则返回０ */


int sizeList(struct List *L)




...{


return L->size;


}






/**//* 4.判断线性表L是否为空，若为空则返回1, 否则返回0 */


int emptyList(struct List *L)




...{




if(L->size ==0)...{


return 1;


}




else...{


return 0;


}


}






/**//* 5.返回线性表L中第pos个元素的值，若pos超出范围，则停止程序运行 */


elemType getElem(struct List *L, int pos)




...{




if(pos < 1 || pos > L->size)...{ /**//* 若pos越界则退出运行 */


printf("元素序号越界！ ");


exit(1);


}




return L->list[pos - 1]; /**//* 返回线性表中序号为pos值的元素值 */


}






/**//* 6.顺序扫描（即遍历）输出线性表L中的每个元素 */


void traverseList(struct List *L)




...{


int i;




for(i = 0; i < L->size; i++)...{


printf("%d ", L ->list[i]);


}


printf(" ");


return;


}






/**//* 7.从线性表L中查找值与x相等的元素，若查找成功则返回其位置，否则返回-1 */


int findList(struct List *L, elemType x)




...{


int i;




for(i = 0; i < L->size; i++)...{




if(L->list[i] == x)...{


return i;


}


}


return -1;


}






/**//* 8.把线性表L中第pos个元素的值修改为x的值，若修改成功返回1，否则返回0 */


int updatePosList(struct List *L, int pos, elemType x)




...{




if(pos < 1 || pos > L->size)...{ /**//* 若pos越界则修改失败 */


return 0;


}


L->list[pos - 1] = x;


return 1;


}






/**//* 9.向线性表L的表头插入元素x */


void inserFirstList(struct List *L, elemType x)




...{


int i;




if(L->size == L->maxSize)...{


againMalloc(L);


}




for(i = L->size - 1; i >= 0; i--)...{


L->list[i + 1] = L ->list[i];


}


L->list[0] = x;


L->size ++;


return;


}






/**//* 10.向线性表L的表尾插入元素x */


void insertLastList(struct List *L, elemType x)




...{




if(L->size == L ->maxSize)...{ /**//* 重新分配更大的存储空间 */


againMalloc(L);


}




L->list[L->size] = x; /**//* 把x插入到表尾 */




L->size++; /**//* 线性表的长度增加１ */


return;


}






/**//* 11.向线性表L中第pos个元素位置插入元素x，若插入成功返回１，否则返回０ */


int insertPosList(struct List *L, int pos, elemType x)




...{


int i;




if(pos < 1 || pos > L->size + 1)...{ /**//* 若pos越界则插入失败 */


return 0;


}




if(L->size == L->maxSize)...{ /**//* 重新分配更大的存储空间 */


againMalloc(L);


}




for(i = L->size - 1; i >= pos - 1; i--)...{


L->list[i + 1] = L->list[i];


}


L->list[pos - 1] = x;


L->size++;


return 1;


}




/**//* 12.向有序线性表L中插入元素x,　使得插入后仍然有序*/


void insertOrderList(struct List *L, elemType x)




...{


int i, j;




/**//* 若数组空间用完则重新分配更大的存储空间 */




if(L->size == L->maxSize)...{


againMalloc(L);


}




/**//* 顺序查找出x的插入位置 */




for(i = 0; i < L->size; i++)...{




if(x < L->list[i])...{


break;


}


}




/**//* 从表尾到下标i元素依次后移一个位置， 把i的位置空出来 */


for(j = L->size - 1; j >= i; j--)


L->list[j+1] = L->list[j];




/**//* 把x值赋给下标为i的元素 */


L->list[i] = x;




/**//* 线性表长度增加1 */


L->size++;


return;


}






/**//* 13.从线性表L中删除表头元素并返回它，若删除失败则停止程序运行 */


elemType deleteFirstList(struct List *L)




...{


elemType temp;


int i;




if(L ->size == 0)...{


printf("线性表为空，不能进行删除操作！ ");


exit(1);


}


temp = L->list[0];


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


L->list[i-1] = L->list[i];


L->size--;


return temp;


}






/**//* 14.从线性表L中删除表尾元素并返回它，若删除失败则停止程序运行 */


elemType deleteLastList(struct List *L)




...{




if(L ->size == 0)...{


printf("线性表为空，不能进行删除操作！ ");


exit(1);


}


L->size--;




return L ->list[L->size]; /**//* 返回原来表尾元素的值 */


}




/**//* 15.从线性表L中删除第pos个元素并返回它，若删除失败则停止程序运行 */


elemType deletePosList(struct List *L, int pos)




...{


elemType temp;


int i;




if(pos < 1 || pos > L->size)...{ /**//* pos越界则删除失败 */


printf("pos值越界，不能进行删除操作！ ");


exit(1);


}


temp = L->list[pos-1];


for(i = pos; i < L->size; i++)


L->list[i-1] = L->list[i];


L->size--;


return temp;


}




/**//* 16.从线性表L中删除值为x的第一个元素，若成功返回1，失败返回0 */


int deleteValueList(struct List *L, elemType x)




...{


int i, j;




/**//* 从线性表中顺序查找出值为x的第一个元素 */




for(i = 0; i < L->size; i++)...{




if(L->list[i] == x)...{


break;


}


}




/**//* 若查找失败，表明不存在值为x的元素，返回0 */




if(i == L->size)...{


return 0;


}




/**//* 删除值为x的元素L->list[i] */




for(j = i + 1; j < L->size; j++)...{


L->list[j-1] = L->list[j];


}


L->size--;


return 1;


}






/**//************************************************************************/




void main()




...{




int a[10] = ...{2, 4, 6, 8, 10, 12, 14, 16, 18, 20};


int i;


struct List L;


initList(&L, 5);




for(i = 0; i < 10; i++)...{


insertLastList(&L, a[i]);


}


insertPosList(&L, 11, 48); insertPosList(&L, 1, 64);


printf("%d ", getElem(&L, 1));


traverseList(&L);


printf("%d ", findList(&L, 10));


updatePosList(&L, 3, 20);


printf("%d ", getElem(&L, 3));


traverseList(&L);


deleteFirstList(&L); deleteFirstList(&L);


deleteLastList(&L); deleteLastList(&L);


deletePosList(&L, 5); ;deletePosList(&L, 7);


printf("%d ", sizeList(&L));


printf("%d ", emptyList(&L));


traverseList(&L);


clearList(&L);


return 0;


}


#include <stdio.h>


#include <stdlib.h>


#define NN 12


#define MM 20


typedef int elemType ;




/**//************************************************************************/




/**//* 以下是关于线性表链接存储（单链表）操作的16种算法 */




/**//************************************************************************/




struct sNode...{ /**//* 定义单链表结点类型 */


elemType data;


struct sNode *next;


};






/**//* 1.初始化线性表，即置单链表的表头指针为空 */


void initList(struct sNode* *hl)




...{


*hl = NULL;


return;


}






/**//* 2.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表 */


void clearList(struct sNode* *hl)




...{




/**//* cp和np分别作为指向两个相邻结点的指针 */


struct sNode *cp, *np;


cp = *hl;




/**//* 遍历单链表，依次释放每个结点 */




while(cp != NULL)...{




np = cp->next; /**//* 保存下一个结点的指针 */


free(cp);


cp = np;


}




*hl = NULL; /**//* 置单链表的表头指针为空 */


return;


}






/**//* 3.返回单链表的长度 */


int sizeList(struct sNode *hl)




...{




int count = 0; /**//* 用于统计结点的个数 */




while(hl != NULL)...{


count++;


hl = hl->next;


}


return count;


}






/**//* 4.检查单链表是否为空，若为空则返回１，否则返回０ */


int emptyList(struct sNode *hl)




...{




if(hl == NULL)...{


return 1;




}else...{


return 0;


}


}






/**//* 5.返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行 */


elemType getElem(struct sNode *hl, int pos)




...{




int i = 0; /**//* 统计已遍历的结点个数 */




if(pos < 1)...{


printf("pos值非法，退出运行！ ");


exit(1);


}




while(hl != NULL)...{


i++;




if(i == pos)...{


break;


}


hl = hl->next;


}




if(hl != NULL)...{


return hl->data;




}else...{


printf("pos值非法，退出运行！ ");


exit(1);


}


}






/**//* 6.遍历一个单链表 */


void traverseList(struct sNode *hl)




...{




while(hl != NULL)...{


printf("%5d", hl->data);


hl = hl->next;


}


printf(" ");


return;


}






/**//* 7.从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL */


elemType* findList(struct sNode *hl, elemType x)




...{




while(hl != NULL)...{




if(hl->data == x)...{


return &hl->data;




}else...{


hl = hl->next;


}


}


return NULL;


}






/**//* 8.把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０ */


int updatePosList(struct sNode *hl, int pos, elemType x)




...{


int i = 0;


struct sNode *p = hl;




while(p != NULL)...{ /**//* 查找第pos个结点 */


i++;




if(pos == i)...{


break;




}else...{


p = p->next;


}


}




if(pos == i)...{


p->data = x;


return 1;




}else...{


return 0;


}


}






/**//* 9.向单链表的表头插入一个元素 */


void insertFirstList(struct sNode* *hl, elemType x)




...{


struct sNode *newP;


newP = malloc(sizeof(struct sNode));




if(newP == NULL)...{


printf("内存分配失败，退出运行！ ");


exit(1);


}




newP->data = x; /**//* 把x的值赋给新结点的data域 */




/**//* 把新结点作为新的表头结点插入 */


newP->next = *hl;


*hl = newP;


return;


}






/**//* 10.向单链表的末尾添加一个元素 */


void insertLastList(struct sNode* *hl, elemType x)




...{


struct sNode *newP;


newP = malloc(sizeof(struct sNode));




if(newP == NULL)...{


printf("内在分配失败，退出运行！ ");


exit(1);


}




/**//* 把x的值赋给新结点的data域，把空值赋给新结点的next域 */


newP->data = x;


newP->next = NULL;




/**//* 若原表为空，则作为表头结点插入 */




if(*hl == NULL)...{


*hl = newP;


}




/**//* 查找到表尾结点并完成插入 */




else...{


struct sNode *p = NULL;




while(p->next != NULL)...{


p = p->next;


}


p->next = newP;


}


return;


}






/**//* 11.向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回１，否则返回０ */




int insetPosList(struct sNode* *hl, int pos, elemType x)...{


int i = 0;


struct sNode *newP;


struct sNode *cp = *hl, *ap = NULL;




/**//* 对pos值小于等于０的情况进行处理 */




if(pos <= 0)...{


printf("pos值非法，返回０表示插入失败！ ");


return 0;


}




/**//* 查找第pos个结点 */




while(cp != NULL)...{


i++;




if(pos == i)...{


break;




}else...{


ap = cp;


cp = cp->next;


}


}




/**//* 产生新结点，若分配失败，则停止插入 */


newP = malloc(sizeof(struct sNode));




if(newP == NULL)...{


printf("内存分配失败，无法进行插入操作！ ");


return 0;


}




/**//* 把x的值赋给新结点的data域 */


newP->data = x;




/**//* 把新结点插入到表头 */




if(ap == NULL)...{




newP->next = cp; /**//* 或改为newP->next = *hl; */


*hl = newP;


}




/**//* 把新结点插入到ap和cp之间 */




else...{


newP->next = cp;


ap->next = newP;


}




return 1; /**//* 插入成功返回1 */


}






/**//* 12.向有序单链表中插入元素x结点，使得插入后仍然有序 */


void insertOrderList(struct sNode* *hl, elemType x)




...{




/**//* 把单链表的表头指针赋给cp，把ap置空 */


struct sNode *cp = *hl, *ap = NULL;




/**//* 建立新结点 */


struct sNode *newP;


newP = malloc(sizeof(struct sNode));




if(newP == NULL)...{


printf("内在分配失败，退出运行！ ");


exit(1);


}




newP->data = x; /**//* 把x的值赋给新结点的data域 */




/**//* 把新结点插入到表头 */




if((cp == NULL) || (x < cp->data))...{


newP->next = cp;


*hl = newP;


return;


}




/**//* 顺序查找出x结点的插入位置 */




while(cp != NULL)...{




if(x < cp->data)...{


break;




}else...{


ap = cp;


cp = cp->next;


}


}




/**//* 把x结点插入到ap和cp之间 */


newP->next = cp;


ap->next = newP;


return;


}






/**//* 13.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行 */


elemType deleteFirstList(struct sNode* *hl)




...{


elemType temp;




struct sNode *p = *hl; /**//* 暂存表头结点指针，以便回收 */




if(*hl == NULL)...{


printf("单链表为空，无表头可进行删除，退出运行！ ");


exit(1);


}




*hl = (*hl)->next; /**//* 使表头指针指向第二个结点 */




temp = p->data; /**//* 暂存原表头元素，以便返回 */




free(p); /**//* 回收被删除的表头结点 */




return temp; /**//* 返回第一个结点的值 */


}






/**//* 14.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行 */


elemType deleteLastList(struct sNode* *hl)




...{


elemType temp;




/**//* 初始化cp和ap指针，使cp指向表头结点，使ap为空 */


struct sNode *cp = *hl;


struct sNode *ap = NULL;




/**//* 单链表为空则停止运行 */




if(cp == NULL)...{


printf("单链表为空，无表头进行删除，退出运行！ ");


exit(1);


}




/**//* 从单链表中查找表尾结点，循环结束时cp指向表尾结点，ap指向其前驱结点 */




while(cp->next != NULL)...{


ap = cp;


cp = cp->next;


}




/**//* 若单链表中只有一个结点，则需要修改表头指针 */




if(ap == NULL)...{




*hl = (*hl)->next; /**//* 或改为*hl = NULL; */


}




/**//* 删除表尾结点 */




else...{


ap->next = NULL;


}




/**//* 暂存表尾元素，以便返回 */


temp = cp->data;




free(cp); /**//* 回收被删除的表尾结点 */




return temp; /**//* 返回表尾结点的值 */


}






/**//* 15.从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行 */


elemType deletePosList(struct sNode* *hl, int pos)




...{


int i = 0;


elemType temp;




/**//* 初始化cp和ap指针，使cp指向表头结点，使ap为空 */


struct sNode *cp = *hl;


struct sNode *ap = NULL;




/**//* 单链表为空或pos值非法则停止运行 */




if((cp == NULL) || (pos <= 0))...{


printf("单链表为空或pos值不正确，退出运行！ ");


exit(1);


}




/**//* 从单链表中查找第pos个结点，找到后由cp指向该结点，由ap指向其前驱结点 */




while(cp != NULL)...{


i++;




if(i == pos)...{


break;


}


ap = cp;


cp = cp->next;


}




/**//* 单链表中没有第pos个结点 */




if(cp == NULL)...{


printf("pos值不正确，退出运行！ ");


exit(1);


}




/**//* 若pos等于1，则需要删除表头结点 */




if(pos == 1)...{




*hl = (*hl)->next; /**//* 或改为*hl = cp->next; */


}




/**//* 否则删除非表头结点，此时cp指向该结点，ap指向前驱结点 */




else...{


ap->next = cp->next;


}




/**//* 暂存第pos个结点的值，以便返回 */


temp = cp->data;




free(cp); /**//* 回收被删除的第pos个结点 */




return temp; /**//* 返回在temp中暂存的第pos个结点的值 */


}






/**//* 16.从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0 */


int deleteValueList(struct sNode* *hl, elemType x)




...{




/**//* 初始化cp和ap指针，使cp指向表头结点，使ap为空 */


struct sNode *cp = *hl;


struct sNode *ap = NULL;




/**//* 从单链表中查找值为x的结点，找到后由cp指向该结点，由ap指向其前驱结点 */




while(cp != NULL)...{




if(cp->data == x)...{


break;


}


ap = cp;


cp = cp->next;


}




/**//* 若查找失败，即该单链表中不存在值为x的结点，则返回0 */




if(cp == NULL)...{


return 0;


}




/**//* 如果删除的是表头或非表头结点则分别进行处理 */




if(ap == NULL)...{




*hl = (*hl)->next; /**//* 或改为*hl= cp->next */




}else...{


ap->next = cp->next;


}




free(cp); /**//* 回收被删除的结点 */




return 1; /**//* 返回1表示删除成功 */


}






/**//************************************************************************/




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




...{


int a[NN];


int i;


struct sNode *p, *h, *s;


srand(time(NULL));


initList(&p);




for(i = 0; i < NN; i++)...{


a[i] = rand() & MM;


}


printf("随机数序列：");




for(i = 0; i < NN; i++)...{


printf("%5d", a[i]);


}


printf(" ");


printf("随机数逆序：");




for(i = 0; i < NN; i++)...{


insertFirstList(&p, a[i]);


}


traverseList(p);


printf("单链表长度：%5d ", sizeList(p));




for(h = p; h != NULL; h = h->next)...{




while(deleteValueList(&(h->next), h->data))...{


;


}


}


printf("去除重复数：");


traverseList(p);


printf("单链表长度：%5d ", sizeList(p));


h = NULL;




for(s = p; s != NULL; s = s->next)...{


insertOrderList(&h, s->data);


}


printf("有序表序列：");


traverseList(h);


clearList(&p);


system("pause");


return 0;


}