数据结构C语言版单链表源代码

合集下载

单链表的完整代码

单链表的完整代码

#include<stdio.h>#include<stdlib.h>#include<malloc.h>typedef int DataType;typedef struct Node{DataType data;struct Node *next;}LinkList;LinkList *creaTaiList() /*建立带头结点的单链表*/ {LinkList *L=(LinkList *)malloc(sizeof(LinkList)); LinkList *s,*r=L;int x;scanf("%d",&x);while(x!=-1){s=(LinkList *)malloc(sizeof(LinkList));s->data=x;r->next=s;r=s;scanf("%d",&x);}r->next=NULL;return L;}void visitElem(LinkList *L) /*遍历单链表*/ {LinkList *s;s=L;while (s->next){s=s->next;printf("%d,",*s);}printf("\n");}LinkList * getElem(LinkList *L,int i) /*按序号查找*/ {LinkList *p=L;int j=0;while(p&&j<i){p=p->next;j++;}if((!p||(j>i))){printf("\n位置错,请重新选择操作!\n");return NULL;}else return p;}int insertElem(LinkList *L,int i,int x) /*直接插入*/ {LinkList *p,*s;int j;p=L; j=0;while(p&&j<i-1){p=p->next;j=j+1; }if((!p)||(j>i-1)){printf("error!\n");return 0;}else {s=(LinkList *)malloc(sizeof(LinkList));s->data=x; s->next=p->next; p->next=s;return 1;}}int deleteElem(LinkList *L,int w,DataType *e) /*删除第i个结点*/ { LinkList *p,*q;int j;p=L;j=0;while ((p->next)&&(j<w-1)){ p=p->next;j++; }if((!p->next)||(j>w-1)){printf("error");return 0;}q=p->next;p->next=q->next;*e=q->data;free(q);return 1;}void longElem(LinkList *L) /*求表长*/{ LinkList *s;int a=0;s=L->next;while (s){s=s->next;a=a+1;}printf("该单链表的长度为:%d\n",a);}void reverse (LinkList *L) /*逆置单链表*/{ LinkList *p,*q;p=L->next;L->next=NULL;while(p){q=p; p=p->next;q->next=L->next;L->next=q;}}void insertyouxuElem(LinkList *L)/*元素插入到有序的单链表中*/ { LinkList *s,*q,*p;int x;q=L;p=L->next;printf("请输入你要插入的数:");scanf("%d",&x);while (p&&p->data<x){q=p;p=p->next;}s=(LinkList *)malloc(sizeof(LinkList));s->data=x;s->next=q->next;q->next=s;printf("插入成功!插入后的单链表为:");}LinkList *uniona(LinkList *A,LinkList *B) /*合并两个表*/ {LinkList *C, *p, *q, *s;p=A->next;q=B->next;C=A;C->next=NULL;while(p&&q){if(p->data<=q->data){s=p; p=p->next; }else{s=q; q=q->next; }s->next=C->next;C->next=s; }if(!q) q=p;while(q){s=q; q=q->next;s->next=C->next;C->next=s;}free(B);return C;}void menu(){ //system("cls");printf("**********************************\n");printf("* 1.建立单链表 2.遍历单链表*\n");printf("* 3.按序号查找 4.插入*\n");printf("* 5.删除 6.求表长*\n");printf("* 7.逆置单链表8.插入有序表*\n");printf("* 9.合并单链表0.退出操作*\n");printf("**********************************\n");//printf("请输入要进行的操作(0-9):\t");}main(){LinkList *h,*o,*p,*R,*A,*B;int i,x;int q;int select;//DataType x;DataType *m;m=(DataType *)malloc(sizeof(DataType));menu();while(1){ //system("cls");//menu();printf("请输入要进行的操作(0-9):");scanf("%d",&select);if(select==0)break;if(select>9||select<0){printf("输入错误,请重新输入相应0-9整数:"); } switch(select){case 1:printf("请输入元素:");h=creaTaiList();printf("建立的点链表为:");visitElem(h);break;case 2:visitElem(h);break;case 3: printf("请输入要查找的序号:");scanf("%d",&i);o=getElem(h,i);if(o)printf("%d\n",*o);break;case 4:printf("进入插入,请输入要插入的位置:");scanf("%d",&i,&x);printf("请输入要插入的数字:");scanf("%d",&x);q=insertElem(h,i,x);printf("更改后的点链表为:");visitElem(h);break;case 5:printf("进入删除,请输入删除的位置:");scanf("%d",&i);q=deleteElem(h,i,m);if(q==1) {printf("删除成功,且删除的元素为:%d\n",*m);printf("删除后的点链表为:");visitElem(h);break;}else printf("error");case 6:longElem(h);break;case 7:reverse (h);printf("逆置后的点链表为:");visitElem(h);break;case 8:printf("建立一个有序的点链表,并将x插入其中:");p=creaTaiList();printf("建好的有序点链表为:");visitElem(p);insertyouxuElem(p);visitElem(p);break;case 9:printf("分别建立A,B点链表\n");printf("输入有序的A族元素:");A=creaTaiList();printf("输入有序的B族元素:");B=creaTaiList();printf("点链表A为:");visitElem(A);printf("点链表B为:");visitElem(B);R=uniona(A,B);printf("合并后的点链表为:");visitElem(R);break;default :printf("输入错误,请重新输入!");continue;}}}[文档可能无法思考全面,请浏览后下载,另外祝您生活愉快,工作顺利,万事如意!]。

C语言单链表实现方法详解

C语言单链表实现方法详解

C语⾔单链表实现⽅法详解本⽂实例讲述了C语⾔单链表实现⽅法。

分享给⼤家供⼤家参考,具体如下:slist.h#ifndef __SLIST_H__#define __SLIST_H__#include<cstdio>#include<malloc.h>#include<assert.h>typedef int ElemType;typedef struct Node { //定义单链表中的结点信息ElemType data; //结点的数据域struct Node *next; //结点的指针域}Node,*PNode;typedef struct List { //定义单链表的链表信息PNode first; //first指向单链表中的第⼀个结点PNode last; //last指向单链表中的最后⼀个结点size_t size; //记录单链表中的结点个数}List;void InitList(List *list);//初始化单链表void push_back(List *list, ElemType x);//在单链表的末尾插⼊元素void push_front(List *list, ElemType x);//在单链表的头部插⼊元素void show_list(List *list);//打印单链表void pop_back(List *list);//删除单链表的最后⼀个元素void pop_front(List *list);//删除单链表的第⼀个元素void insert_val(List *list, ElemType val);//将数据元素插⼊到单链表中(要求此时单链表中的数据元素顺序排列)Node* find(List *list, ElemType x);//查找单链表中数据值为x的结点int length(List *list);//求单链表的长度void delete_val(List *list, ElemType x);//按值删除单链表中的某个数据元素void sort(List *list);//对单链表进⾏排序void reverse(List *list);//逆置单链表void clear(List *list);//清除单链表void destroy(List *list);//摧毁单链表#endif //__SLIST_H__slist.cpp#include"slist.h"void InitList(List *list) {list->first = list->last = (Node*)malloc(sizeof(Node)); //头结点assert(list->first != NULL);list->first->next = NULL;list->size = 0;}void push_back(List *list, ElemType x) {//step 1:创建⼀个新的结点Node *s = (Node*)malloc(sizeof(Node));assert(s != NULL);s->data = x;s->next = NULL;//step 2:将新结点插⼊单链表的表尾list->last->next = s;list->last = s;//step 3:更新单链表的长度list->size++;}void push_front(List *list, ElemType x) {//step 1:创建⼀个新的结点Node *s = (Node*)malloc(sizeof(Node));assert(s != NULL);s->data = x;s->next = NULL;//step 2:将新结点插⼊单链表的表头s->next = list->first->next;list->first->next = s;//step 3:判断插⼊的结点是否是单链表的第⼀个结点,若是更新链表的尾指针if (list->size == 0)list->last = s;//step 4:更新单链表的长度list->size++;}void show_list(List *list) {//step 1:指针p指向单链表的第⼀个结点Node *p = list->first->next;//step 2:循环打印结点的信息while (p != NULL) {printf("%d->", p->data);p = p->next;}printf("Nul.\n");}void pop_back(List *list) {//step 1:判断单链表是否为空if (list->size == 0) return;//step 2:定义指针p使其指向⽬标结点的前⼀个结点Node *p = list->first;//从头结点开始while (p->next != list->last)p = p->next;//step 3:删除⽬标结点free(list->last);list->last = p;list->last->next = NULL;//step 4:更新单链表的长度list->size--;}void pop_front(List *list) {//step 1:判断单链表是否为空if (list->size == 0) return;//step 2:定义指针p使其指向⽬标结点的前⼀个结点Node *p = list->first->next;//step 3:删除⽬标结点list->first->next = p->next;free(p);//step 4:判断删除的结点是否是单链表的最后⼀个结点,若是则更新单链表的尾指针 if (list->size == 1)list->last = list->first;//step 4:更新单链表的长度list->size--;}void insert_val(List *list, ElemType x) {//step 1:创建⼀个新的结点Node *s = (Node*)malloc(sizeof(Node));assert(s != NULL);s->data = x;s->next = NULL;//step 2:定义指针p使其指向待插⼊位置的前⼀个结点Node *p = list->first;//从头结点开始while (p->next != NULL && p->next->data < s->data)p = p->next;//step 3:判断结点的待插⼊位置是否是表尾,若是则更新单链表的尾指针if (p->next == NULL)list->last = s;//step 4:插⼊结点s->next = p->next;p->next = s;//step 5:更新单链表长度list->size++;}Node* find(List *list, ElemType x) {//step 1:指针p指向单链表的第⼀个结点Node *p = list->first->next;//step 2:按照循环顺序查找链表结点while (p != NULL && p->data != x)p = p->next;return p;}int length(List *list) {return list->size;}void delete_val(List *list, ElemType x) {//step 1:判断单链表是否为空if (list->size == 0) return;//step 2:确定结点在单链表中的位置,并判断其是否存在于单链表中Node *p = find(list, x);if (p == NULL) {printf("要删除的数据不存在!\n");return;}//step 3:判断结点位置是否是表尾if (p == list->last)//是表尾pop_back(list);else {//不是表尾Node *q = p->next;p->data = q->data;p->next = q->next;free(q);list->size--;}}void sort(List *list) {//step 1:判断单链表中的结点数是否为0或1if (list->size == 0 || list->size == 1) return;//step 2:将单链表中第⼀个结点之后的链表部分截出,⽅便重新按顺序插⼊链表之中Node *s = list->first->next; // 指针s指向单链表的第⼀个节点Node *p = s->next;//q指向s后⾯的结点list->last = s;//单链表的尾指针指向单链表的第⼀个结点list->last->next = NULL;//截断链表//step 3:将截出的链表中的结点根据其数据域⼤⼩重新插⼊到原来链表中while (p != NULL) {s = p;p = p->next;Node *q = list->first;while (q->next != NULL && q->next->data < s->data)q = q->next;if (q->next == NULL)//判断q此时指向的是否是单链表的最后⼀个结点,若是则更新链表的尾指针list->last = s;//将结点重新插⼊链表s->next = q->next;q->next = s;}}void reverse(List *list) {//step 1:判断单链表中的结点数是否为0或1if (list->size == 0 || list->size == 1) return;//step 2:将单链表中第⼀个结点之后的链表部分截出,然后将截出的链表中的结点按头插法重新插⼊到原链表中 Node *p = list->first->next;Node *q = p->next;list->last = p;list->last->next = NULL;while (q != NULL) {p = q;q = q->next;p->next = list->first->next;list->first->next = p;}}void clear(List *list) {//step 1:判断单链表是否为空if (list->size == 0) return;//step 2:释放单链表中的每⼀个结点Node *p = list->first->next;while (p != NULL) {list->first->next = p->next;free(p);p = list->first->next;}//step 3:头指针和尾指针重新都指向头结点list->last = list->first;//step 4:更新链表长度list->size = 0;}void destroy(List *list) {//step 1:清空单链表clear(list);//step 2:释放头结点free(list->first);//step 3:头指针和尾指针都赋值为空list->first = list->last = NULL;}main.cpp#include"slist.h"void main() {List mylist;InitList(&mylist);ElemType item;Node *p = NULL;int select = 1;while (select) {printf("*******************************************\n"); printf("*[1] push_back [2] push_front *\n");printf("*[3] show_list [4] pop_back *\n");printf("*[5] pop_front [6] insert_val *\n");printf("*[7] find [8] length *\n");printf("*[9] delete_val [10] sort *\n");printf("*[11] reverse [12] clear *\n");printf("*[13*] destroy [0] quit_system *\n"); printf("*******************************************\n"); printf("请选择:>>");scanf("%d", &select);if (select == 0) break;switch (select) {case 1:printf("请输⼊要插⼊的数据(-1结束):>");while (scanf("%d", &item), item != -1) {push_back(&mylist, item);}break;case 2:printf("请输⼊要插⼊的数据(-1结束):>");while (scanf("%d", &item), item != -1) {push_front(&mylist, item);}break;case 3:show_list(&mylist);break;case 4:pop_back(&mylist);break;case 5:pop_front(&mylist);break;case 6:printf("请输⼊要插⼊的数据:>");scanf("%d", &item);insert_val(&mylist, item);break;case 7:printf("请输⼊要查找的数据:>");scanf("%d", &item);p = find(&mylist, item);if (p == NULL)printf("要查找的数据在单链表中不存在!\n"); break;case 8:printf("单链表的长度为%d\n", length(&mylist)); break;case 9:printf("请输⼊要删除的值:>");scanf("%d", &item);delete_val(&mylist, item);break;case 10:sort(&mylist);break;case 11:reverse(&mylist);break;case 12:clear(&mylist);break;//case 13://destroy(&mylist);//break;default:printf("选择错误,请重新选择!\n");break;}}destroy(&mylist); //程序结束,摧毁链表}附:单链表优化版本slist.h#ifndef __SLIST_H__#define __SLIST_H__#include<cstdio>#include<malloc.h>#include<assert.h>typedef int ElemType;typedef struct Node { //定义单链表中的结点信息ElemType data; //结点的数据域struct Node *next; //结点的指针域}Node,*PNode;typedef struct List { //定义单链表的链表信息PNode first; //first指向单链表中的第⼀个结点PNode last; //last指向单链表中的最后⼀个结点size_t size; //记录单链表中的结点个数}List;void InitList(List *list);//初始化单链表void push_back(List *list, ElemType x);//在单链表的末尾插⼊元素void push_front(List *list, ElemType x);//在单链表的头部插⼊元素void show_list(List *list);//打印单链表void pop_back(List *list);//删除单链表的最后⼀个元素void pop_front(List *list);//删除单链表的第⼀个元素void insert_val(List *list, ElemType val);//将数据元素插⼊到单链表中(要求此时单链表中的数据元素顺序排列)Node* find(List *list, ElemType x);//查找单链表中数据值为x的结点int length(List *list);//求单链表的长度void delete_val(List *list, ElemType x);//按值删除单链表中的某个数据元素void sort(List *list);//对单链表进⾏排序void reverse(List *list);//逆置单链表void clear(List *list);//清除单链表void destroy(List *list);//摧毁单链表//代码优化Node* CreateNode(ElemType x); //创建⼀个单链表结点Node* begin(List *list); //返回单链表的第⼀个结点Node* end(List *list); //返回单链表中最后⼀个结点的下⼀个结点void insert(List *list, Node *pos, ElemType x); //在单链表的特定位置(pos)插⼊新的结点#endif //__SLIST_H__slist.cpp#include"slist.h"void InitList(List *list) {list->first = list->last = (Node*)malloc(sizeof(Node)); //头结点assert(list->first != NULL);list->first->next = NULL;list->size = 0;}//push_back的优化void push_back(List *list, ElemType x) {insert(list, end(list), x);}//push_front的优化void push_front(List *list, ElemType x) {insert(list, begin(list), x);}void show_list(List *list) {//step 1:指针p指向单链表的第⼀个结点Node *p = list->first->next;//step 2:循环打印结点的信息while (p != NULL) {printf("%d->", p->data);p = p->next;}printf("Nul.\n");}void pop_back(List *list) {//step 1:判断单链表是否为空if (list->size == 0) return;//step 2:定义指针p使其指向⽬标结点的前⼀个结点Node *p = list->first;//从头结点开始while (p->next != list->last)p = p->next;//step 3:删除⽬标结点free(list->last);list->last = p;list->last->next = NULL;//step 4:更新单链表的长度list->size--;}void pop_front(List *list) {//step 1:判断单链表是否为空if (list->size == 0) return;//step 2:定义指针p使其指向⽬标结点的前⼀个结点Node *p = list->first->next;//step 3:删除⽬标结点list->first->next = p->next;free(p);//step 4:判断删除的结点是否是单链表的最后⼀个结点,若是则更新单链表的尾指针 if (list->size == 1)list->last = list->first;//step 4:更新单链表的长度list->size--;}//insert_val的优化void insert_val(List *list, ElemType x) {//step 1:创建⼀个新的结点Node *s = CreateNode(x);//step 2:定义指针p使其指向待插⼊位置的前⼀个结点Node *p = list->first;//从头结点开始while (p->next != NULL && p->next->data < s->data)p = p->next;//step 3:判断结点的待插⼊位置是否是表尾,若是则更新单链表的尾指针if (p->next == NULL)list->last = s;//step 4:插⼊结点s->next = p->next;p->next = s;//step 5:更新单链表长度list->size++;}Node* find(List *list, ElemType x) {//step 1:指针p指向单链表的第⼀个结点Node *p = list->first->next;//step 2:按照循环顺序查找链表结点while (p != NULL && p->data != x)p = p->next;return p;}int length(List *list) {return list->size;}void delete_val(List *list, ElemType x) {//step 1:判断单链表是否为空if (list->size == 0) return;//step 2:确定结点在单链表中的位置,并判断其是否存在于单链表中Node *p = find(list, x);if (p == NULL) {printf("要删除的数据不存在!\n");return;}//step 3:判断结点位置是否是表尾if (p == list->last)//是表尾pop_back(list);else {//不是表尾Node *q = p->next;p->data = q->data;p->next = q->next;free(q);list->size--;}}void sort(List *list) {//step 1:判断单链表中的结点数是否为0或1if (list->size == 0 || list->size == 1) return;//step 2:将单链表中第⼀个结点之后的链表部分截出,⽅便重新按顺序插⼊链表之中Node *s = list->first->next; // 指针s指向单链表的第⼀个节点Node *p = s->next;//q指向s后⾯的结点list->last = s;//单链表的尾指针指向单链表的第⼀个结点list->last->next = NULL;//截断链表//step 3:将截出的链表中的结点根据其数据域⼤⼩重新插⼊到原来链表中while (p != NULL) {s = p;p = p->next;Node *q = list->first;while (q->next != NULL && q->next->data < s->data)q = q->next;if (q->next == NULL)//判断q此时指向的是否是单链表的最后⼀个结点,若是则更新链表的尾指针list->last = s;//将结点重新插⼊链表s->next = q->next;q->next = s;}}void reverse(List *list) {//step 1:判断单链表中的结点数是否为0或1if (list->size == 0 || list->size == 1) return;//step 2:将单链表中第⼀个结点之后的链表部分截出,然后将截出的链表中的结点按头插法重新插⼊到原链表中 Node *p = list->first->next;Node *q = p->next;list->last = p;list->last->next = NULL;while (q != NULL) {p = q;q = q->next;p->next = list->first->next;list->first->next = p;}}void clear(List *list) {//step 1:判断单链表是否为空if (list->size == 0) return;//step 2:释放单链表中的每⼀个结点Node *p = list->first->next;while (p != NULL) {list->first->next = p->next;free(p);p = list->first->next;}//step 3:头指针和尾指针重新都指向头结点list->last = list->first;//step 4:更新链表长度list->size = 0;}void destroy(List *list) {//step 1:清空单链表clear(list);//step 2:释放头结点free(list->first);//step 3:头指针和尾指针都赋值为空list->first = list->last = NULL;}//优化Node* CreateNode(ElemType x) {Node *s = (Node*)malloc(sizeof(Node));assert(s != NULL);s->data = x;s->next = NULL;return s;}Node* begin(List *list) {return list->first->next;}Node* end(List *list) {return list->last->next;}void insert(List *list, Node *pos, ElemType x) {//step 1:创建⼀个新的结点Node *s = CreateNode(x);//step 2:确定带插⼊位置Node *p = list->first;while (p->next != pos)p = p->next;//step 3:插⼊结点s->next = p->next;p->next = s;//step 4:判断结点是否插⼊到链表的表尾,若是则更新单链表的表尾指针 if (pos == NULL)list->last = s;//step 5:更新单链表长度list->size++;}main.cpp#include"slist.h"void main() {List mylist;InitList(&mylist);ElemType item;Node *p = NULL;int select = 1;while (select) {printf("*******************************************\n");printf("*[1] push_back [2] push_front *\n");printf("*[3] show_list [4] pop_back *\n");printf("*[5] pop_front [6] insert_val *\n");printf("*[7] find [8] length *\n");printf("*[9] delete_val [10] sort *\n");printf("*[11] reverse [12] clear *\n");printf("*[13*] destroy [0] quit_system *\n");printf("*******************************************\n");printf("请选择:>>");scanf("%d", &select);if (select == 0) break;switch (select) {case 1:printf("请输⼊要插⼊的数据(-1结束):>");while (scanf("%d", &item), item != -1) {push_back(&mylist, item);}break;case 2:printf("请输⼊要插⼊的数据(-1结束):>");while (scanf("%d", &item), item != -1) {push_front(&mylist, item);}break;case 3:show_list(&mylist);break;case 4:pop_back(&mylist);break;case 5:pop_front(&mylist);break;case 6:printf("请输⼊要插⼊的数据:>");scanf("%d", &item);insert_val(&mylist, item);break;case 7:printf("请输⼊要查找的数据:>");scanf("%d", &item);p = find(&mylist, item);if (p == NULL)printf("要查找的数据在单链表中不存在!\n");break;case 8:printf("单链表的长度为%d\n", length(&mylist));break;case 9:printf("请输⼊要删除的值:>");scanf("%d", &item);delete_val(&mylist, item);break;case 10:sort(&mylist);break;case 11:reverse(&mylist);break;case 12:clear(&mylist);break;//case 13://destroy(&mylist);//break;default:printf("选择错误,请重新选择!\n");break;}}destroy(&mylist); //程序结束,摧毁链表}希望本⽂所述对⼤家C语⾔程序设计有所帮助。

数据结构-单链表基本操作实现(含全部代码)

数据结构-单链表基本操作实现(含全部代码)

数据结构-单链表基本操作实现(含全部代码)今天是单链表的实现,主要实现函数如下:InitList(LinkList &L) 参数:单链表L 功能:初始化时间复杂度 O(1)ListLength(LinkList L) 参数:单链表L 功能:获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数:单链表L,位置i,元素e 功能:位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数:单链表L,位置i 功能:删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域,然后删除后继结点。

最坏是O(n),即从头查找p之前的结点,然后删除p所指结点LocateElem(LinkList L,ElemType e) 参数:单链表L,元素e 功能:查找第⼀个等于e的元素,返回指针时间复杂度O(n)代码:/*Project: single linkeed list (数据结构单链表)Date: 2018/09/14Author: Frank YuInitList(LinkList &L) 参数:单链表L 功能:初始化时间复杂度 O(1)ListLength(LinkList L) 参数:单链表L 功能:获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数:单链表L,位置i,元素e 功能:位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数:单链表L,位置i 功能:删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域,然后删除后继结点。

单链表(C语言实现)

单链表(C语言实现)

单链表(C语⾔实现)链表结构:SList.h//--------------------------------------------------------------------------/***功能:应⽤C语⾔实现单链表的各项操作****** 1:建⽴节点** 2:打印单链表** 3:尾插** 4:尾删** 5:头插** 6:头删** 7:清空整个链表** 8:获取链表长度** 9:查找数据** 10:在某位置后插⼊数据** 11:删除某位置的数据** 12:删除⼀个⽆头单链表的⾮尾节点** 13:在⽆头单链表的⼀个⾮头节点前插⼊⼀个节点** 14:查找中间节点** 15:查找倒数第k个节点(要求只能遍历⼀次)** 16:倒着打印单链表** 17:逆置单链表** 18:合并两个有序链表(合并后依然有序)** 19:冒泡排序****** By :Lynn-Zhang***///---------------------------------------------------------------------------#pragma oncetypedef int DataType;typedef struct SListNode{DataType data; // 数据struct SListNode* next; //指向下⼀个节点的指针}SListNode;// 如果要修改链表就必须加引⽤SListNode* _BuyNode(DataType x); //建⽴节点void PrintSlist(SListNode* pHead); //打印单链表void PushBack(SListNode* & pHead, DataType x); //尾插(这⾥⽤了引⽤,指明是list的别名,调⽤时传参,不⽤传地址)(引⽤在.c⽂件中不可⽤) //void PushBack(SListNode** pHead, DataType x); // 这⾥的第⼀个参数指向链表第⼀个节点的指针的地址(调⽤时传参,传的是地址)void PopBack(SListNode* & pHead); //尾删void PushFront(SListNode* & pHead, DataType x); //头插void PopFront(SListNode* & pHead); //头删void DestoryList(SListNode*& pHead); //清空整个链表int GetSize(SListNode* pHead); //获取链表长度SListNode* Find(SListNode* pHead, DataType x); //查找数据void Insert(SListNode* pos, DataType x); //在某位置后插⼊数据void Erase(SListNode*& pHead, SListNode* pos); //删除某位置的数据void DelNonTailNode(SListNode* pos); //删除⼀个⽆头单链表的⾮尾节点void InsertFrontNode(SListNode* pos, DataType x); // 在⽆头单链表的⼀个⾮头节点前插⼊⼀个节点SListNode* FindMidNode(SListNode* pHead); //查找中间节点SListNode* FindKNode(SListNode* pHead, int k); //查找倒数第k个节点(要求只能遍历⼀次)void PrintTailToHead(SListNode* pHead); //倒着打印单链表(递归)//SListNode* Reverse_(SListNode* pHead); //逆置单链表(需要接收返回值),原链表会被改void Reverse(SListNode*& pHead); // 将原链表逆置SListNode* Merge(SListNode* pHead1, SListNode* pHead2); //合并两个有序链表(合并后依然有序)(递归)void Sort(SListNode* pHead); //冒泡排序SList.cpp#include"SList.h"#include <stdio.h>#include<assert.h>#include <malloc.h>SListNode* _BuyNode(DataType x) //建⽴节点{SListNode* tmp = (SListNode*)malloc(sizeof(SListNode)); tmp->data = x;tmp->next = NULL;return tmp;}void PrintSlist(SListNode* pHead) // 打印单链表{SListNode* cur = pHead;while (cur){printf("%d->", cur->data);cur = cur->next;}printf("NULL\n");}//void PushBack(SListNode** ppHead, DataType x) //尾插//{// assert(ppHead);//// 1.空//// 2.不为空// if(*ppHead == NULL)// {// *ppHead = _BuyNode(x);// }// else// {//// 找尾// SListNode* tail = *ppHead;// while(tail->next != NULL)// {// tail = tail->next;// }//// tail->next = _BuyNode(x);// }//}void PushBack(SListNode* & pHead, DataType x) //尾插{// 1.空// 2.不为空if (pHead == NULL){pHead = _BuyNode(x);}else{// 找尾SListNode* tail = pHead;while (tail->next != NULL){tail = tail->next;}tail->next = _BuyNode(x);}}void PopBack(SListNode* & pHead) // 尾删{//// 1.空// 2.⼀个节点// 3.多个节点//if (pHead == NULL){return;}else if (pHead->next == NULL){free(pHead);pHead = NULL;}else{SListNode* tail = pHead;SListNode* prev = NULL;while (tail->next){prev = tail;tail = tail->next;}free(tail);prev->next = NULL;}}void PushFront(SListNode* & pHead, DataType x) //头插{// 1.空// 2.不空if (pHead == NULL){pHead = _BuyNode(x);}else{SListNode* tmp = _BuyNode(x);tmp->next = pHead;pHead = tmp;}}void PopFront(SListNode*& pHead) //头删{//// 1.空// 2.⼀个节点// 3.⼀个以上的节点//if (pHead == NULL){return;}else if (pHead->next == NULL){free(pHead);pHead = NULL;}else{SListNode* tmp = pHead;pHead = pHead->next;free(tmp);}}void DestoryList(SListNode*& pHead) //清空整个链表{SListNode* cur = pHead;while (cur){SListNode* tmp = cur;cur = cur->next;free(tmp);}pHead = NULL;}int GetSize(SListNode* pHead) //获取链表长度{assert(pHead);SListNode* cur = pHead;int count = 0;while (cur){count++;cur = cur->next;}return count;}SListNode* Find(SListNode* pHead, DataType x) //查找节点{SListNode* cur = pHead;while (cur){if (cur->data == x)return cur;}cur = cur->next;}return NULL;}void Insert(SListNode* pos, DataType x) // 某位置后插⼊节点{assert(pos);SListNode* tmp = _BuyNode(x);tmp->next = pos->next;pos->next = tmp;}void Erase(SListNode*& pHead, SListNode* pos) //删除某位置的节点{assert(pos);assert(pHead);//pos为头结点if (pHead == pos){pHead = pHead->next;free(pos);return;}////SListNode* prev = pHead;while (prev){if (prev->next == pos){prev->next = pos->next;free(pos);break;}prev = prev->next;}}void DelNonTailNode(SListNode* pos) //// 删除⼀个⽆头单链表的⾮尾节点{assert(pos);assert(pos->next);SListNode* del = pos->next;SListNode* dnext = del->next;pos->data = del->data;pos->next = dnext;free(del);}void InsertFrontNode(SListNode* pos, DataType x) // 在⽆头单链表的⼀个⾮头节点前插⼊⼀个节点{assert(pos);SListNode* tmp = _BuyNode(pos->data);tmp->next = pos->next;pos->next = tmp;pos->data = x;}void Sort(SListNode* pHead) //冒泡排序{assert(pHead);int size = GetSize(pHead);for (int i = 0; i < size - 1; i++){SListNode* left = pHead;SListNode* right = pHead->next;for (int j = 0; j < size - i - 1; j++){if (left->data>right->data){int tmp = left->data;left->data = right->data;right->data = tmp;}right = right->next;left = left->next;}}SListNode* FindMidNode(SListNode* pHead) //查找中间节点{SListNode* fast = pHead;SListNode* slow = pHead;while (fast&&fast->next){slow = slow->next;fast = fast->next->next;}return slow;}SListNode* FindKNode(SListNode* pHead, int k) //查找倒数第k个节点{SListNode* fast = pHead;SListNode* slow = pHead;while (fast && k--){fast = fast->next;}if (k > 0){return NULL;}while (fast){slow = slow->next;fast = fast->next;}return slow;}void PrintTailToHead(SListNode* pHead) //倒着打印单链表(递归){if (pHead){PrintTailToHead(pHead->next);printf("%d ", pHead->data);}}//SListNode* Reverse_(SListNode* pHead) //逆置单链表(需要接收返回值)原链表会被改//{// SListNode* cur = pHead;// SListNode* newHead = NULL;// while (cur)// {// SListNode* tmp = cur;// cur = cur->next;// tmp->next = newHead;// newHead = tmp;// }// return newHead;//}void Reverse(SListNode*& pHead) //逆置单链表(⽆需返回值){SListNode* cur = pHead;SListNode* newHead = NULL;while (cur){SListNode* tmp = cur;cur = cur->next;tmp->next = newHead;newHead = tmp;}pHead = newHead;//return newHead;}SListNode* Merge(SListNode* pHead1, SListNode* pHead2) //合并两个有序链表(合并后依然有序)递归{if (pHead1 == NULL)return pHead2;else if (pHead2 == NULL)return pHead1;SListNode* pMergedHead = NULL;if (pHead1->data < pHead2->data){pMergedHead = pHead1;pMergedHead->next = Merge(pHead1->next, pHead2); }else{pMergedHead = pHead2;pMergedHead->next = Merge(pHead1, pHead2->next); }return pMergedHead;}Test.cpp#include "SList.h"#include<stdlib.h>//测试⽤例void Test1(){// 尾插打印尾删头插头删清空链表SListNode* list = NULL;PushBack(list, 1);PushBack(list, 2);PushBack(list, 3);PushBack(list, 4);PrintSlist(list);PopBack(list);PrintSlist(list);PushFront(list,0);PrintSlist(list);PopFront(list);PrintSlist(list);DestoryList(list);PrintSlist(list);}void Test2(){// 查找节点在某位置插⼊节点删除某位置节点SListNode* list = NULL;PushBack(list, 1);PushBack(list, 2);PushBack(list, 3);PushBack(list, 4);PrintSlist(list);SListNode* pos = Find(list, 2);Insert(pos, 0);PrintSlist(list);Erase(list, Find(list, 0));PrintSlist(list);}void Test3(){SListNode* list = NULL;PushBack(list, 1);PushBack(list, 2);PushBack(list, 3);PushBack(list, 4);PushBack(list, 5);PushBack(list, 6);PrintSlist(list);// 删除⼀个⽆头单链表的⾮尾节点/*SListNode* pos = Find(list, 2);DelNonTailNode(pos);PrintSlist(list);*/// 在⽆头单链表的⼀个⾮头节点前插⼊⼀个节点/*SListNode* pos = Find(list, 2);InsertFrontNode(pos, 0);PrintSlist(list);*///查找中间节点//PrintSlist(FindMidNode(list));//查找倒数第k个节点//SListNode* ret = FindKNode(list, 2);//PrintSlist(ret);//倒着打印单链表(递归)//PrintTailToHead(list);//逆置单链表//SListNode* ret = Reverse(list);//PrintSlist(ret);//PrintSlist(Reverse_(list));//PrintSlist(list);}void Test4(){ //合并两个有序链表(合并后依然有序) SListNode* list = NULL;PushBack(list, 4);PushBack(list, 2);PushBack(list, 1);PushBack(list, 4);PrintSlist(list);Sort(list);PrintSlist(list);/*SListNode* list1 = NULL;PushBack(list1, 2);PushBack(list1, 3);PushBack(list1, 3);PushBack(list1, 0);PrintSlist(list);Sort(list1);PrintSlist(list1);SListNode* ret = Merge(list, list1);PrintSlist(ret);PrintSlist(list);PrintSlist(list1);*/}int main(){//Test1();//Test2();//Test3();Test4();system("pause");return0;}。

数据结构C语言版 线性表源代码

数据结构C语言版 线性表源代码

#include <stdio.h>#include <conio.h>#include <malloc.h>#include <stdlib.h>#define LIST_INIT_SIZE 100 #define LISTINCREMENT 10#define OK 1#define ERROR -1#define OVERFLOW -1#define ENDFLAG 0typedef int Status;typedef int ElemType;#define OUTFORMAT "%d "#define INFORMAT "%d"typedef struct{ElemType *elem;int length;int listsize;}SqList;Status InitList(SqList *L){L->elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L->elem) ////// 如果没有分配成功exit(OVERFLOW); /////退出,显示()内内容L->length=0;L->listsize=LIST_INIT_SIZE;return OK;}Status Inputdata(SqList *L){ ///////SqList *L定义首节点的地址ElemType temp,*newbase;printf("\nInput the data of the sequencial list:\nNote:0 is the ending flag:\n");scanf(INFORMAT,&temp);while(temp!=ENDFLAG){if(L->length>=L->listsize){newbase=(ElemType *)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType));////扩大空间,把旧的地址拷贝到新空间if(!newbase)exit(OVERFLOW);L->elem=newbase;L->listsize+=LISTINCREMENT;}L->elem[L->length++]=temp;scanf(INFORMAT,&temp);}return OK;}Status ListInsert(SqList *L,int i,ElemType e){ElemType *p,*q,*newbase;if(i<0||i>L->length)return ERROR;if(L->length>=L->listsize){Newbase =( elemType*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType));if(!newbase) exit(OVERFLOW);L->elem=newbase;L->listsize+=LISTINCREMENT;}q=&(L->elem[i-1]);for(p=&(L->elem[L->length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L->length;return OK;}void MyDisplay(SqList L){int i;for(i=0;i<L.length;i++)printf(OUTFORMAT,L.elem[i]);printf("\n");}void main(void){SqList L;ElemType temp;int i;if(!InitList(&L)) { ////如果初始化失败printf("To initialize the sequencial list fail\n");getch(); //////如果失败,按任意键退出exit(0);}if(!Inputdata(&L)){printf("To input the data of the sequencial list fail\n");getch();exit(0);}MyDisplay(L);printf("Input the data that you want to insert:");scanf(INFORMAT,&temp);printf("Input the insert_location:");scanf("%d",&i);if(!ListInsert(&L,i,temp)){printf("To insert fail\n");getch();exit(0);}MyDisplay(L);getch();}。

C语言之单向链表详解及实例代码

C语言之单向链表详解及实例代码

C语⾔之单向链表详解及实例代码1,单向链简洁。

单向链表(单链表)是链表的⼀种,其特点是链表的链接⽅向是单向的,对链表的访问要通过顺序读取从头部开始;链表是使⽤指针进⾏构造的列表;⼜称为结点列表,因为链表是由⼀个个结点组装起来的;其中每个结点都有指针成员变量指列表中的下⼀个结点;列表是由结点构成,由head指针指向第⼀个成为表头的结点⽽终⽌于最后⼀个指向nuLL的指针;2,例⼦要求:根据⽰例代码中的例⼦,完成单向链表(single linked list)中的以字符串为数据的链表的插⼊、删除以及查找,并⽀持单向链表的反转;3,代码实现。

#include <stdio.h>#include <math.h>#include <cstring>#include <memory.h>#include <malloc.h>//节点的定义typedef struct Node {void *data; //数据域 //链域struct Node *next;} NodeStruct, *pNode;pNode head = NULL;typedef char (*pCompareFunc)(void *a, void *b);typedef void* (*pChar)(void *p);// 字符串判断int str_compare(void *a, void *b) {char *pa = (char*)a;char *pb = (char*)b;return strcmp(pa , pb);}// 分配⼀个节点pNode allocate_node(void *data, pChar char_func) {pNode node = allocate();node->data = char_func(data);return node;}// 创建节点pNode allocate() {void *p = malloc(sizeof(NodeStruct));pNode node = (pNode)p;node->next = NULL;node->data = NULL;return node;}// 添加⼀个节点void insertNode(pNode node){if (head == null){head=node;}else {node->next = head;head = node;}}void* char_char(void *p) {char* pa = (char*)malloc(sizeof(char));memcpy(pa, p, sizeof(char));return pa;}// 初始化节点pNode allocate_node(void *data, pChar char_func) { pNode node = allocate();node->data = char_func(data);return node;}// 释放资源void free_list(pNode node) {pNode next = node;while (next != NULL) {if (next->data != NULL)free(next->data);pNode temp = next;next = next->next;free(temp);}}// 1.1 添加⼀个节点void insert(pNode node) {if (head == NULL)head = node;else {node->next = head;head = node;}}//1.2查找int str_search(void* data,pCompareFunc compare){ pNode next = head;pNode prev = NULL;while (next != NULL ) {if (compare(data, next->data) == 0) {// 如果查找到了,就退出返回1return 1;break;}prev = next;next = next->next;}// 如果⼀直查找不到,就返回0return 0;}// 1.3删除节点void remove(void* data,pCompareFunc compare) { pNode next = head;pNode prev = NULL;while (next != NULL) {if (compare(data, next->data) == 0) {if (prev == NULL) {head = next->next;next->next = NULL;free_list(next);} else {prev->next = next->next;next->next = NULL;free_list(next);}break;}prev = next;next = next->next;}}//1.4反转void invert_order(){node *This,*prev;p=head.next;This=NULL;while(p) {prev=This;This=p;p=p->next;This->next=prev;}head.next=This;}void main(){// 1单向链表char a1[] = 'aaa1';char a2[] = 'aaa2';char a3[] = 'aaa3';// 1.1添加insertNode(allocate_node(a1, init_char));insertNode(allocate_node(a2, init_char));insertNode(allocate_node(a3, init_char));// 1.2查找int flag = 0;flag = str_search(&a2,str_compare);// 1.3删除remove(&a2,str_compare);// 1.4反转invert_order();}以上就是对 C语⾔单向联表的资料整理,后续继续补充相关资料,谢谢⼤家对本站的⽀持!。

数据结构c语言版创建单链表的代码

数据结构c语言版创建单链表的代码

数据结构c语言版创建单链表的代码单链表作为常用的线性结构之一,常常用于解决以链式方式存储数据的问题。

创建单链表需要掌握一些基础的数据结构知识以及对C语言的熟练运用。

接下来,本文将分步骤地阐述数据结构C语言版创建单链表的代码。

第一步,定义单链表结构体并定义节点类型。

在C语言中,我们可以通过结构体的方式定义单链表,其中结构体中包含两个成员变量,分别为存储数据的data和指向下一个节点的指针next。

对于节点类型,我们可以使用typedef对节点类型进行定义,例如:```struct ListNode {int data;struct ListNode *next;};typedef struct ListNode ListNode;```在以上代码中,我们首先定义了一个结构体ListNode作为单链表的元素类型,其中包含存储数据的data和指向下一个元素的指针next。

接着我们使用typedef将结构体ListNode定义为仿函数ListNode,从而使其更加方便使用。

第二步,初始化单链表。

在创建单链表之前,我们需要先将单链表的头指针初始化为NULL,表示当前链表为空。

具体代码如下:```ListNode *createLinkedList() {ListNode *head = NULL;return head;}```以上代码中,函数createLinkedList用于创建并初始化单链表,其中head表示单链表头指针,我们将其初始化为NULL。

第三步,向单链表中添加元素。

在单链表中添加元素需要借助于指针的指向关系。

具体来说,我们需要先创建新的节点,将其数据添加到节点中,然后将新节点的next指针指向之前的头节点,最后将头指针指向新节点。

具体过程如下:```ListNode *addListNode(ListNode **head, int val) {ListNode *newNode = (ListNode *)malloc(sizeof(ListNode)); newNode->data = val;newNode->next = *head;*head = newNode;return *head;}```在以上代码中,函数addListNode接收一个指向头指针的指针head,以及需要添加的元素值val。

数据结构C语言版 线性表的单链表存储结构表示和实现

数据结构C语言版 线性表的单链表存储结构表示和实现

#include 〈stdio.h>#include <malloc。

h>#include 〈stdlib.h>/*数据结构C语言版线性表的单链表存储结构表示和实现P28—31编译环境:Dev-C++ 4。

9。

9。

2日期:2011年2月10日*/typedef int ElemType;// 线性表的单链表存储结构typedef struct LNode{ElemType data; //数据域struct LNode *next;//指针域}LNode, *LinkList;// typedef struct LNode *LinkList;// 另一种定义LinkList的方法// 构造一个空的线性表Lint InitList(LinkList *L){/*产生头结点L,并使L指向此头结点,头节点的数据域为空,不放数据的。

void *malloc(size_t)这里对返回值进行强制类型转换了,返回值是指向空类型的指针类型.*/(*L)= (LinkList)malloc(sizeof(struct LNode) );if( !(*L))exit(0);// 存储分配失败(*L)-〉next = NULL;// 指针域为空return 1;}// 销毁线性表L,将包括头结点在内的所有元素释放其存储空间。

int DestroyList(LinkList *L){LinkList q;// 由于单链表的每一个元素是单独分配的,所以要一个一个的进行释放while(*L ){q = (*L)—〉next;free(*L );//释放*L = q;}return 1;}/*将L重置为空表,即将链表中除头结点外的所有元素释放其存储空间,但是将头结点指针域置空,这和销毁有区别哦。

不改变L,所以不需要用指针。

*/int ClearList( LinkList L ){LinkList p,q;p = L—〉next;// p指向第一个结点while( p ) // 没到表尾则继续循环{q = p—>next;free( p );//释放空间p = q;}L—>next = NULL; // 头结点指针域为空,链表成了一个空表return 1;}// 若L为空表(根据头结点L—〉next来判断,为空则是空表),则返回1,// 否则返回0.int ListEmpty(LinkList L){if(L—>next ) // 非空return 0;elsereturn 1;}// 返回L中数据元素个数。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

/*单链表的各种操作*/
#include <stdio.h>
#include <malloc.h>
#define null 0
typedef int ElemType; /* 字符型数据*/
struct LNode
{
ElemType data;
struct LNode *next;
};
void setnull(struct LNode **p);
int length (struct LNode **p);
ElemType get(struct LNode **p,int i);
void insert(struct LNode **p,ElemType x,int i); void dele(struct LNode **p,int i);
void display(struct LNode **p);
int locate(struct LNode **p,ElemType x);
void main()
{
struct LNode *head,*q; /*定义静态变量*/ int select,x1,x2,x3,x4;
int i,n;
int m,g;
char e,y;
setnull(&head); /*建设链表并设置为空表*/ printf("请输入数据长度: ");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
printf("将数据插入到单链表中: ");
scanf("%d",&y);
insert(&head,y,i);
} /*插入数据到链表*/
display(&head); /*显示链表所有数据*/ printf("select 1 求长度 length()\n");
printf("select 2 取结点 get()\n");
printf("select 3 求值查找 locate()\n");
printf("select 4 删除结点 delete()\n");
printf("select 0 退出\n");
printf("input your select: ");
scanf("%d",&select);
while(select!=0)
{switch(select)
{
case 1:
{
x1=length(&head);
printf("输出单链表的长度%d ",x1);
display(&head);
}break;
case 2:
{
printf("请输入要取得结点: ");
scanf("%d",&m);
x2=get(&head,m);
printf("%d",x2);
display(&head);
}break;
case 3:
{
printf("请输入要查找的数据: ");
scanf("%d",&e);
x3=locate(&head,e);
printf("%d",x3);
display(&head);
}break;
case 4:
{
printf("请输入要删除的结点: ");
scanf("%d",&g);
dele(&head,g);
display(&head);
}break;
}
printf("select 1 求长度 length()\n");
printf("select 2 取结点 get()\n");
printf("select 3 求值查找 locate()\n");
printf("select 4 删除结点 delete()\n");
printf("select 0 退出\n");
printf("input your select: ");
scanf("%d",&select);
}
}
void setnull(struct LNode **p)
{
*p=null;
}
int length (struct LNode **p)
{
int n=0;
struct LNode *q=*p;
while (q!=null)
{
n++;
q=q->next;
}
return(n);
}
ElemType get(struct LNode **p,int i) {
int j=1;
struct LNode *q=*p;
while (j<i&&q!=null)
{
q=q->next;
j++;
}
if(q!=null)
return(q->data);
else
{printf("位置参数不正确!\n");
return 0;}
}
int locate(struct LNode **p,ElemType x) {
int n=0;
struct LNode *q=*p;
while (q!=null&&q->data!=x)
{
q=q->next;
n++;
}
if(q==null)
return(-1);
else
return(n+1);
}
void insert(struct LNode **p,ElemType x,int i) {
int j=1;
struct LNode *s,*q;
s=(struct LNode *)malloc(sizeof(struct LNode)); s->data=x;
q=*p;
if(i==1)
{
s->next=q;
*p=s;
}
else
{
while(j<i-1&&q->next!=null)
{
q=q->next;
j++;
}
if(j==i-1)
{
s->next=q->next;
q->next=s;
}
else
printf("位置参数不正确!\n"); }
}
void dele(struct LNode **p,int i)
{
int j=1;
struct LNode *q=*p,*t;
if(i==1)
{
t=q;
*p=q->next;
}
{
while(j<i-1&&q->next!=null)
{
q=q->next;
j++;
}
if(q->next!=null&&j==i-1)
{
t=q->next;
q->next=t->next;
}
else
printf("位置参数不正确!\n"); }
if(t!=null)
free(t);
}
void display(struct LNode **p)
{
struct LNode *q;
printf("单链表显示: ");
if(q==null)
printf("链表为空!");
else if (q->next==null)
printf("%d\n",q->data);
else
{
while(q->next!=null)
{
printf("%d->",q->data);
q=q->next;
}
printf("%d",q->data);
}
printf("\n");
}。

相关文档
最新文档