线性链表 各种操作整理 数据结构

#include "stdlib.h" #include "stdio.h" #include "conio.h" struct list { int data; struct list *next; }; typedef struct list node; typedef node *link; /* **删除链表中的节点 **节点tmp指向被删除节点的前一个节点 **返回值为删除tmp后一个节点的链表头指针 */ link delete_node(link pointer, link tmp) { /*如果被删除节点的前一个节点为空,说明被删除节点为头节点, 将头节点后移一个节点即可*/ if (tmp==NULL) { return pointer->next; } /*如果被删除节点不是链表的头节点*/ else { /*如果被删除节点的后继节点为空, 说明该节点为链表的尾节点, 将tmp的后继节点指空即可*/ if(tmp->next->next==NULL) { tmp->next=NULL; } /*如果被删除节点为非头节点和非尾节点. 将tmp的后继节点指向被删除节点的后继节点即可*/ else {/*delete the other node*/ tmp->next=tmp->next->next; } return pointer; } } /* **对链表进行选择排序, 每次输出当前链表的最小元素, 并从当前链表中删除最小元素节点 */ void selection_sort(link pointer, int num) { link tmp, btmp; /*tmp指向当前遍历到的节点, btmp指向当前链表最小元素节点的前一个节点*/ int i, min; /*min中保存最小元素*/ for(i=0; i <num; i++) { tmp=pointer; /*tmp指向链表头节点*/ min=tmp->data; /*min中保存最小元素*/ btmp=NULL; /*tmp指向当前遍历到的节点*/ /*以下while循环完成后,min中保存的值为当前链表的最小元素.bmtp指向当前链表最小元素节点的前一个节点*/ while(tmp->next) { if(min>tmp->next->data) { min=tmp->next->data; /*min中保存最小元素*/ btmp=tmp; /*btmp指向当前链表最小元素节点的前一个节点*/ } tmp=tmp->next; } printf("/40: %d/n",min); pointer=delete_node(pointer,btmp); /*删除当前最小元素节点*/ } } /* **创建链表。 **按照数组元素的顺序,依次将数组元素添加到链表中, 返回值为新创建链表的链表头 */ link create_list(int array[],int num) { link tmp1, tmp2, pointer; int i; pointer = (link)malloc(sizeof(node)); printf("this is the length of struct:%d",sizeof(node)); pointer->data = array[0]; /*创建链表头*/ pointer->next=NULL; /*这句要添加, 防止数组只有一个元素时, 链表头指针域没有指空*/ tmp1 = pointer; /*tmp1指针指向当前已经添加到链表的最后一个节点*/ for(i=1;i <num;i++) { /*新增加一个节点, 保存在tmp2中, 节点数据域为当前数组元素, 指针域指为空*/ tmp2=(link)malloc(sizeof(node)); tmp2->next=NULL; tmp2->data=array[i]; /*将新增加的节点tmp2添加到链表尾*/ tmp1->next=tmp2; /*tmp1后移, 指向当前已经添加到链表的最后一个节点*/ tmp1=tmp1->next; } return pointer; } /* **合并链表 **将头节点为pointer2的链表添加到头节点为pointer1的链表尾.返回值为合并后的链表头节点 */ link concatenate(link pointer1,link pointer2) { link tmp; tmp=pointer1; while(tmp->next) /*遍历到链表1的最后一个节点*/ tmp=tmp->next; tmp->next=pointer2; /*将链表2的头节点pointer2添加到链表1尾节点的后一个节点*/ return pointer1; } void main(void) { int arr1[]={3,12,8,9,11}; link ptr; ptr=create_list(arr1,5); selection_sort(ptr,5); getch(); }  

 

#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; } 

 

#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; }