C语言实现单链表的增删改查
单链表的增删查改功能
单链表的增删查改功能的实现#include<iostream>using namespace std;class LinkNode{friend class List;private:int date;LinkNode *link;LinkNode(const int& d=int()):date(d),link(NULL) {} };class List{public:void CreatList(int );bool Insert(int i,int& x);bool Remove(int i,int& x);void PrintList();int Find(const int& date);int FindPos(int pos);void Update(const int &e,const int &ne);void Showmeun();private:LinkNode *first;};void List::CreatList(int n){LinkNode *p,*q;first=new LinkNode;first->link=NULL;p=first;for(int i=0;i<n;i++){cout<<"请输入第"<<i+1<<"个数: ";q=new LinkNode;cin>>q->date;q->link=p->link;p->link=q;p=q;}}bool List::Insert(int i, int &x){if(first==NULL||i==0){LinkNode *newNode=new LinkNode(x);if(newNode==NULL){cerr<<"存储分配错误！"<<endl;exit(i);}newNode->link=first;first=newNode;}else{LinkNode *p=first;for(int k=1;k<i;k++)if(p==NULL)break;elsep=p->link;if(p==NULL){cerr<<"无效的插入位置！"<<endl;return false;}else{LinkNode *newNode=new LinkNode(x);if(newNode==NULL){cerr<<"存储分配错误！"<<endl;exit(1);}newNode->link=p->link;p->link=newNode;}}return true;}bool List::Remove(int i, int &x){LinkNode *del,*p;if(i<=1){del=first;first=first->link;}else{p=first;for(int k=1;k<i;k++)if(p==NULL)break;elsep=p->link;if(p==NULL||p->link==NULL){cerr<<"无效的删除位置！"<<endl;return false;}del=p->link;p->link=del->link;}x=del->date;delete del;return true;};void List::Showmeun(){cout<<"********链表的增删查改功能*********"<<endl;cout<<" 1-链表全部数据的输出"<<endl;cout<<" 2-链表插入元素"<<endl;cout<<" 3-链表删除元素"<<endl;cout<<" 4-链表查找元素"<<endl;cout<<" 5-链表数据的修改"<<endl;cout<<" 0-退出"<<endl;cout<<"*********************************"<<endl;cout<<" 请输入功能序号:"<<endl;}void List::PrintList(){LinkNode *p;cout<<"输出单链表为：";p=first->link;while(p!=NULL){cout<<p->date<<" ";p=p->link;}cout<<endl;}int List::Find(const int &date){LinkNode *p;p=first;for(int k=0;p!=NULL;k++){if(p->date==date)return k;p=p->link;}return -1;}int List::FindPos(int pos){if(pos<1){cerr<<"位置超出范围!"<<endl;exit(1);}LinkNode* p=first;int i=-1;while(p!=NULL){i++;if(i==pos)break;p=p->link;}if(p!=NULL)returnp->date;else{cerr<<"位置超出范围!"<<endl;exit(1);}return -1;}void List::Update(const int &e,const int &ne){LinkNode *p = first;LinkNode *q = first;while(p != NULL && p->link != NULL){q = p->link;if(e == q->date){q->date = ne;continue;}p = p->link;}}void main(){List link;int n,choice,i,x,y;cout<<"请输入链表中元素的个数，建立链表："<<endl;cin>>n;link.CreatList(n);link.Showmeun();cin>>choice;while(choice!=0){switch(choice){case 1:link.PrintList();break;case 2:cout<<"请输入你要插入元素的位置："<<endl;cin>>i;cout<<"请输入你要插入元素的值："<<endl;cin>>x;link.Insert(i,x);break;case 3:cout<<"请输入你要删除元素的位置:"<<endl;cin>>i;link.Remove(i,x);break;case 4:cout<<"******************"<<endl;cout<<"1-按元素的数值查找"<<endl;cout<<"2-按元素的位置查找"<<endl;cout<<"******************"<<endl;cout<<"请选择："<<endl;cin>>x;if(x==1){cout<<"请输入要查找的数据："<<endl;cin>>x;i=link.Find(x);if(i!=-1)cout<<"在第"<<i<<"个位置找到数据："<<x<<endl;elsecout<<"没有找到数据！"<<endl;}else{cout<<"请输入需要查找元素位置"<<endl;cin>>i;x=link.FindPos(i);cout<<"第"<<i<<"个位置的数据为："<<x<<endl;}break;case 5:cout<<"请输入原数据和更改后的数据："<<endl;cin>>x>>y;link.Update(x,y);cout<<"你已经成功的将"<<x<<"改成了"<<y<<"!"<<endl;break;}cout<<"请输入功能序号："<<endl;cin>>choice;}}。
C++链表，增删改查
C++链表，增删改查//// main.c// homework_linkList//// Created by jiumiao on 15/7/23.// Copyright (c) 2015年 jiumiao. All rights reserved.//#include <stdio.h>#include <stdlib.h>typedef struct _NPC{char name[20];int attack;int hp;}NPC;typedef struct _node{NPC data;struct _node *pNext;}Node;Node *head = NULL;//定义⼀个头节点//加⼊节点void addNode(){if (head == NULL) {//head申请⼀个内存空间head = malloc(sizeof(Node));printf("请输⼊NPC的名字攻击⼒⽣命值:\n");scanf("%s %d %d",head->,&head->data.attack,&head->data.hp);head->pNext=NULL;} else {Node *p = head;//指向头节点while (p->pNext != NULL) {p = p->pNext;}//申请内存空间p->pNext = malloc(sizeof(Node));p=p->pNext;printf("请输⼊NPC的名字攻击⼒⽣命值:\n");scanf("%s %d %d",p->,&p->data.attack,&p->data.hp);p->pNext = NULL;}printf("加⼊节点成功！\n");}//输出全部节点void printAllNode(){Node *q = head;//指向头节点while (q!=NULL) {printf("名字为：%s，攻击⼒：%d。
C语言之单链表的插入、删除与查找
C语⾔之单链表的插⼊、删除与查找单链表是⼀种链式存取的数据结构，⽤⼀组地址任意的存储单元存放线性表中的数据元素。
要实现对单链表中节点的插⼊、删除与查找的功能，就要先进⾏的单链表的初始化、创建和遍历，进⽽实现各功能，以下是对单链表节点的插⼊、删除、查找功能的具体实现：#include<stdio.h>#include<stdlib.h>#include<string.h>typedef int ElemType;/***链表通⽤类型*ElemType 代表⾃定义的数据类型*struct Node *next 代表结构体指针（指向下⼀个结构体，完成链表动作）*/typedef struct Node{ElemType data;struct Node *next;}Node;/*==========单链表的初始化================*//**头结点指针数据域设置为空*/void initList(Node **pNode){*pNode=NULL;}/*===========单链表的创建=================*//**功能实现：通过⽤户不断输⼊数据，创建链表*利⽤游标俩个指针（p1,p2），将申请下的数据块(存⼊⽤户输⼊数据)，链接起来*/Node *create(Node *pHead){Node *p1;Node *p2;p1=p2=(Node *)malloc(sizeof(Node)); //申请内存空间memset(p1,0,sizeof(Node)); //存⼊数据域清空scanf("%d",&p1->data);p1->next=NULL;while(p1->data>0){ //输⼊负数结束if(pHead==NULL)pHead=p1;elsep2->next=p1;p2=p1;p1=(Node *)malloc(sizeof(Node));memset(p1,0,sizeof(Node));scanf("%d",&p1->data);p1->next=NULL;}return pHead;}/*=================链表的遍历==================*//***从头结点开始，不断遍历出数据域的内容将表遍历*/void printList(Node *pHead){if(NULL==pHead)printf("链表为空\n");else{while(pHead!=NULL){printf("%d ",pHead->data);pHead=pHead->next;}}printf("\n");}/*===============插⼊节点==================*//***Node **pNode 传⼊头结点空间地址*int i 传⼊要插⼊的结点位置*/void insert_data(Node **pNode,int i){Node *temp;Node *target;Node *p;int item;int j=1;printf("输⼊要插⼊的节点值:");scanf("%d",&item);target=*pNode;for(;j<i-1;target=target->next,++j); //不断移动target位置，到要插⼊结点位置，temp=(Node *)malloc(sizeof(Node)); //申请内存空间temp->data=item; //存⼊要存⼊的数据位置p=target->next;target->next=temp;temp->next=p;}/*===============删除节点====================*//***删除结点后，释放内存空间free(temp)*/void delete_data(Node **pNode,int i){Node *target;Node *temp;int j=1;target=*pNode;for(;j<i-1;target=target->next,++j);temp=target->next;target->next=temp->next;free(temp);}/*===============查找结点====================*/int search_data(Node *pNode,int elem){Node *target;int i=1;for(target=pNode;target->data!=elem && target->next!=NULL;++i,target=target->next); if(target->next==NULL)return 0;elsereturn i;}int main(){int i;Node *pHead=NULL;initList(&pHead);pHead=create(pHead);printList(pHead);printf("输⼊插⼊节点位置\n");scanf("%d",&i);insert_data(&pHead,i);printList(pHead);printf("输⼊删除节点位置\n");scanf("%d",&i);delete_data(&pHead,i);printList(pHead);printf("输⼊查找节点\n");scanf("%d",&i);printf("节点所在位置：%d",search_data(pHead,i));return 0;}通过以上各功能的实现，希望对⼤家单链表的学习有所帮助。
C语言单向链表的增删查改快速掌握
C 语⾔单向链表的增删查改快速掌握⽬录前⾔⼀、创建⼆、单向链表的函数声明三、函数实现1.创建节点2.尾插节点3.头插4.尾删5.头删6.查找节点7.修改总结前⾔链表是线性表的链式存储结构，它可以以O(1)的时间复杂度进⾏插⼊或者删除，同时由于是链式结构相⽐顺序表⽽⾔，不会存在空间浪费的情况。
⽽链表⼜分为带头单向链表，不带头单向链表，带头循环链表，不带头循环链表，带头双向循环链表，不带头双向循环链表，带头双向链表，不带头双向链表，总共有⼋种，其中结构最简单的是不带头单向链表，也是实现起来最容易出错的。
并且我们在⽹上进⾏链表的oj 时，题⽬基本也是不带头的单向链表，⽽且也是互联⽹⼤⼚⾯试中最容易考的。
⼀、创建123456typedef int SLTDadaType;//存放的数据类型struct SListNode { SLTDadaType _data;//存放的数据struct SListNode* _next;//指向下⼀个节点的指针};typedef struct SListNode SListNode;⼆、单向链表的函数声明123456SListNode* BuyListNode(SLTDadaType x);//创建⼀个节点SListNode* SListPushBack(SListNode* head, SLTDadaType x);//尾插SListNode* SListPopBack(SListNode* head);//头插SListNode* SListPushFornt(SListNode* head, SLTDadaType x);//尾删SListNode* SListPopFornt(SListNode* head);//头删SListNode* SListFind(SListNode* head, SLTDadaType x);//查找⼀个节点void SListModify(SListNode* head, SLTDadaType x,SLTDadaType y);//x 修改三、函数实现1.创建节点1234SListNode* BuyListNode(SLTDadaType x){ SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));newnode->_data = x;56newnode->_next = NULL;return newnode;}2.尾插节点12345678910111213141516171819SListNode* SListPushBack(SListNode* head, SLTDadaType x){SListNode* newnode = BuyListNode(x);//⽆论节点是否为空，都先进⾏创建⼀个节点if (head == NULL) //头节点为空{head = newnode; return head; } else //头节点不为空，直接遍历到链表结尾进⾏尾插 {SListNode* tail = head;while (tail->_next != NULL){tail = tail->_next; } tail->_next = newnode;return head;}}3.头插123456SListNode* SListPushFornt(SListNode* head, SLTDadaType x){ SListNode* newnode = BuyListNode(x);newnode->_next = head;head = newnode;return head;}4.尾删12345678*********SListNode* SListPopBack(SListNode* head){//1.空//2.只有⼀个节点 //3.有多个节点 if (head == NULL) { return head; }else if (head->_next== NULL){free(head);head = NULL;14151617181920212223242526272829return head;}else{ SListNode* prev = NULL; SListNode* tail = head;while (tail->_next != NULL) //利⽤前指针来保存要删除的节点的前⼀个节点{prev = tail;tail = tail->_next; } free(tail); if (prev != NULL)prev->_next = NULL;return head;}}5.头删1234567891011121314SListNode* SListPopFornt(SListNode* head){if (head == NULL){ return head; } else {SListNode* cur = head->_next;free(head); head = cur; return head; }}6.查找节点12345678910111213141516SListNode* SListFind(SListNode* head, SLTDadaType x){SListNode* cur = head; while (cur) { if (cur->_data == x) { return cur; }else{cur = cur->_next; } }return NULL;}7.修改1234567891011void SListModify(SListNode* head, SLTDadaType x, SLTDadaType y)//x 修改{SListNode* find = SListFind(head, x); if (find) { find->_data = y; }else{printf("对不起，您要修改的值不存在\n"); }}总结本篇⽂章主要是针对单向链表⼀些基本操作的代码实现，若有写的错误或值得改进的地⽅，请⼤家多多留⾔指出。
注释最全的C语言链表的增删改查
注释最全的C语⾔链表的增删改查 1//这是C语⾔的写法，但会报错，原因是len（当前的节点长度）2//⽆法在insert（插⼊）和deleted（删除）之后改变3//不能使⽤delete是因为delete是C++中的⼀个运算符4//最终我把改程序⽤C++写了⼀遍，运⽤引⽤将len的真实值改变了5 #include <stdio.h>6 #include <stdlib.h>7 typedef int ElementType;8 typedef struct node {9 ElementType data;10struct node *pNext;//指向下⼀个结点的指针11 }Node, *pNode;//这⾥NODE等价于struct node、、PNODE等价于struct Node*1213 pNode Create_List(int len);14 pNode change(pNode pHead,int len);15void ergodic(pNode pHead,int len);16 pNode insert(pNode pHead,int *len);17int main() {18 pNode pHead = NULL;//创建⼀个头结点19int len;//⽤来存放有效节点字数20 printf("请输⼊节点个数：");21 scanf("%d", &len);22 pHead = Create_List(len);//创建⼀个单链表，并将该链表的头指针赋值给pHead23 pNode p;//创建⼀个移动指针，指向需要访问的结点242526 ergodic(pHead,len);//遍历数据输出27 p = change(pHead,len);//修改节点的数据28 ergodic(pHead,len);//遍历数据输出29 p = insert(pHead,&len);//插⼊⼀个节点30 printf("此时len为:%d", len);31 printf("\n插⼊成功\n");32 ergodic(pHead,len);//遍历数据输出33return0;34 }35363738 pNode Create_List(int len)//这⾥⽤PNODE表⽰返回⼀个结构体类型的指针39 {40//创建链表4142 pNode pHead = (pNode)malloc(sizeof(Node));//分配⼀个不存放有效数据的头的头结点43//malloc返回的是⼀个节点，其中 (结构体类型的指针)malloc(sizeof(结构体的名称))44 pNode pTail = pHead;//定义⼀个尾指针,并初始化45 pTail->pNext = NULL;//将尾节点指针置空4647int i;48int val;49for (i = 0; i<len; i++) {50 printf("输⼊第%d个节点的数值：", i + 1);51 scanf("%d", &val);52 pNode pNew = (pNode)malloc(sizeof(Node));53//给下⼀个节点分配空间54 pNew->data = val;//1.先把值赋给下⼀个结点55 pTail->pNext = pNew;//新的节点的指针域pTail的指针域56 pNew = NULL;//把为节点的指针域置空57 pTail = pTail->pNext;//将尾指针+1指向最后⼀个节点58 }59return pHead;//返回⼀个链表的头指针60 }61//++++++++++++++++++++++++++++++62void ergodic(pNode pHead, int len) {63//遍历数据输出64 pNode p;65 p = pHead;//将移动指针指向头结点66int j;67for (j = 0; j<len; j++) {68 p = p->pNext;69 printf("第%d个节点的数值是：%d\n", (j + 1), p->data);70 }71 }7273//++++++++++++++++++++++++++++++74 pNode change(pNode pHead, int len) {75//修改节点的数据76 pNode p;77 p = pHead;78int value;79 printf("修改节点的数据\n");80int k;81for (k = 0; k<len; k++) {82 p = p->pNext;83 printf("输⼊第%d个结点要修改的数据：", k + 1);84 scanf("%d", &value);85 p->data = value;86 }87return pHead;88 }89//+++++++++++++++++++++++++++++90//插⼊节点91 pNode insert(pNode pHead, int *len) {92 pNode p;93 p = pHead;94 printf("输⼊在第⼏个节点(头结点不算)后插⼊：");95int m;96 scanf("%d", &m);97int i;98for (i = 0; i<m; i++) {99 p = p->pNext;100 }101 pNode e = (pNode)malloc(sizeof(Node));102 e->pNext = NULL;103 printf("请输⼊该节点的数值：");104int n;105 scanf("%d", &n);106 e->data = n;107 e->pNext = p->pNext;108 p->pNext = e;109 len++;110return pHead;111 }112//+++++++++++++++++++++++++++++++113//+++++++++++++++++++++++++++++114//删除节点115 pNode delete(pNode pHead,int len){116 pNode p;117 pNode q;118 p=pHead;119 printf("请输⼊要删除第⼏个节点(不包含头结点)"); 120int k;121 scanf("%d",&k);122int i;123for(i=0;i<k-1;i++){124 p=p->pNext;125 }126 q=p->pNext;127 p->pNext=q->pNext;128free(q);129 q=NULL;130return pHead;131 }。
链表：用CC++实现单链表的增删改查
链表：⽤CC++实现单链表的增删改查最近复习了线性表，对链表这⼀部分遗忘最⼤，所以⼿动实现⼀下单链表的增，删，改，查，倒置等等加深理解，附上C++代码：#include<iostream>using namespace std;typedef struct LNode { //定义链表的结构int data;struct LNode* next;}LNode,*LinkList;void create(LinkList& l)// 头插法建⽴带头结点的链表，输⼊⼩于0的数值视为终⽌{l = (LinkList)malloc(sizeof(LNode));int x;l->next = NULL;cin >> x;do{LNode* s = (LNode*)malloc(sizeof(LNode));s->data = x;s->next = l->next;l->next = s;cin >> x;} while (x > 0);}void tailCreate(linkList& l){l = (linkList)malloc(sizeof(LNode));int data;l->next = NULL;cin >> data;linkList ptr = l;while (data > 0){linkList p = (linkList)malloc(sizeof(LNode));p->data = data;ptr->next = p;p->next = NULL;ptr = p;cin >> data;}}void dis(LinkList l) //输出链表{cout << "当前链表为："<<endl;while (l->next != NULL){cout << l->next->data << "";l = l->next;}cout << endl;}LinkList insert(LinkList& l, int x) //头插法插⼊结点在链表开头{LNode* s = (LNode*)malloc(sizeof(LNode));s->data = x;s->next = l->next;l->next = s;return l;}int getNumber(LinkList l, int x)//按照值查找结点序号，返回序号{int i = 0;while (l != NULL){i++;if (l->data == x){cout << "find x=" << x << " ,num=" << i - 1 << endl;break;}l = l->next;}return i;}LNode* getElement(LinkList l, int no)//按照序号查找结点并返回结点{LNode* s = l->next;int j = 1;while (s->next != NULL && j < no){s = s->next;j++;}cout <<"find No."<<no<<" is "<< s->data << endl;return s;}void delect(LinkList& l, int no)//删除指定序号的节点{if (no == 1)//因为第⼀个元素的前驱结点是头结点，所以单独处理删除第⼀个元素的情况 {LNode* s = l;LNode* p = l->next;l->next = p->next;free(p);}else{LNode* s = getElement(l, no - 1); //先找到它的前驱结点LNode* p;p = s->next;s->next = p->next;cout << "delect " << p->data << " success" << endl;free(p);}}void reverseList(LinkList& l) //将链表倒序{LNode* s = (LNode*)malloc(sizeof(LNode));LNode* p = (LNode*)malloc(sizeof(LNode));s = l->next;l->next = NULL;while (s!= NULL){p = s->next;s->next = l->next;l->next = s;s = p;}}int main(void){LinkList l;int x, no;cout << "输⼊正整数插⼊链表，输⼊负整数后结束输⼊：" << endl;create(l);//输⼊链表dis(l); //输出链表cout << "输⼊要插⼊在链表前端的数值：" << endl;cin >> x;insert(l,x);dis(l);cout << "输⼊要查找的结点数值：" << endl;cin >> x;getNumber(l,x);//根据数组查找第⼀个对应的结点cout << "输⼊要查找的结点序号(1~n)：" << endl;cin >> no;getElement(l,no);//根据序号查找对应的数值cout << "输⼊要删除的结点序号(1~n)：" << endl; cin >> no;delect(l,no);//删除指定序号的结点dis(l);reverseList(l);//反转链表dis(l);}执⾏上述程序的输出如下：。
【C语言】－单链表元素的添加、删除
【C语⾔】－单链表元素的添加、删除#include <stdio.h>#include <stdlib.h>// 定义数据结构/* 节点 Node */typedef int Element;struct Node{Element data;struct Node *next;};// 创建单链表struct Node * createList(void);struct Node * createList(void){struct Node *head = NULL;struct Node *temp = NULL;struct Node *tail = NULL;int data;scanf("%d",&data);while (data){temp = (struct Node *)malloc(sizeof(struct Node));if (temp == NULL){printf("alloc error!");}else{temp->data = data;temp->next = NULL;if (head == NULL){head = tail = temp;}else{tail->next = temp;tail = temp;}}scanf("%d",&data);}return head;}// 输出单链表各个元素的数值void printList(struct Node *head);void printList(struct Node *head){struct Node *p = NULL;p = head;while (p){printf("%d ",p->data);p = p->next;}}// 求链表长度int length(struct Node *head);int length(struct Node *head){int count = 0;struct Node *p;p = head;while (p){count++;p=p->next;}return count;}// 求pos位置的数据int elementAt(struct Node *head,int pos);int elementAt(struct Node *head,int pos){if (pos <= 0 || pos > length(head)){return0;}int loc = 1;struct Node *p = head;while (loc < pos){loc++;p = p->next;}//p->data = 12;return p->data;}void insertHeadNode(struct Node **head,int value); void insertHeadNode(struct Node **head,int value) {struct Node *tmp;tmp = (struct Node *)malloc(sizeof(struct Node)); tmp->data = value;tmp->next = NULL;if (head == NULL){*head = tmp;}else{tmp->next = *head;*head = tmp;}}// 在尾部添加⼀个元素void insertTailNode(struct Node **head,int value); void insertTailNode(struct Node **head,int value) {struct Node *tmp;tmp = (struct Node *)malloc(sizeof(struct Node)); tmp->data = value;tmp->next = NULL;if (head == NULL){*head = tmp;}else{struct Node *q = NULL;struct Node *p = *head;while (p){q = p;p = p->next;}q->next = tmp;}}//在列表的第 pos 个位置添加⼀个 value 元素int insertNode(struct Node **head,int pos,int value); int insertNode(struct Node **head,int pos,int value) {if (pos<=0){return0;}if (pos == 1){insertHeadNode(head, value);return1;}if (pos > length(*head)){insertTailNode(head, value);return1;}struct Node *tmp;tmp = (struct Node *)malloc(sizeof(struct Node)); tmp->data = value;tmp->next = NULL;struct Node *p,*q;p = *head;int loc = 1;// 定位指针位置while (loc < pos){loc++;q = p;p = p->next;}tmp->next = q->next;q->next = tmp;return1;}int main(int argc, const char * argv[]){struct Node *head = NULL;head = createList();printList(head);//1、int pos = 0;printf("第%d个元素的数值：%d",pos,elementAt(head,pos)); //3、printf("\n");insertHeadNode(&head, 100);printList(head);printf("\n");insertTailNode(&head, 200);printList(head);printf("\n");insertNode(&head, 2, 300);printList(head);return0;}。
C语言单链表的基本操作（增删改查）
C语⾔单链表的基本操作（增删改查）这是尾插法单链表，单链表⽐较适合⽤来做队列和栈，因为在链表的头和尾时的增删改查的时间复杂度为O(1)，⽽在链表内部的增删改查的平均时间复杂度为O(n)。
#include "stdio.h"#include "stdlib.h"//提供malloc()和free()#include "string.h"#include "time.h"//提供strcpy()，time()等//1.⽤结构体创建链表节点//⼀个⽤来存放数据，另⼀个存放指针struct Node{int data; //数据域struct Node* next; //指针域(指向节点的指针）};//2.全局定义链表头尾指针，⽅便调⽤struct Node* head = NULL;struct Node* end = NULL;//3.向链表添加数据void AddListTill(int a ){//创建⼀个节点struct Node* temp = (struct Node*)malloc(sizeof(struct Node)); //此处注意强制类型转换//节点数据进⾏赋值temp->data = a;temp->next = NULL;//连接分两种情况1.⼀个节点都没有2.已经有节点了，添加到尾巴上if(NULL == head){head = temp;//end=temp;}else{end->next=temp;//end=temp; //尾结点应该始终指向最后⼀个}end=temp; //尾结点应该始终指向最后⼀个}//4.遍历链表并输出void ScanList(){struct Node *temp = head; //定义⼀个临时变量来指向头while (temp != NULL){printf("%d\n",temp->data);temp = temp->next; //temp指向下⼀个的地址即实现++操作}}//5.查找指定的数据是否在链表内struct Node* FindNode(int a ){struct Node *temp = head;while(temp != NULL){if(a == temp->data){return temp;}temp = temp->next;}//没找到return NULL;}//6.删除链表void FreeList(){struct Node *temp = head; //定义⼀个临时变量来指向头while (temp != NULL){struct Node* pt = temp;temp = temp->next; //temp指向下⼀个的地址即实现++操作free(pt); //释放当前}//头尾清空，不然下次的头就接着0x10head = NULL;end = NULL;}//7.在指定位置处插⼊数据void AddListRand(int index,int a){if (NULL == head){printf("链表没有节点\n");return;}struct Node* pt = FindNode(index);if(NULL == pt) //没有此节点{printf("没有指定节点\n");return;}//有此节点//创建临时节点，申请内存struct Node* temp =(struct Node *)malloc(sizeof(struct Node));//节点成员进⾏赋值temp->data = a;temp->next = NULL;//连接到链表上 1.找到的节点在尾部 2.找到的节点在中间if (pt == end){//尾巴的下⼀个指向新插⼊的节点end->next = temp;//新的尾巴end = temp;}else{//先连后⾯（先将要插⼊的节点指针指向原来找到节点的下⼀个） temp->next = pt->next;//后连前⾯pt->next = temp;}}//8.删除链表末尾数据void DeleteListTail(){if (NULL == end){printf("链表为空，⽆需删除\n");return;}//链表不为空//链表有⼀个节点if (head == end){free(head);head = NULL;end = NULL;}else{//找到尾巴前⼀个节点struct Node* temp = head;while (temp->next != end){temp = temp->next;}//找到了，删尾巴//释放尾巴free(end);//尾巴迁移end=temp;//尾巴指针为NULLend->next = NULL;}}//9.删除链表的第⼀个数据void DeleteListHead(){ //记住旧头struct Node* temp = head;//链表检测if (NULL == head){printf("链表为空\n");return;}head = head->next; //头的第⼆个节点变成新的头free(temp);}//10.删除链表指定的数据void DeleteListRand(int a){//链表判断是不是没有东西if(NULL == head){printf("链表没东西\n");return;}//链表有东西，找这个节点struct Node* temp = FindNode(a);if(NULL == temp){printf("查⽆此点\n");return;}//找到了,且只有⼀个节点if(head == end){free(head);head = NULL;end = NULL;}else if(head->next == end) //有两个节点{//看是删除头还是删除尾if(end == temp){DeleteListTail();}else if(temp == head){DeleteListHead();}}else//多个节点{//看是删除头还是删除尾if(end == temp)DeleteListTail();else if(temp == head)DeleteListHead();else//删除中间某个节点{ //找要删除temp前⼀个，遍历struct Node* pt = head;while(pt->next != temp){pt=pt->next;}//找到了//让前⼀个直接连接后⼀个跳过指定的即可 pt->next = temp->next;free(temp);}}}//主函数void main(){struct Node *pFind;srand((unsigned)time(NULL));int i;//创建20个节点for(i = 0; i < 20; i++)AddListTill(i); //添加数据//AddListTill(rand());AddListRand(4,86); //在指定位置4增加节点14//DeleteListHead(); //删除⼀个头结点//DeleteListTail(); //删除⼀个尾结点DeleteListRand(4); //删除4节点ScanList(); //遍历输出链表//FreeList(); //删除链表pFind = FindNode(5); //查找5节点if (pFind != NULL){printf("找到%d\n",pFind->data); //找到节点并且输出该节点数据 }else{printf("No Find!\n");}}以下是排序算法的时间和空间复杂度表：。
1、链表之增、删、查实现（C语言）
1、链表之增、删、查实现（C语⾔）⼀、功能描述：可以创建节点并添加到链表中、查看链表中的所有节点、并可以删除特定的节点⼆、代码实现1、主函数main主要实现的是从后台键⼊不同的字符，执⾏对应的函数来实现特定的操作代码如下：int main(char argc, char *argv[]){char c;while (1){c = getchar(); //键⼊⼀个字符// printf("c = %c\n",c);printf("Usage:\n");printf("<l> List all the notes\n");printf("<a> Add a node to chains\n");printf("<d> Delete a node from chains\n");printf("<q> quit\n");printf("Enter the choise: \n");switch (c){case'l' :{list_all_notes(); //显⽰链表中所有的节点break;}case'a' :{add_a_node(); //链表中添加⼀个节点break;}case'd' :{delete_a_node(); //删除链表中的⼀个节点break;}case'q' : //退出死循环{return0;break;}defaut :{break;}}}return0;}2、add_a_node的主要作⽤创建⼀个节点，并初始化（节点分配内存、初始化节点name），最后调⽤add_note_to_chains函数把该节点添加到链表中，代码如下：1void add_a_node()2 {3char *str; //⽤来存放节点名字4char name[128]; //临时变量，键盘设置新节点的名字5 PT_Node ptNew; //指针变量，指向新的节点67 printf("Please enter name of node to be added : ");8 scanf("%s", name); //给新添加的节点取⼀个名字910 str = malloc(strlen(name) + 1); //为节点的名字分配空间11 strcpy(str, name);1213 ptNew = malloc(sizeof(T_Node)); //为新节点分配内存1415//初始化节点中的元素16 ptNew ->name = str; //节点中的name指向str17 ptNew ->pre = NULL;18 ptNew ->next = NULL;1920 add_note_to_chains(ptNew); //把该节点添加到链表中21 }3、add_note_to_chains主要实现的是把节点挂载到链表中，代码如下：static void add_note_to_chains(PT_Node ptNew){PT_Node ptCur;if (g_ptNodeHead == NULL){g_ptNodeHead = ptNew;//如果链表中没有⼀个节点，则头结点指向该节点}else{ptCur = g_ptNodeHead;while(ptCur ->next) //遍历找到当前节点的next元素为空{ptCur = ptCur ->next;}ptCur->next = ptNew; //把新的节点挂载到g_ptNodeHead链表中ptNew ->pre = ptCur;}}4、delete_a_node函数的主要功能是通过键⼊的name，索引到链表中对应的节点地址，最后调⽤delete_node函数删除（卸载）链表中对应的节点，代码如下：static void delete_a_node(){PT_Node ptFindName;char name[128];printf("Please enter the name of node to be deleted :");scanf("%s", name);ptFindName = get_name(name); //通过名字获得对应节点地址if (ptFindName == NULL){printf("Don't have this node\n");return;}delete_node(ptFindName); //删除链表中对应的节点}5、get_name函数的作⽤是通过节点name在链表中索引到其对应的节点地址，代码如下：PT_Node get_name(char *name){PT_Node ptCar;if (g_ptNodeHead == NULL){return NULL;}else{ptCar = g_ptNodeHead;do{if (strcmp (ptCar->name, name) == 0){printf("find \'%s\' from chain\n",name);return ptCar;}else{ptCar = ptCar->next;}}while (ptCar);printf("don't find \'%s\' from chain\n",name);return NULL;}}6、delete_node函数的主要作⽤是卸载链表中对应的节点，卸载细节如下图，其中ptCar为当前要被卸载的节点、ptPre为前⼀个节点、ptNext为后⼀个节点对应代码如下：static void delete_node(PT_Node ptDel){PT_Node ptCar;PT_Node ptPre;PT_Node ptNext;if (g_ptNodeHead == ptDel){g_ptNodeHead = ptDel->next;// return;}else{ptCar = g_ptNodeHead ->next;// printf("1111111111111\n");while(ptCar){if (ptCar == ptDel){//从链表中删除ptPre = ptCar ->pre;ptNext = ptCar ->next;ptPre->next = ptNext;// printf("22222222\n");if(ptNext){ptNext ->pre = ptPre;}break;}else{ptCar = ptCar->next;// printf("333333\n");}}}free(ptDel->name); //释放节点名字占⽤的内存free(ptDel); //释放节点占⽤的内存}7、list_all_notes显⽰链表中的所⽤节点，代码如下：static void list_all_notes(){PT_Node ptCar;ptCar = g_ptNodeHead;int i = 0;if (g_ptNodeHead == NULL){printf("\n");printf("There is no node in chain list!\n");printf("\n");}while(ptCar){printf("%02d : %s\n", i++, ptCar ->name);ptCar = ptCar ->next;}}8、完整代码实现1 #include <stdio.h>2 #include <stdlib.h>3 #include <string.h>45//定义⼀个节点6 typedef struct T_NODE{7char *name;8struct T_NODE *pre;9struct T_NODE *next;10 }T_Node, *PT_Node;1112static PT_Node g_ptNodeHead; //链表头1314static void add_note_to_chains(PT_Node ptNew)15 {16 PT_Node ptCur;17if (g_ptNodeHead == NULL)18 {19 g_ptNodeHead = ptNew;//如果链表中没有⼀个节点，则头结点指向该节点20 }21else22 {23 ptCur = g_ptNodeHead;24while(ptCur ->next) //遍历找到当前节点的next元素为空25 {26 ptCur = ptCur ->next;27 }2829 ptCur->next = ptNew; //把新的节点挂载到g_ptNodeHead链表中30 ptNew ->pre = ptCur;3132 }33 }3435void add_a_node()36 {37char *str; //⽤来存放节点名字38char name[128]; //临时变量，键盘设置新节点的名字39 PT_Node ptNew; //指针变量，指向新的节点4041 printf("Please enter name of node to be added : ");42 scanf("%s", name); //给新添加的节点取⼀个名字4344 str = malloc(strlen(name) + 1); //为节点的名字分配空间45 strcpy(str, name);4647 ptNew = malloc(sizeof(T_Node)); //为新节点分配内存4849//初始化节点中的元素50 ptNew ->name = str; //节点中的name指向str51 ptNew ->pre = NULL;52 ptNew ->next = NULL;5354 add_note_to_chains(ptNew); //把该节点添加到链表中55 }565758 PT_Node get_name(char *name)59 {60 PT_Node ptCar;61if (g_ptNodeHead == NULL)62 {63return NULL;64 }65else66 {67 ptCar = g_ptNodeHead;68do{69if (strcmp (ptCar->name, name) == 0)70 {71 printf("find \'%s\' from chain\n",name);72return ptCar;73 }74else75 {76 ptCar = ptCar->next;77 }78 }while (ptCar);7980 printf("don't find \'%s\' from chain\n",name);81return NULL;8283 }8485 }8687static void delete_node(PT_Node ptDel)88 {89 PT_Node ptCar;90 PT_Node ptPre;91 PT_Node ptNext;92if (g_ptNodeHead == ptDel)93 {94 g_ptNodeHead = ptDel->next;95// return;96 }97else{98 ptCar = g_ptNodeHead ->next;99// printf("1111111111111\n");100while(ptCar)101 {102if (ptCar == ptDel)103 {104//从链表中删除105 ptPre = ptCar ->pre;106 ptNext = ptCar ->next;107 ptPre->next = ptNext;108// printf("22222222\n");109if(ptNext)110 {111 ptNext ->pre = ptPre;112 }113break;114 }115else116 {117 ptCar = ptCar->next;118// printf("333333\n");119 }120 }121 }122free(ptDel->name); //释放节点名字占⽤的内存123free(ptDel); //释放节点占⽤的内存124 }125126static void delete_a_node()127 {128 PT_Node ptFindName;129char name[128];130131 printf("Please enter the name of node to be deleted :");132 scanf("%s", name);133134 ptFindName = get_name(name); //通过名字获得对应节点地址135if (ptFindName == NULL)136 {137 printf("Don't have this node\n");138return;139 }140141 delete_node(ptFindName); //删除链表中对应的节点142 }143144static void list_all_notes()145 {146 PT_Node ptCar;147 ptCar = g_ptNodeHead;148int i = 0;149if (g_ptNodeHead == NULL)150 {151 printf("\n");152 printf("There is no node in chain list!\n");153 printf("\n");154 }155while(ptCar)156 {157 printf("%02d : %s\n", i++, ptCar ->name);158 ptCar = ptCar ->next;159 }160 }161162int main(char argc, char *argv[])163 {164char c;165while (1)166 {167 c = getchar(); //键⼊⼀个字符168// printf("c = %c\n",c);169170 printf("Usage:\n");171 printf("<l> List all the notes\n");172 printf("<a> Add a node to chains\n");173 printf("<d> Delete a node from chains\n");174 printf("<q> quit\n");175 printf("Enter the choise: \n");176switch (c)177 {178case'l' :179 {180 list_all_notes(); //显⽰链表中所有的节点181break;182 }183case'a' :184 {185 add_a_node(); //链表中添加⼀个节点186break;187 }188case'd' :189 {190 delete_a_node(); //删除链表中的⼀个节点191break;192 }193case'q' : //退出死循环194 {195return0;196break;197 }198 defaut :199 {200201break;202 }203 }204 }205return0;206 }。
c语言中链表进行增删查改的知识
c语言中链表进行增删查改的知识链表是一种常用的数据结构，可以用来存储一系列数据元素，并且可以实现对数据的增删查改操作。
在C语言中，链表的实现通常使用指针来进行。
我们来了解一下链表的基本概念。
链表由一个个节点组成，每个节点包含两部分：数据域和指针域。
数据域用来存储数据元素，而指针域则用来指向下一个节点。
链表的头节点是链表的第一个节点，而尾节点则指向NULL，表示链表的结束。
链表的插入操作可以在任意位置插入一个新节点。
具体步骤如下：1. 创建一个新节点，并为其分配内存空间。
2. 将新节点的数据域赋值为要插入的数据。
3. 将新节点的指针域指向当前节点的下一个节点。
4. 将当前节点的指针域指向新节点。
链表的删除操作可以删除链表中的一个节点。
具体步骤如下：1. 找到要删除的节点以及其前一个节点。
2. 将前一个节点的指针域指向要删除节点的下一个节点。
3. 释放要删除节点的内存空间。
链表的查找操作可以根据给定的数据值查找链表中对应的节点。
具体步骤如下：1. 从链表的头节点开始，依次遍历链表中的每个节点。
2. 判断当前节点的数据值是否与给定的数据值相等。
3. 如果相等，则找到了对应的节点，返回该节点；否则继续遍历下一个节点。
4. 如果遍历完整个链表仍未找到对应的节点，则返回NULL，表示未找到。
链表的修改操作可以修改链表中的一个节点的数据值。
具体步骤如下：1. 找到要修改的节点。
2. 将该节点的数据域修改为新的数据值。
通过上述的增删查改操作，我们可以实现对链表中数据的灵活操作。
链表可以动态地插入和删除节点，而不需要像数组那样需要提前定义大小。
链表的查找和修改操作的时间复杂度为O(n)，其中n为链表的长度，而插入和删除操作的时间复杂度为O(1)，即常数时间。
在实际应用中，链表常用于需要频繁进行插入和删除操作的场景，比如实现队列、栈、链表等数据结构。
链表也可以与其他数据结构相结合，例如与哈希表结合实现LRU缓存淘汰算法。
C语言链表的增删查改
C语⾔链表的增删查改⼩经验：在VS2017中，使⽤while（scanf（“%d”,&i）!= NULL）{......}时，结束输⼊需要输⼊三次ctrl+z+空格func.h#include <stdlib.h>#include <string.h>typedef struct student {int number;struct student* pnext;}stu, *pstu;void list_print(pstu);//打印void list_head_insert(pstu*,pstu*,int);//头插法void list_tail_insert(pstu*, pstu*, int);//尾插法void list_sort_insert(pstu*, pstu*, int);//有序插⼊void list_delete(pstu*, pstu*, int);//节点删除func.c#include "func.h"void list_head_insert(pstu* pphead, pstu* pptail, int i){//头插法pstu pnew;pnew = (pstu)malloc(sizeof(stu));//申请空间memset(pnew,0,sizeof(stu));//初始化pnew->number = i;if (*pphead == NULL) {//链表为空，新节点既是头指针，⼜是尾指针*pphead = pnew;*pptail = pnew;}else {pnew->pnext = *pphead;//原有的链表头作为新节点的pnext*pphead = pnew;//新节点作为节点头}}void list_tail_insert(pstu* pphead, pstu* pptail, int i){//尾插法实现pstu pnew;pnew = (pstu)calloc(1, sizeof(stu));//calloc会进⾏空间初始化pnew->number = i;if (*pptail == NULL) {*pphead = pnew;*pptail = pnew;}else{(*pptail)->pnext = pnew;//新节点变成原有尾节点的pnext*pptail = pnew;//新节点变成尾节点}}void list_sort_insert(pstu* pphead, pstu* pptail, int i){//有序插⼊实现pstu pcur,ppre;//游标pcur = *pphead;ppre = *pphead;pstu pnew;pnew = (pstu)calloc(1, sizeof(stu));//calloc会进⾏空间初始化pnew->number = i;if (*pptail == NULL) {//链表为空*pphead = pnew;*pptail = pnew;}else if (i<(*pphead)->number)//⼩于头结点，类似头插法{pnew->pnext = *pphead;//原有的链表头作为新节点的pnext*pphead = pnew;//新节点作为节点头}else{while (pcur!=NULL){//插⼊中间if (i<pcur->number){ppre->pnext = pnew;pnew->pnext = pcur;break;}ppre = pcur;pcur = pcur->pnext;}if (pcur == NULL){//pcur为null，说明插⼊尾节点(*pptail)->pnext = pnew;*pptail = pnew;}}}void list_delete(pstu* pphead, pstu* pptail, int d) {//删除实现pstu ppre = *pphead, pcur = *pphead;if (*pphead == NULL) //链表为空{printf("List is empty\n");return;}else if(pcur->number==d)//头结点删除{*pphead = pcur->pnext;if (*pphead == NULL) {//删除节点后，链表为空 *pptail = NULL;}free(pcur);}else//删除中间和尾部{while (pcur != NULL){if (pcur->number == d){ppre->pnext = pcur->pnext;break;}ppre = pcur;pcur = pcur->pnext;}if (pcur==*pptail) //删除的是尾节点{*pptail = ppre;}if (pcur == NULL) //未找到节点{printf("This node is not in list\n");}else{free(pcur);}}}void list_print(pstu phead) {while (phead != NULL){printf("%3d", phead->number);phead = phead->pnext;}printf("\n");}main.c#include "func.h"int main() {pstu phead = NULL;pstu ptail = NULL;int i;while(scanf("%d",&i)!=EOF){//list_head_insert(&phead, &ptail,i);//头插法 //list_tail_insert(&phead, &ptail, i);//尾插法list_sort_insert(&phead, &ptail, i);//有序插⼊ }list_print(phead);while (scanf("%d", &i) != EOF) {list_delete(&phead, &ptail, i); list_print(phead);}system("pause");}。
单链表插入和删除节点的代码
单链表插入和删除节点的代码好的，以下是单链表插入和删除节点的简单示例代码，使用C语言编写：```c#include<stdio.h>#include<stdlib.h>//定义链表节点结构struct Node{int data;struct Node*next;};//插入节点void insertNode(struct Node**head,int newData){//创建新节点struct Node*newNode=(struct Node*)malloc(sizeof(struct Node)); newNode->data=newData;newNode->next=*head;//更新头指针*head=newNode;}//删除节点void deleteNode(struct Node**head,int key){//暂存头节点struct Node*temp=*head;struct Node*prev=NULL;//如果头节点包含要删除的值if(temp!=NULL&&temp->data==key){*head=temp->next;//更改头指针free(temp);//释放原头节点return;}//查找要删除的节点，同时记录前一个节点while(temp!=NULL&&temp->data!=key){ prev=temp;temp=temp->next;}//如果未找到要删除的节点if(temp==NULL){printf("未找到值为%d的节点\n",key); return;}//调整指针，删除节点prev->next=temp->next;free(temp);}//打印链表void printList(struct Node*node){while(node!=NULL){printf("%d",node->data);node=node->next;}printf("\n");}//主函数int main(){struct Node*head=NULL;//插入节点insertNode(&head,1);insertNode(&head,2);insertNode(&head,3);insertNode(&head,4);printf("初始链表：\n");printList(head);//删除节点deleteNode(&head,3);printf("删除节点后的链表：\n");printList(head);return0;}```这段代码创建了一个简单的单链表，包括插入和删除节点的功能。
《如何使用C语言函数实现表格数据增删改？》
《如何使用C语言函数实现表格数据增删改？》
在C语言中，要实现表格数据增删改，可以使用函数。
函数
提供了一种便捷的方法来实现对表格中数据的增删改操作。
下面就介绍如何在C语言中使用函数实现表格数据增删改功能：
首先，它是必要的来定义需要被操作的数据结构，及其中存储的各个字段。
定义表格中字段的类型，使用struct关键字，该
结构体可以包含普通变量或者结构体变量，这取决于您的需要。
然后，实现增删改的函数，例如在条件允许的情况下增加新的表格元素，或者删除已有的表格元素，还有修改已有的表格元素。
这取决于您定义的数据结构的大小及特性。
实现这些函数时需要考虑到各个函数之间的关系，以确保函数的正确性。
最后，使用函数将定义好的数据结构和基本操作功能结合起来，实现对表格数据的增删改操作。
这可以通过调用函数指针来实现，使用函数指针就可以通过传递不同的参数实现某个函数的不同操作，从而实现表格数据的增删改功能。
借助函数，C语言可以很容易地实现对表格数据的增删改操作。
函数提供了一种便捷的实现此类功能的方法，从而使得开发人员可以使用函数快速、准确地实现对表格数据的增删改操作。
C语言链表结构（2）——单链表的增删改查
C语⾔链表结构（2）——单链表的增删改查单向链表的增删改查：1. 设计链表节点由于链表节点需要数据域以及指针域(存放着不同类型的数据)，所以将每⼀个节点设计成⼀个结构体。
结构体模型：struct data{ /* 数据域 */ ... /* 指针域 */ ...};例⼦1：每⼀个节点都存放着⼀个整型数据，那么结构体如何定义？struct list_node{ int a; //数据域 struct list_node *next; //指针域};2. 初始化链表 -> 搞⼀个链表头struct list_node *init_list_head(struct list_node *head) //head = NULL{ //为头节点申请空间 head = (struct list_node *)malloc(sizeof(struct list_node)); if(head == NULL) printf("head malloc error!\n"); //为头节点的指针域赋值 head->next = NULL; return head;}3. 尾插数据 -> 在链表末尾增加⼀个新的节点int tail_add_list(struct list_node *head,int num){ //为新节点申请空间 struct list_node *Node = NULL; Node = (struct list_node *)malloc(sizoef(struct list_node)); //为新节点赋值 Node->a = num; Node->next = NULL; //寻找最后⼀个节点，并尾插 struct list_node *p = NULL; for(p=head;p->next!=NULL;p=p->next); //从循环出来时，p->next=NULL，也就是说，p指向最后⼀个节点！ p->next = Node; return 0;}4. 遍历链表int show_list_node(struct list_node *head){ struct list_node *p = NULL; for(p=head->next;p!=NULL;p=p->next) { printf("%d\n",p->a); } return 0;}5. 头插 -> 在头节点之后插⼊⼀个新的节点。
C语言链表实现增删改查
} else {
for (int i=1;i<n-1;i++) {
p2=p2->next; } p2->next=p1->next; } return 0; } p1=p1->next; n++; } printf("Input Error!\n"); return 0; } int main() { struct stu *head=0,*s=0; //创建空 head=creat(s); //插入 insert(head); show(head); //修改 modify(head); show(head); //删除 del(head); show(head); return 0; }
printf("%ld\t%.2f\n",p1->id,p1->score); p1=p1->next; } printf("---------------\n"); } void insert(struct stu *head) { stu *p1; int n; printf("Enter the students number:\n"); scanf("%d",&n); for (int i=0;i<n;i++) {
#include <stdio.h> #include <stdlib.h> #define NULL 0 struct stu {
long id; float score; struct stu *next; }; void judge(long num) {
单链表以及单链表的建立、清空、插入、删除、查找、修改等运算
int size=sizeof(struct lian_node); struct lian_node *llist,*tail,*p; llist=tail=NULL; printf("请输入链表长度 n="); scanf("%d",&n); printf("请输入链表的各个值:"); for(i=1;i<=n;i++){
return llist;
}
/*查找值*/ void SearchDoc_num(struct lian_node*llist,int num) { struct lian_node *ptr; if(llist==NULL){
printf("\n 无结果！\n"); return; } for(ptr=llist;ptr;ptr=ptr->link){ if(ptr->num==num){ printf("输出序号为 : %d\n\n",ptr->n); break; }
#include<stdio.h> #include<stdlib.h> #include<string.h>
struct lian_node{ int n; int num; struct lian_node*link; };
/*单个链表节点的结构体*/
struct lian_node*Create_Lian_Doc(); 一个只有 6 个结点的单链表，并输出该链表*/ void SearchDoc_n(struct lian_node*link,int n); 序号为 n 的结点，并输出*/ void SearchDoc_num(struct lian_node*link,int num); 为 x 的结点，并输出*/ void InsertDoc(struct lian_node*llist,struct lian_node*p,int n); 和值 x。在序号为 n 的结点后插入 x，并输出该链表*/ void DeleteDoc(struct lian_node*llist,int n); 号 n，删除序号为 n 的结点，并输出该链表*/ void Print_Lian_Doc(struct lian_node*llist);
C语言实现的链表的增删查找
C语⾔实现的链表的增删查找1 #include <stdio.h>2 #include<malloc.h>34 typedef struct Node5 {6int val;7struct Node * pNext;8 }Node,* pNode;910 pNode creat_list();11void trevel_list(pNode);12void sort_list(pNode);13void insert_list(pNode,int,int);14int length_list(pNode);15int delete_list(pNode,int);16void search_list(pNode,int);1718void main()19 {20 pNode pHead = creat_list();21 printf("输⼊后信息如下：\n");22 trevel_list(pHead);23 printf("\n排序之后如下：\n");24 sort_list(pHead);25 trevel_list(pHead);26 printf("\n链表长度位：\n");27 printf("%d",length_list(pHead));28 printf("\n删除第三个数字为：\n");29 printf("%d",delete_list(pHead,3));30 printf("\n删除之后如下：\n");31 trevel_list(pHead);32 printf("\n删除之后链表长度为：\n");33 printf("%d",length_list(pHead));34 printf("\n在第5个位置插⼊⼀个节点\n");35 insert_list(pHead,5,15);36 printf("\n插⼊之后如下：\n");37 trevel_list(pHead);38 search_list(pHead,15);39 }4041 pNode creat_list()42 {43 pNode pHead,pTail,pNew;44int len,i;45 scanf("%d",&len);46 pHead = (pNode)malloc(sizeof(Node));47 pTail = pHead;48 pTail->pNext = NULL;49for (i = 0; i < len; i++)50 {51 pNew = (pNode)malloc(sizeof(Node));52 scanf("%d",&pNew->val);53 pTail->pNext=pNew;54 pTail = pNew;55 pTail->pNext = NULL;56 }57return pHead;58 }5960void trevel_list(pNode pHead)61 {62 pNode t = pHead->pNext;63while(t != NULL)64 {65 printf("%d ",t->val);66 t = t->pNext;67 }6970void sort_list(pNode pHead)71 {72 pNode p,q;73int i,j,temp,len;74 len=length_list(pHead);75for(i=0,p=pHead->pNext;i<len-1;i++,p=p->pNext) 76 {77for(j=i+1,q=p->pNext;j<len;j++,q=q->pNext) 78 {79if(p->val > q->val)80 {81 temp = p->val;82 p->val = q->val;83 q->val = temp;84 }85 }86 }87 }8889void insert_list(pNode pHead,int pos,int val)90 {91 pNode p,t;92int len = length_list(pHead);93if(pos>len)94 printf("插⼊失败\n");95else96 {97 p = pHead->pNext;98 pos--;99while(pos--)100 {101 p = p->pNext;102 }103 t = (pNode)malloc(sizeof(Node));104 t->val = val;105 t->pNext = p->pNext;106 p->pNext = t;107 }108 }109110int delete_list(pNode pHead,int pos)111 {112int i,val,len;113 pNode t,p=pHead;114 len = length_list(pHead);115if(pos>len)116 printf("删除失败\n");117else118 { pos--;119while(pos--)120 {121 p=p->pNext;122 }123 t = p->pNext;124 p->pNext = t->pNext;125 val = t->val;126free(t);127 }128return val;129 }130131int length_list(pNode pHead)132 {133int len = 0;134 pNode t = pHead->pNext;135while(t != NULL)136 {137 len++;138 t = t->pNext;140return len;141 }142143void search_list(pNode pHead, int val)144 {145 pNode p = pHead->pNext;146int n=0;147while(p!=NULL)148 {149 n++;150if(p->val == val)151 printf("\n链表第%d节点有%d这个值\n",n, val); 152 p=p->pNext;153 }154if(!n)155 printf("未找到\n");156 }。
C语言如何建立链表并实现增删查改详解
C语⾔如何建⽴链表并实现增删查改详解前⾔以下是本⼈完成的⼀个C语⾔建⽴链表并进⾏增删查改操作的程序，为⽅便学习，本⼈将整个程序分为头⽂件和主函数两部分：1.头⽂件(函数部分)(1)初始化函数#include <stdio.h>#include <stdlib.h>typedef struct {int *head;int length;int capacity;} Toslist; //Toslist类型//初始化顺序表Toslist initSeqlist() {Toslist list;list.length = 0;list.capacity = 5;list.head = (int *)malloc(10 * sizeof(int));if (!list.head){printf("初始化失败！\n");exit(0);}return list;}（2）打印函数//打印顺序表void displayList(Toslist list) {for (int i = 0; i < list.length; i++) {printf("%d ", list.head[i]);}printf("\n");}(3)插⼊函数//插⼊元素Toslist add(Toslist list, int elem, int pos) {if (list.length == list.capacity) {int *temp = (int *)realloc(list.head, (list.capacity + 1) * sizeof(int));//判断空间是否⾜够，不够就另建链表//不直接⽤head⽽引⼊temp的作⽤：防⽌空间分配失败导致head失去原来的链表if (!temp) {list.head = temp;list.capacity += 1;}}//插⼊位置及以后的元素后移for (int i = list.length - 1; i >= pos; i--) {list.head[i + 1] = list.head[i];}list.head[pos] = elem;list.length ++;return list;if (pos > list.length || pos < 0)printf("插⼊位置错误！\n");return list;}（4）删除函数//删除元素Toslist delete(Toslist list, int pos) {for (int i = pos; i < list.length - 1; i++) {list.head[i] = list.head[i + 1];}list.length--;return list;if (pos < 0 || pos > list.length) {printf("删除位置有误！\n");return list;}}（5）查找函数//查int search(Toslist list, int elem) { //elem是查找的元素//顺序查找for (int i = 0; i < list.length; i++) {if (elem == list.head[i]) {return i;}}return 0;}(6)替换函数//改Toslist modify(Toslist list, int elem, int val) { //val是要替换它的元素int pos = search(list, elem); //获取要替换元素的位置list.head[pos] = val;return list;}2.主函数int main() {Toslist list = initSeqlist();int Addpos = -1, Addnum, Delpos, Serachnum,Modifynum;printf("请输⼊5个整数元素\n");for (int i = 0; i < 5; i++) {scanf("%d", &list.head[i]);list.length++;}printf("顺序表中的元素有：\n");displayList(list);//插⼊元素printf("要在哪个元素后插⼊元素？\n");while (Addpos < 0 || Addpos > list.length) {scanf("%d", &Addpos);if (Addpos < 0 || Addpos > list.length)printf("请输⼊正确的位置！\n");};printf("请输⼊需要插⼊的元素：\n"); scanf("%d", &Addnum);printf("在顺序表的第%d个元素后插⼊元素%d得到\n", Addpos, Addnum); list = add(list, Addnum, Addpos);displayList(list);//删除元素printf("要删除顺序表下标顺序中哪个元素？\n"); scanf("%d", &Delpos); printf("删除后得到：\n");list = delete(list, Delpos);displayList(list);//查找printf("请输⼊需要查找的元素\n"); scanf("%d", &Serachnum);int pos = search(list, Serachnum);if(pos)printf("元素%d的位置为第%d个\n", Serachnum, pos+1);if(!pos){printf("表中⽆该元素\n");}//修改printf("请输⼊需要修改的元素：\n");scanf("%d",&Serachnum);printf("请输⼊要替换的数：\n");scanf("%d",&Modifynum);printf("将%d修改为%d得到：\n", Serachnum, Modifynum);list = modify(list, Serachnum, Modifynum);displayList(list);free(list.head);list.head = NULL;return 0;}以上程序本⼈已调试完毕，若程序有繁杂之处，欢迎批评指正！总结以上就是这篇⽂章的全部内容了，希望本⽂的内容对⼤家的学习或者⼯作具有⼀定的参考学习价值，谢谢⼤家对的⽀持。
单链表创建、删除、查找、插入之C语言实现
单链表创建、删除、查找、插⼊之C语⾔实现本⽂将详细的介绍C语⾔单链表的创建、删除、查找、插⼊以及输出功能⼀、创建#include<stdio.h>#include<stdlib.h>typedef int ElemType;/*结构体部分*/typedef struct Node{ElemType data; //数值域struct Node *next; //指针域}Linklist;Linklist *InitList(Linklist *L) //初始化单链表{L = (Linklist *) malloc(sizeof(Linklist));L->next = NULL;return L;}Linklist *CreateList(int n){/*通过输⼊n个数据，创建⼀个单链表*/int x,i;Linklist *L,*r,*p;L = InitList(L); //构造头结点r = L;printf("input %d value: ",n);for(i=0;i<n;i++){scanf("%d",&x);p = (Linklist *)malloc(sizeof(Linklist));p -> data = x;p -> next = NULL;r->next = p;r = r->next; //指针r始终指向链表中末数据元素所在位置}return L;}⼆、插⼊int InsItem1(Linklist *L,ElemType item,int x) /*给定的序号来插⼊*/{int i = 1;Linklist *p,*t;p = L;t = (Linklist *)malloc(sizeof(Linklist));t ->data = item;if(L->next==NULL){ /*若L为空表且要求将新结点插⼊到第0个位置*/if(x==1){L->next=t;t->next=NULL;return1;}/*若L为空表且要求将新结点插⼊到第⾮0个位置，则操作失败*/else{printf("wrong!\n");return0;}}while(p->next!=NULL&&i<x)/*查找第i个节点*/{p = p->next;i++;}if(p->next==NULL&&i<x)/*在表中不存在插⼊位置i ，找不到，则插⼊操作失败*/{printf("The node %d is not exist\n",x);return0;}elset->next = p->next;p->next = t;return1;}}int InsItem2(Linklist *L,ElemType item,ElemType k) /*插⼊给定值在链表中的位置*/ {Linklist *q,*p,*t;t = (Linklist *)malloc(sizeof(Linklist));t->data = item;if(L->next==NULL){printf("The linklist is empty\n");return0;}else{q = L;p = L->next;while(p->next!=NULL)/*查找值为k的结点*/{if(p->data!=k){q = p;p = p->next;}elsebreak;}if(p==NULL)/*如p= =NULL，则没有值为k的结点，插⼊操作失败*/{printf("The node %d is not exist\n",k);return0;}else{q->next = t;t->next = p;return1;}}}三、删除int DelItem(Linklist *L,int x)//在单链表中删除数据元素{int i = 1;Linklist *p,*q;p = L;if(L->next==NULL) /*L为空表，⽆结点可删除*/{printf("The linklist is empty!\n");return0;}while(p->next!=NULL&&i<x){p = p->next;i++;}if(p->next==NULL)/*若没有第i个结点，则删除操作失败*/{printf("The node %d is not exist\n",x);return0;}else{q = p->next;p->next = p->next->next;free(q);return1;}}四、查找int LocItem(Linklist *L,ElemType x)//查找给定值的结点位置Linklist *p,*q,*r;int i = 1;if(L->next==NULL){printf("The linklist is empty\n");return0;}else{p = L->next;while(p!=NULL){if(p->data!=x){i++;p = p->next;}elsebreak;}if(p==NULL)/*如p= =NULL，则没有值为item的结点，删除操作失败*/ {printf("The node %d is not exist\n",x);return0;}/*若找到该节点返回该节点的位置*/elsereturn i;}}五、输出void output(Linklist *L) //输出{Linklist *p;p = L->next;printf("output element: \n");for(;p!=NULL;p=p->next){printf(" %d ",p->data);}printf("\n");}六、主函数部分int main(){ElemType x = 5;Linklist *L;L = CreateList(x);output(L);InsItem1(L,3,2);output(L);InsItem1(L,3,4);output(L);DelItem(L,3);output(L);printf("3的位置是: %d",LocItem(L,3));}。
c++单链表冒泡排序（交换结点），链表增删改查，运算符重载
c++单链表冒泡排序（交换结点），链表增删改查，运算符重载#include <iostream>#include <stdlib.h>#include <time.h>#include <fstream>#include <string>using namespace std;//类class List{public://构造器初始化，⽣成头节点List(){head = new Node;head->next = NULL;}//成员函数void createList();void insertList(int data);void travelList(int chance);void input();int addNode();void deleteData(int addNum);void ifClear();void clearList();//重载下标int operator[](int idx);//重载+friend List operator+(List& List_1, List& List_2);//重载-friend List operator-(List& List_1, List& List_2);//重载<<friend ostream& operator<<(ostream& os, List& list);//重载>>friend istream& operator>>(istream& is, List& list);//冒泡排序void bubbleSortList(List& list);private://数据成员struct Node{int data; //数据域struct Node* next; //指针域} *head;//头指针int num;//链表元素个数};//头插法⽣成节点void List::insertList(int data){Node* cur = new Node;//插⼊数据cur->data = data;//插⼊节点cur->next = head->next;head->next = cur;}//调⽤insertList输⼊数据，⽣成链表void List::input(){cout << "请输⼊链表数量长度：";cin >> num;srand(time(NULL));for (int i = 0; i < num; i++){insertList(rand() % 100);}}//任意位置插⼊节点int List::addNode()int d, idx;cout << "请输⼊你要插⼊的节点数据:";cin >> d;cout << "请输⼊你要插⼊的节点位置: ";cin >> idx;Node* tp = NULL;Node* link = head;//寻找插⼊位置if (idx<1 || idx>num + 1){cout << "操作⾮法" << endl;return num;}else{for (int i = 0; i < idx; i++){tp = link;link = link->next;}Node* cur = new Node;tp->next = cur;cur->data = d;cur->next = link;travelList(1);return ++num;}}ofstream mycout1("D:/text1.txt");ofstream mycout2("D:/text2.txt");//遍历链表并将数据存⼊⽂件void List::travelList(int chance){Node* temp = head->next; //防⽌头指针地址改变while (temp != NULL){cout << temp->data << " ";if (chance == 1)mycout1 << temp->data << " ";elsemycout2 << temp->data << " ";temp = temp->next;}cout << endl;}//删除节点void List::deleteData(int addNum){int i, j = 0;cout << "请问您要删除第⼏个数据: ";cin >> i;Node* tp = NULL;Node* link = head;//link为删除节点后⾯的⼀个节点，temp为删除节点 if (addNum < i || i < 0)cout << "操作⾮法！！" << endl;else{while (link->next){tp = link->next; //第⼀个节点j++;if (i == j) //找的删除的节点{link->next = tp->next;delete tp;break;}link = link->next;}travelList(1);}}//清空链表void List::clearList()Node* tp = NULL;Node* ph = head->next;while (head->next){tp = ph;ph = ph->next;delete tp;head->next = ph;}travelList(1);cout << endl;}//询问是否清空void List::ifClear(){string i;if (!head->next){cout << "链表已清空" << endl; }else{cout << "是否清空链表（是/否）：";cin >> i;if (i == "是"){clearList();cout << "链表清空完成" << endl; }elsecout << "链表未清空" << endl; }}//冒泡排序void List::bubbleSortList(List& list){//求list链表长度lenint len=0;//临时指针pheadNode* phead = list.head->next;while (phead){len++;phead = phead->next;}//冒泡排序for (int i=0;i<len-1; i++){//phead指向头结点phead = list.head;//ph1指向⾸元结点Node* ph1 = phead->next;//ph2指向⾸元结点的后继Node* ph2 = ph1->next;//进⼊循环冒出最⼤的数for (int j = 0; j < len - 1 - i; j++){//如果前⾯的值⼤于后⾯的值则交换if (ph1->data > ph2->data){phead->next = ph2;ph1->next = ph2->next;ph2->next = ph1;//结点交换后，ph1与ph2位置颠倒回来 Node* temp = ph1;ph1 = ph2;ph2 = temp;}//如果不需要交换,三指针移动phead = phead->next;ph1 = ph1->next;ph2 = ph2->next;}//打印结点数据phead = list.head->next;while (phead){cout << phead->data << " ";phead = phead->next;}cout << endl;}//下标重载int List::operator[](int idx){//临时指针temp，为了防⽌头指针改变Node* temp = head;//如果下标⼩于链表长度进⾏取值if (idx < num){for (int i = 0; i < idx; i++){temp = temp->next;}}return temp->data;}//+ 重载List operator +(List & List_1, List & List_2){//由链表1⽣成链表3List List_3;//⽣成临时指针temp_1List::Node* temp_1 = List_1.head->next;//把链表1的值给链表3while (temp_1){List_3.insertList(temp_1->data);temp_1 = temp_1->next;}//⽣成临时指针temp_2List::Node* temp_2 = List_2.head->next;//把链表2的值给链表3while (temp_2){List_3.insertList(temp_2->data);temp_2 = temp_2->next;}return List_3;}//- 重载List operator -(List & List_1, List & List_2){//⽣成链表4List List_4;//⽣成临时指针temp_1,temp_2List::Node* temp_1 = List_1.head->next;List::Node* temp_2 = List_2.head->next;//flag为1链表2有链表1的值，为0则没有int flag = 0;//⽐较链表⼀和链表⼆，不等就将数据存⼊List_4 while (temp_1){//临时指针temp_2回溯temp_2 = List_2.head->next;while (temp_2){//判断是否有相同值if (temp_1->data == temp_2->data){flag = 1;break;}//指针移动temp_2 = temp_2->next;}//没有相同值List_4则插⼊数据if (!flag){List_4.insertList(temp_1->data);//指针移动,开始下⼀轮对⽐temp_1 = temp_1->next;flag = 0;}return List_4;}//重载<<ostream& operator<<(ostream & os, List & list) {list.bubbleSortList(list);return os;}//重载>>istream &operator>>(istream & is, List & list) {int size, i=0;cout << "(输⼊链表长度):";is >> size;//当i<size时录⼊数据while (i < size){int data;is >> data;//插⼊数据list.insertList(data);i++;}return is;}int main(){//初始化，⽣成List_1List List_1;//输⼊链表长度List_1.input();//遍历链表，并存⼊text1⽂件List_1.travelList(1);//添加节点并返回总结点数int addNum = List_1.addNode();//删除节点List_1.deleteData(addNum);//初始化，⽣成List_2List List_2;//输⼊链表长度List_2.input();//遍历链表，并存⼊text2⽂件List_2.travelList(2);//重载下标cout << "取链表2的第⼆个元素：";cout << List_2[2]<<endl;//重载+List List_3;List_3 = List_1 + List_2;cout << "两链表+为：";List_3.bubbleSortList(List_3);//重载-List List_4;List_4 = List_1 - List_2;cout << "两链表-为：";List_4.bubbleSortList(List_4);//重载<<cout << "cout<<List_4：";cout << List_4 << endl;//重载>>List List_5;cout << "cin>>List_5";cin >> List_5;cout << "链表List_5: " << List_5;//询问是否清空链表1List_1.ifClear();//关闭打开的⽂件mycout1.close();mycout2.close();return 0;}⽤类创建单链表时，可以将结构体封装为私有成员，在构造函数中初始化链表极为⽅便；链表的删除操作需要先进⾏遍历，并且遍历途中不能随意改变头结点的位置，所以在进⾏链表的操作时，皆需要临时变量防⽌头指针改变；除此之外，在进⾏冒泡排序时，需要画图理清逻辑，虽然⽐较过后，链表的连接⽅式改变了，但是ph1与ph2位置颠倒，需要互换回来，使下⼀次⽐较正常运⾏；运算符“+”号重载时，如果直接由链表1⽣成链表3，在进⾏减操作时，会发现链表1随链表3的改变⽽改变了，导致在进⾏“-”操作时出错，后在“+”操作时，对链表3进⾏逐⼀赋值，问题得到解决。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
scanf("%d",&a);
insertsl(p,b,a);
printf("\n你还要插入其他元素吗？请选择(Y:是|N：否)：\n");
c=getch();
}
else
{
s=p->next;
p->next=s->next;
free(s);
printf("在位置%d成功删除%d\n",j,i);
}
}
node *lianjie(node *L1,node *34;,c);
if(c!='Y'&& c!='y')
{
break;
}
}
print(p);
printf("\n你想要删除的元素是:\n");
scanf("%d",&a);
p->next=NULL;
return h;
}
void insertsl(node *head, int k, int i)
{
int j;
node *p, *t;
p=head;
j=0;
while ( p&&j<k-1 )
t->next=p->next;
p->next=t;
}
void deletesl(node *h,int i)
{
node *p,*s,*q;
int j=1;
p=h;
while(p->next!=NULL)
{
q=p->next;
{
p = p->next;
j++;
}
if (!p||j>k-1)
{
printf("插入位置不对。\n");
}
t=(node *)malloc (sizeof (node));
t->data=i;
{
node *p1, *p2;
p1=L1;
p2=p1->next;
while(p2->next!=NULL)
{
p2=p2->next;
}
p2->next=L2->next;
return p1;
}
void hebing (node *L)
if(q->data==i)
break;
p=p->next;
j++;
}
if(p->next==NULL)
{
printf("找不到你要删除的元素\n");
return;
#include <stdio.h>
#include <malloc.h>
typedef struct node
{
int data;
struct node *next;
}node;
node *head;
int k;
node * creates()
{
node *p,*s,*h;
{
node *s,*t,*r;
s=L->next;
while(s)
{
t=s;
r=s->next;
while(t->next)
{
if(s->data==r->data)
}
int main()
{
node *p,*q,*r,*s;
int a,b;
char c;
p=creates();
while(1)
{
printf("\n请输入你要插入的元素的位置:\n");
scanf("%d",&b);
int j=1,x, n;
p=h=(node*)malloc(sizeof(node));
h->next=NULL;
printf("请输入链表长度：\n");
scanf("%d",&n);
printf("请输入%d 个数字创建链表：\n",n);
deletesl(p,a);
print(p);
q=creates();
r=creates();
s= lianjie(q,r);
hebing(s);
print(s);
printf("谢谢使用!");
return 0;
{
t->next=r->next;
r=t->next;
}
else
{
t=t->next;
r=r->next;
}
}
s=s->next;
}
}
void print(node *h)
{
printf("\n链表中的元素为");
node *s;
s=h->next;
if(s!=NULL)
{
while(s!=NULL)
{
printf(" %d ",s->data);
s=s->next;
}
}
else
{
printf("这是一个空表%d");
}
printf("\n");
}
while(j<=n)
{
scanf("%d",&x);
s=(node*)malloc(sizeof(node));
s->data=x;
p->next=s;
p=s;
j++;
}