数据结构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语⾔单链表实现⽅法。

分享给⼤家供⼤家参考，具体如下：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语⾔实现）链表结构：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语言版线性表源代码

#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语⾔之单向链表详解及实例代码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语言中，我们可以通过结构体的方式定义单链表，其中结构体中包含两个成员变量，分别为存储数据的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语言版线性表的单链表存储结构表示和实现

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

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

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.有一个单链表的第一个节点指针为head，编写一个函数将该单链表逆置，即最后一个节点变成第一个节点，原来倒数第二个节点变成第二个节点，如此等等，在逆置中不能建立新的单链表。

#include#include#define bs -1typedef int db;typedef struct xiangjia{db data;struct xiangjia *next;}lb;lb *tou(){lb *L;L=(lb *)malloc(sizeof(lb));L->next=NULL;return L;}void get(lb *l){lb *L,*h;db x;L=l;printf("请输入你的数据,并在末尾输入-1以示结束\n\n");scanf("%d",&x);while(x!=bs){h=(lb *)malloc(sizeof(lb)); h->data=x;h->next=L->next;L->next=h;scanf("%d",&x);}}void put(lb *l){lb *L;L=l;printf("链表中的数据有:\n"); while(L->next!=NULL) {printf("%d",L->next->data); L=L->next;if(L->next!=NULL){printf("->");}}printf("\n");}main(){lb *a;a=tou();get(a);printf("逆序后的整数表:"); put(a);}2.编写程序，将若干整数从键盘输入，以单链表形式存储起来，然后计算单链表中结点的个数（其中指针P指向该链表的第一个结点）。

数据结构单链表代码

s=p->next;
}
printf("删除重复元素后的表是：");
print(L);
DestroyList_Link(L);
}
/*void main()
{
LinkList La,Lb,Lc;
//int e;
InitList_Link(La);
InitList_Link(Lb);
CreateList_Link(La,5);
CreateList_Link(Lb,8);
MergeList_Link(La,Lb,Lc);
//DestroyList_Link(L);
//DestroyList_Link(L,2,e);
//printf("%d",e);
print(La);
print(Lb);
print(Lc);
printf("\n");
}
int ListLength_Link(LinkList L)
{
int len=0;
LinkList p=L;
while(p->next)
{
len++;
p=p->next;
}
return len;
}
void MergeList_Link(LinkList &La,LinkList &Lb,LinkList &Lc)
{
//LinkList L;
L=(LinkList)malloc(sizeof(LNode)的是一个带头结点的空的单链表
for(int i=n;i>0;i--)
{
LinkList p;//生成新结点

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

/＊单链表的各种操作*/#inｃｌuｄe <sｔdio.ｈ>#incｌude <malｌoc.h>＃ｄefine null 0typｅｄｅf int ＥlemType; /* 字符型数据*/ｓｔｒｕct LＮｏde{ElemTｙpe data;ｓｔruｃt LＮode*next;｝;ﻩvｏｉｄsetｎulｌ（strｕct LNode **ｐ）;int lｅngth (strｕｃt LＮｏde ＊*ｐ);ElemTｙpe get(ｓtruct LNode *＊p,ｉnt i);voiｄinsert(strｕct LNoｄe ＊*p，ElemTyｐe ｘ，iｎt i）；void delｅ(strｕct LNode *＊p,ｉｎt ｉ);vｏid diｓｐlａy(stｒucｔＬNode **p）;int loｃatｅ（ｓtruct ＬNode ＊＊p,ElemTｙpｅx）;ｖoid main(){ﻩstruct LNｏｄe ＊head,＊q; /*定义静态变量＊/ int seleｃt,x1,x2，x3,x4;ﻩint i,n;int ｍ,ｇ;cｈar e,y;setｎuｌl(＆heａｄ）;／*建设链表并设置为空表*／printｆ("请输入数据长度:");ｓcaｎf（"％d",&n);ﻩfor(i＝1；i<=ｎ;i＋+){ｐrintf("将数据插入到单链表中：");ﻩﻩｓcanf("%ｄ＂,&ｙ);ｉｎseｒt(&head,y,i）;｝/＊插入数据到链表*/ﻩｄisplay(＆ｈeaｄ）; /*显示链表所有数据＊/ﻩｐrｉnｔf("selｅct 1 求长度lenｇth（)\n"）;ﻩﻩｐrintf(＂sｅlect ２取结点geｔ()\ｎ");ﻩﻩpｒｉｎtf(＂selｅct 3 求值查找locate()\n")；ﻩprinｔf（＂seleｃt 4 删除结点delete(）＼n＂)；ﻩﻩｐrintf("selｅｃt 0 退出\n");ﻩﻩprintf("iｎput yoｕr ｓelect: ");scanf(＂%d"，&selｅｃｔ);while(seｌeｃt!=0)｛switcｈ（sｅlect)ﻩ{ﻩﻩｃase 1:ﻩ{ﻩﻩﻩx１=lenｇtｈ(&heａd);ﻩﻩpｒintf(＂输出单链表的长度％d",ｘ1)；ﻩﻩdisplay（&hｅaｄ);ﻩ}brｅak;case ２：ﻩﻩ{ﻩprｉnｔf("请输入要取得结点: "）；ﻩﻩsｃａnf("%d",&ｍ);ﻩｘ2=ｇet(&head,m);printｆ("%d＂,x2);ﻩﻩdｉsplaｙ(＆hｅaｄ);}ｂreak;ﻩﻩcaｓｅ3:ﻩﻩﻩ｛ﻩprintf("请输入要查找的数据: "）;ﻩｓcaｎf("％ｄ",&ｅ);ﻩx3=lｏcatｅ(&head,ｅ);ﻩﻩpriｎｔf(＂%ｄ＂,ｘ３);ﻩｄiｓplay(＆head)；ﻩ}ｂreaｋ;ﻩﻩﻩｃａse 4:ﻩﻩ｛ﻩﻩprintf(＂请输入要删除的结点：");ﻩscanf("%d＂,&g);deｌe(&head,g);ﻩﻩﻩdisplay(＆heａd）；ﻩ｝brｅak;ﻩ｝printｆ(＂selｅct １求长度lｅngｔh()＼ｎ"）;prｉｎtｆ("selｅｃt２取结点ｇｅｔ（）\n"）; ﻩﻩｐrinｔｆ("selｅct ３求值查找locatｅ()\n＂);priｎｔf(＂ｓeｌect 4删除结点delｅtｅ()＼ｎ");priｎtｆ("select 0退出\ｎ＂）;ｐrｉnｔf("ｉnpｕt ｙouｒｓｅｌeｃt: "）;ﻩｓcanf("％d",&selｅct）;ﻩ}ﻩ｝void seｔｎuｌl(strｕct LNode **p)｛ﻩ*p=null;}iｎｔlengtｈ(sｔruct LNｏde **p){ﻩｉnt n=0;ﻩsｔｒuct LNoｄe*q＝＊p;ﻩwｈiｌe (ｑ!＝null){ﻩｎ＋+;ｑ＝q->neｘt；ﻩ｝returｎ（n)；}ElemＴｙpｅｇｅt(sｔruct LNoｄe **p,iｎt i) {ｉnｔj=1;ﻩstrｕｃt LNode *q=*p;while (j<i&&ｑ!=nulｌ)ﻩ{ﻩq=ｑ->ｎext;j+＋;ﻩ}ﻩif(q!=null）ﻩﻩreｔurｎ(q->data);eｌｓeﻩ{prｉnｔf（＂位置参数不正确!\ｎ")；ﻩrｅｔuｒn0；}ﻩ}int lｏcatｅ（struｃｔLＮoｄe ＊*ｐ,ＥlemType x) {ﻩint ｎ=0;ﻩsｔｒｕct LNodｅ＊q=＊p;ﻩwhile (q!=nuｌl&＆q->ｄatａ！=x){q=ｑ->nexｔ;ﻩﻩｎ＋＋;ﻩ}ｉf（q==ｎull)ﻩreturｎ（-1);ﻩelｓerｅｔurn(n+1）；}voｉｄinsert（strucｔLNｏde**p,EleｍＴype x,int i）{iｎｔj=１;ﻩｓｔruct LNode *s,*q;ｓ=（sｔrucｔLNodｅ*)malloｃ(sizeof（strｕcｔLN ｏdｅ)）;ﻩｓ->ｄata=x;q=*ｐ;ﻩif(i==1)ﻩ｛s->nｅxｔ=ｑ;ﻩ*p＝s;ﻩ}ﻩｅlse{ﻩwhile（j<ｉ-1&＆ｑ->nｅxｔ!=nｕｌｌ){ﻩﻩq=q->ｎext；ﻩﻩj＋＋;ﻩﻩ}ﻩﻩif(j==i-1)ﻩ{ﻩs->next=q->nｅxｔ;ﻩq－>ｎｅxt=s;}ﻩelseprｉnｔf（"位置参数不正确!\ｎ")；ﻩ}ﻩ}voiｄdele(ｓｔｒｕｃt ＬNｏｄe ＊*p,int ｉ) {ﻩint ｊ=１;ﻩstｒuct LＮｏdｅ*q＝*p,*t;ﻩif(i==１){ﻩﻩt=q;ﻩﻩ*p=q->next;ﻩ}ﻩelseﻩ｛ﻩﻩwｈile（j＜i-1&&q-＞ｎexｔ!=nｕll)ﻩﻩ{ﻩﻩﻩｑ＝q->nexｔ;ﻩｊ+＋;ﻩﻩ}ﻩif(ｑ->neｘt!＝ｎuｌl&&j==i-1)ﻩ｛ﻩﻩﻩｔ=q->neｘt;ﻩﻩｑ->next=t->neｘｔ;}elseﻩﻩｐrinｔf（＂位置参数不正确!\n＂)；}ｉｆ(ｔ!=ｎull)ﻩfrｅe(ｔ);}void disｐlａｙ（struｃt LNode **p){strucｔLＮoｄｅ*q;ﻩq=*p；prｉｎtｆ（"单链表显示: ");ﻩif(ｑ＝＝nｕll）ｐriｎtf("链表为空！");eｌse if（q->ｎext==null)ﻩprintｆ("%d\ｎ"，q->dａtａ）;ｅlse{ﻩｗhile（q->nｅxｔ!＝nuｌl）ﻩ{ﻩﻩﻩprｉnｔｆ("%d－＞＂,q->daｔa); ﻩﻩﻩq=q-＞next;ﻩﻩ}ﻩprintf(＂%d",ｑ->dａta）;}ﻩprintf(＂\n＂）;}。

c语言单链表程序代码

c语言单链表程序代码单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

单链表的优点在于插入和删除操作的效率高，但是访问任意节点的效率较低。

下面是一个简单的单链表程序代码：```c#include <stdio.h>#include <stdlib.h>struct Node {int data;struct Node* next;};void insert(struct Node** head, int data) {struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = data;newNode->next = *head;*head = newNode;}void printList(struct Node* head) {while (head != NULL) {printf("%d ", head->data);head = head->next;}printf("\n");}int main() {struct Node* head = NULL;insert(&head, 1);insert(&head, 2);insert(&head, 3);printList(head);return 0;}```这个程序定义了一个结构体`Node`，包含一个整型数据`data`和一个指向下一个节点的指针`next`。

`insert`函数用于在链表头部插入一个新节点，`printList`函数用于打印整个链表。

在`main`函数中，我们创建了一个空链表`head`，然后插入了三个节点，最后打印整个链表。

这个程序虽然简单，但是涉及到了单链表的基本操作。

c语言单链表代码

c语言单链表代码单链表是一种数据结构，它由一系列节点构成，每个节点都包含一个数据域和一个指向下一个节点的指针域。

在C语言中，实现单链表需要使用指针和动态内存分配。

下面分步骤阐述一下如何实现单链表的代码。

1.定义单链表节点结构体单链表的节点包含两个域，一个是数据域用于存储数据，另一个是指针域用于指向下一个节点。

定义单链表节点结构体如下：```cstruct Node {int data;struct Node* next;};```其中，data表示节点存储的数据，next表示指向下一个节点的指针。

2.创建单链表创建单链表需要考虑两个问题，一个是如何在内存中分配节点的空间，另一个是如何将各个节点连接起来。

在C语言中使用malloc函数动态分配内存。

具体步骤如下：```cstruct Node *create_list(int n) {int i;struct Node *head = NULL;//定义头节点指针，初始化为空struct Node *p, *tail;//定义节点指针p和tail，用于遍历和尾插//读入n个节点的数据for (i = 0; i < n; i++) {p = (struct Node*)malloc(sizeof(struct Node));//动态分配内存scanf("%d", &p->data);p->next = NULL;//新节点的指针要初始化为空if (head == NULL)head = p;elsetail->next = p;//将上一个节点的next指向当前节点 tail = p;//更新尾节点指针}return head;//返回头节点指针}```其中，head指向链表的第一个节点，p表示当前节点，tail表示尾节点，next指向下一个节点。

3.遍历单链表遍历单链表需要用指针从头节点开始往下遍历。

数据结构课程设计-职工信息管理系统-单链表实现程序源代码

｛
printf（”请你输入要查找的工号："）；
scanf（”％s"，findmess);
p=Locate(l,findmess,”num”）；
if(p）
｛
printf（”\t\t\t\t查找结果\n”)；
printstart（）; //打印横线
printc（)； //打印各学科标题
printe(p）； //打印p结点各个数据成员的值
printf（”\t＊ [7] 排序 [8］保存职工信息＊\n");
printf（”\t＊［9] 显示数据［0] 退出系统＊\n”）；
printf(”\t＊＊\n”);
printf（"\t**＊**＊*＊＊＊*＊＊＊＊＊*＊*＊＊＊＊*＊＊＊*＊**＊＊＊*＊*＊*＊＊*＊＊*＊*＊*＊＊＊＊＊＊*＊*＊＊＊***＊\n”）;
｝
void Wrong（）
｛
printf("\n=====>提示：输入错误！\n"）；
｝
void Nofind(）
｛
printf（"\n=====〉提示：没有找到该职工！\n”)；
｝
void printc（) /＊本函数用于输出中文＊/
{
printf（" 工号\t 姓名性别部门职称工资总工资平均工资\n");
Node ＊p，＊r; /*实现删除操作的临时的结构体指针变量＊/
char findmess[20］；
if(！l—〉next) //当list无后继结点时,提示和结束返回del（）
｛
printf（"\n=====>提示：没有记录可以删除！\n"）;

数据结构(C语言)用单链表存储一元多项式,并实现两个多项式的相加运算

#include<stdio.h>#include<stdlib.h>#include<malloc.h>typedef int ElemType;/*单项链表的声明*/typedef struct PolynNode{int coef; // 系数int expn; // 指数struct PolynNode *next;}PolynNode,*PolynList;/*正位序(插在表尾)输入n个元素的值，建立带表头结构的单链线性表*/ /*指数系数一对一对输入*/void CreatePolyn(PolynList &L,int n){int i;PolynList p,q;L=(PolynList)malloc(sizeof(PolynNode)); // 生成头结点L->next=NULL;q=L;printf("成对输入%d个数据\n",n);for(i=1;i<=n;i++){p=(PolynList)malloc(sizeof(PolynNode));scanf("%d%d",&p->coef,&p->expn); //指数和系数成对输入q->next=p;q=q->next;}p->next=NULL;}// 初始条件：单链表L已存在// 操作结果: 依次对L的每个数据元素调用函数vi()。

一旦vi()失败,则操作失败void PolynTraverse(PolynList L,void(*vi)(ElemType, ElemType)){PolynList p=L->next;while(p){vi(p->coef, p->expn);if(p->next){printf(" + "); //“+”号的输出，最后一项后面没有“+”}p=p->next;}printf("\n");}/*ListTraverse()调用的函数(类型要一致)*/void visit(ElemType c, ElemType e){if(c != 0){printf("%dX^%d",c,e); //格式化输出多项式每一项 }}/* 多项式相加，原理：归并 *//* 参数：两个已经存在的多项式 *//* 返回值：归并后新的多项式的头结点 */PolynList MergeList(PolynList La, PolynList Lb){PolynList pa, pb, pc, Lc;pa = La->next;pb = Lb->next;Lc = pc = La; // 用La的头结点作为Lc的头结点while(pa&&pb){if(pa->expn < pb->expn){pc->next = pa; //如果指数不相等，pc指针连上指数小的结点，pc = pa;pa = pa->next; //指向该结点的指针后移}else if(pa ->expn > pb->expn ){pc->next = pb; //pc指针连上指数小的结点，pc = pb;pb = pb->next; //指向该结点的指针后移}else//(pa ->expn = pb->expn ){pa->coef = pa->coef + pb->coef; //指数相等时，系数相加pc->next = pa;pc = pa;pa = pa->next; //两指针都往后移pb = pb->next;}}pc->next = pa ? pa:pb; // 插入剩余段return Lc;}void main(){PolynList ha,hb,hc;printf("非递减输入多项式ha， ");CreatePolyn(ha,5); // 正位序输入n个元素的值 printf("非递减输入多项式hb， ");CreatePolyn(hb,5); // 正位序输入n个元素的值 printf("多项式ha :");PolynTraverse(ha, visit);printf("\n");printf("多项式hb :");PolynTraverse(hb, visit);printf("\n");hc = MergeList(ha,hb);PolynTraverse(hc, visit);}。

C#源码_数据结构(单链表+反向链表)

单链表class Node{ int a;public Node(int a){ this.a=a; }public int A{get{return a;} set{a=value;} }public Node next;}class LinkedList{ Node header;public void Generate(int x){ if(header==null)header=new Node(x);else{ Node n = new Node(x);if(n.A < header.A){ n.next = header;header=n;return;}Node tmp=header;Node t=header;while(tmp.A < n.A){ t=tmp; //为了下一次循环tmp=tmp.next;if(tmp==null)break;}t.next=n;n.next=tmp;}}public void Out(){ Node tmp=header;while(tmp!=null){ Console.WriteLine(tmp.A);tmp = tmp.next;} } }class Test{ static void Main(){ LinkedList ll = new LinkedList();ll.Generate(6);ll.Generate(36);ll.Generate(26);ll.Generate(16);ll.Out();} } }反向链表class Link //this class reverse the LinkedList { public int a;public Link next;}class createLink //the class create the LinkedList{Link header=null;Link p = null;Link temp = null;Link l=null; //Link k=null;Link g=null;public void create(){ string str;int i;Console.WriteLine("Please enter number:");str=Console.ReadLine();while(str!="y"){ i=Convert.ToInt32(str);temp=new Link();temp.a=i;temp.next=null;if(g==null)g=temp;if(header==null)header=temp;if(p==null)p=temp;else{ p.next=temp;p=p.next;}Console.WriteLine("please enter number:");str=Console.ReadLine();}}public void display(){ while(header!=null){ Console.WriteLine(header.a);header=header.next;}}public void reversed() // the mothod reversed the LinkedList { Link k=null;Link tmp=null;Link com =null;if(tmp==null)tmp=header.next;while(tmp!=null){ // if(com==null)// com=header;l=tmp;if(k==null){ header.next=null;k=header;}com=header;header=l;tmp=l.next;l.next=com;}}public void show(){ while(l!=null){ Console.WriteLine(l.a);l=l.next;} } }class Tester{ static void Main(){ createLink cl=new createLink();cl.create();//cl.display();cl.reversed();cl.show();} } }。

单链表（c语言实现）贼详细

单链表（c语⾔实现）贼详细直接上代码吧#include<stdio.h>#include<malloc.h>/*单链表特点：它是⼀种动态的储存结构，链表中每个节点占⽤的储存空间不是预先分配的，⽽是运⾏时系统根据需求⽣成的*/typedef struct lnode{int data;struct lnode *next;}lnode,*linklist;//结点定义/*关于头指针的⼀点说明：linklist L;外⾯⽤头指针来标识⼀个单链表，如单链表L,单链表H等，是指链表的第⼀个节点的地址被记录在指针变量L，H中，头指针为NULL时，表⽰⼀个空的单链表，需要进⼀步指出的是：上⾯定义的lnode是节点的类型，linklist是指向lnode节点的指针的类型，为了增强程序的可读性，通常将标识⼀个链表的头指针说明为linklist类型的变量*/linklist creat_linklist_insert_head_nohead(){linklist l=NULL;//定义头指针变量llnode *s;//新建⼀个节点int flag=-1;//输⼊停⽌标志位printf("输⼊整型数据，数据以空格隔开，输⼊数据为-1的时候表⽰输⼊截⽌\n");while(1){int x;scanf("%d",&x);if(x==flag)break;s=(lnode*)malloc(sizeof(lnode));//对s节点申请储存空间s->data=x;//赋值s->next=l;//s节点的next指向头指针l=s;//头指针指向新建⽴的s节点，因为这是在单链表的头部插⼊数据}return l;}//创建⼀个单链表，通过在头部插⼊数据，不含空的头节点//-------------------------------------------------------------------------------------------------------------///*在单链表的表头插⼊，只要x！=flag，就是⼀直申请s结点，从⽽可以⼀直在表头插⼊，其中l=s是最重要的，因为这是将s插⼊到l的表头，因为是在头部插⼊，所以只要⼀个头指针就可以，若是在单链表的尾部插⼊，那么就需要尾部指针关于此函数使⽤的⼀点说明：我们输⼊数据 1 2 3 4 5的时候，输出的是 5 4 3 2 1，因为我们是在头部插⼊数据的*///-------------------------------------------------------------------------------------------------------------//linklist creat_linklist_insert_end_yeshead(){linklist l=NULL,r=NULL;//定义头指针变量和尾指针变量lnode *s;//定义新建节点int flag=-1;//输⼊结束标志位printf("输⼊整型数据，数据以空格隔开，输⼊数据为-1的时候表⽰输⼊截⽌\n");while(1){int x;scanf("%d",&x);if(x==flag)//输⼊数据等于输⼊结束标志位则跳出循环break;s=(lnode*)malloc(sizeof(lnode));//申请内存空间s->data=x;//赋值if(l==NULL)//单链表为空l=s;//则将头指针指向新建节点elser->next=s;//不空的话则将尾指针的next指向s，因为如果不空的话，尾指针指向的肯定是⼀个数据节点，尾指针的next指向s是为了将两个数据节点连接起来r=s;//尾指针移动到新插⼊的节点上}if(r!=NULL)//有数据r->next=NULL;//尾指针的next指向空，说明尾指针后⾯没有数据了，⽬的的为了保证单链表尾指针逻辑的合理性return l;}//建⽴单链表且在链表尾部插⼊数据,含空的头节点//-----------------------------------------------------------------------------------------------------------------------///*在单链表的尾部插⼊，只要没有输⼊结束的标志，就⼀直申请s结点，然后把x赋给s结点的data域，l=s是为了第⼀个结点的结点的处理，因为在此之前l是⼀个空表，然后因为不断有新的结点⽣成，所以就是不断把新的s结点赋给r的next，这样就不断有s结点加⼊到了单链表中间，然后最重要的是每次新的结点加⼊到单链表中后要把r尾指针向后⾯移动，就是⽂中的r=s；关于此函数的⼀点说明：输⼊数据 1 2 3 4 5，输出还是 1 2 3 4 5，⽽不是 5 4 3 2 1，因为我们插⼊数据是在链表尾部插⼊的*///-----------------------------------------------------------------------------------------------------------------------//int length_linklist_yeshead(linklist l){linklist p=l;int j=1;while(p->next){j++;p=p->next;}return j;}//求单链表的表长，针对含有空的头节点的单链表int length_linklist_nohead(linklist l){lnode *p=l;int j=0;while(p){j++;p=p->next;}return j;}//求链表的表长，针对不含空的头节点的单链表lnode *get_linklist(linklist l,int i){lnode *p=l;int j=0;while(p!=NULL&&j<i){p=p->next;j++;}if(j==i)return p;elsereturn NULL;}//单链表的查找第i个元素结点，*p=l就是使p指针指向l链表；lnode *locate_linklist(linklist l,int x){lnode *p=l->next;//l为头节点while(p!=NULL&&p->data!=x)p=p->next;return p;}//单链表查找值为x的结点，找到后返回指向这个结点的指针；以后时刻要记得l为头指针，因为定义了头指针⽐没有定义头指针要⽅便许多；int insert_linklist(linklist l,int i,int x){lnode *p,*s;p=get_linklist(l,i-1);//找到第i-1个结点if(p==NULL){printf("i错误");return0;}elses=(lnode*)malloc(sizeof(lnode));s->data=x;s->next=p->next;p->next=s;return1;}//单链表的第i个结点后⾯的插⼊，重要的是申请，封装s结点，int del_linklist(linklist l,int i){i--;linklist p,s;p=get_linklist(l,i-1);if(p==NULL){printf("该i-1节点不存在");return -1;}else if(p->next==NULL){printf("第i个结点不存在");return0;}else{s=p->next;p->next=s->next;free(s);return1;}}//单链表中删除第i个结点，那么就先要找到i个结点的前驱，也就是第i-1个结点，同理单链表中的插⼊也要知道其前驱结点，所以单链表中的头节点的重要性就可想⽽知了void printf_linklist(lnode *plisthead){lnode *ptemp=plisthead;while(ptemp){printf("%d\t",ptemp->data);ptemp=ptemp->next;}printf("\n");}//链表打印函数int main(){/*linklist l=creat_linklist_insert_end_yeshead();printf("%d\n",length_linklist_yeshead(l));insert_linklist(l,2,100);//第⼆个结点的后⾯插⼊100printf_linklist(l);del_linklist(l,4);//删除第四个结点printf_linklist(l);*//*linklist l=creat_linklist_insert_head_nohead();printf("%d\n",length_linklist_nohead(l));insert_linklist(l,2,100);printf_linklist(l);del_linklist(l,4);printf_linklist(l);*/return0;}。

数据结构实验5单链表配套代码

数据结构实验5 配套代码1、#include <stdio.h>#include <stdlib.h>#include <ctype.h>#define OK 1#define ERROR 0#define OVERFLOW -2#define MAXSIZE 100#define NULL 0typedef int Status;typedef int ElemType;typedef struct LNode{ElemType data; //数据域struct LNode *next; //指针域}LNode,*LinkList; // *LinkList为Lnode类型的指针int main(){LNode *La=NULL;char choice1,choice2,choice3; // 菜单选项ElemType b[MAXSIZE],b1[MAXSIZE],x,z;int i,num,num1,n,m,e,y;Status InitList_L(LinkList &L);void CreateList_L(LinkList &L,ElemType a[],int n);Status DispList_L(LinkList L);int ListEmpty(LinkList L);Status GetElem_L(LinkList L,int i,ElemType &e);int LocateELem_L (LinkList L,ElemType e);Status ListInsert_L(LinkList &L,int i,ElemType e);Status ListDelete_L(LinkList &L,int i,ElemType &e);int ListLength_L(LinkList L);Status ClearList(LinkList & L);Status DestroyList_L(LinkList &L);InitList_L(La);printf("线性表中元素的个数?\n");scanf("%d",&num);printf("请输入元素:\n");for(i=0;i<num;i++)scanf("%d",&b[i]);CreateList_L(La,b,num);do{printf("\t单链表操作\n");printf("P-输出\t\tG-取值\n");printf("S-查找\t\tI-插入\n");printf("D-删除\t\tC-清空\n");printf("L-求表长\tQ-退出\n");scanf(" %c", &choice1);choice1 = toupper(choice1); //将字符choice转换为大写英文字母switch (choice1){case 'P':printf("线性表中的元素为:\n");DispList_L(La);break;case 'G':printf("要查找第几个元素?\n");scanf("%d",&n);m=GetElem_L(La,n,e);if(!m)printf("要查找的元素位置不合法!\n");elseprintf("要查找的第%d个元素是：%d\n",n,e);break;case 'S':printf("要查找的元素的值为：\n");scanf("%d",&x);m=LocateELem_L(La,x);if(!m)printf("线性表中不存在该元素!\n");elseprintf("%d是本表中的第%d个元素。

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

单链表的完整代码

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

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

单链表（C语言实现）

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

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

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

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

数据结构单链表实验代码

数据结构单链表代码

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

c语言单链表程序代码

c语言单链表代码

数据结构课程设计-职工信息管理系统-单链表实现程序源代码

数据结构(C语言)用单链表存储一元多项式,并实现两个多项式的相加运算

C#源码_数据结构(单链表+反向链表)

单链表（c语言实现）贼详细

数据结构实验5单链表配套代码

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

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

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