对链表进行创建、结点的删除和插入操作

最新推荐文章于 2022-07-15 23:06:13 发布
最新推荐文章于 2022-07-15 23:06:13 发布
阅读量500 收藏 2
点赞数
分类专栏： ★C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyzsir/article/details/79116608
版权

C：

/*链表注意的问题：每个函数是独立的，而且完成一个函数需要返回头指针，说明已完成此功能，以便下一个功能使用*/
#include<stdio.h>
#include<stdlib.h>
struct Node
{
    int num;
    struct Node*next;
};
int n;
int main()
{
    struct Node *creat();                                         //创建链表
    struct Node *del(struct Node * ,int);                         //删除结点
    struct Node *insert(struct Node *, struct Node *);            //插入节点
    void print(struct Node *);                                    //输出
    struct Node*head,stu;
    int del_num;
    printf("Input datas:\n");
    head=creat();             
    printf("Input the data that you want to delete:");
    scanf("%d",&del_num);                                         //输入想要删除的数据
    head=del(head,del_num);
    print(head);                                                  //输出删除之后的数据               
    printf("Input the data you want to insert:");     
    scanf("%d",&stu.num);                                         //输入想要插入的数据
    head=insert(head,&stu);
    print(head);                                                  //输出插入之后的数据
    return 0;
}
struct Node*creat()
{
    struct Node*head;
    struct Node *p1,*p2;
    n=0;                                                           //计算数据个数
    p1=p2=(struct Node*)malloc(sizeof(struct Node));               //先给p1和p2一个空间
    scanf("%d",&p1->num);                                          //先向第一个结点输入数据，让它进入循环
    head=NULL;
    while(p1->num!=0)                                              //输入0结束数据输入
    {
        n=n+1;
        if(n==1)head=p1;                                           //为第一个结点时，将头指针指向第一个结点
        else p2->next=p1;                                          //不是第一个结点时，前一个结点的next指向下一个结点
        p2=p1;                                                     //p2指向新结点
        p1=(struct Node*)malloc(sizeof(struct Node));              //p1建立新结点
        scanf("%d",&p1->num);                                      //向新结点里加入数据
    }
    p2->next=NULL;                                                 //循环结束时，将最后的一个结点的next赋为空
    return(head);                                                  //返回头指针，链表创建结束
}
struct Node *del(struct Node *head,int num)
{
    struct Node*p1,*p2;
    if(head==NULL)                                                //如果头结点为空
    {
        printf("\nlist NULL!\n");                                 //这是一个空表
        return(head);                                             //返回头指针
    }
    p1=head;                                                      //p1指向头指针指向的内容
    while(num!=p1->num&&p1->next!=NULL)                           //循环条件是p1指向的数据不是要删除的而且p1的next不是空 ，遍历
    {
        p2=p1;                                                  //p2指向p1指向的内容
        p1=p1->next;                                              //p1指向p1的next，也就是下一个结点
    }
    if(num==p1->num)                                            //如果找到了想要删除的数据
    {
        if(p1==head)head=p1->next;                             //如果删除的是头，那么头指向下一个结点
        else p2->next=p1->next;                                 //否则删除此节点，让p2指向被删除结点的next的指向
        printf("delete:%d\n",num);
        n=n-1;
    }
    else printf("%d Not been found!\n",num);                  //遍历结束没找到   
    return(head);                                             //返回头指针，删除结束
}
struct Node*insert(struct Node *head, struct Node *stud)
{
    struct Node *p0,*p1,*p2;
    p1=head;                                                     //p1指向头结点
    p0=stud;                                                      //p0指向传递过来的指针               
    if(head==NULL)                                               //如果是空表 ，此时插入完只有一个结点
    {
        head=p0;                                                  //头指针指向p0
        p0->next=NULL;                                           //唯一结点的next为空
    } 
    else
    {
        while((p0->num>p1->num)&&(p1->next!=NULL))              //遍历，如果p0的数据大于p1的数据而且p1的next不是空
        {
            p2=p1;                                               //p2指向p1   
            p1=p1->next;                                        //p1指向p1的next
        }         
        if(p0->num<=p1->num)                                 //比较两个数，找到一个第一次小于的数插入 ，这个功能只会向头或尾插入
        {
            if(head==p1) head=p0;                             //如果是头结点，head指向p0
            else p2->next=p0;                                  //否则p2的next指向p0，连接过程
            p0->next=p1;                                       //p0的next指向p1
        }
        else
        {
            p1->next=p0;
            p0->next=NULL;
        }
    }
     n=n+1;                 
     return(head);                                            //返回头指针，插入结束
}
void print(struct Node *head)
{
    struct Node *p;
    printf("\nThese %d data are:\n",n); 
    p=head;
    if(head!=NULL)
    do
    {
        printf("%d\n",p->num);
        p=p->next;
    }while(p!=NULL);
}

C++：

/*链表注意的问题：每个函数是独立的，而且完成一个函数需要返回头指针，说明已完成此功能，以便下一个功能使用*/
#include<iostream>
#include<cstdlib>
using namespace std;
struct Node
{
    int num;
    Node *next;
};
int main()
{
    int data;
    Node stu1;
    Node *head,stu;
    Node *create();                        //创建链表 
    Node *Delete(Node *head,int data);     //删除结点 
    Node *insert(Node *head,Node *p);      //插入结点 
    void print(Node *head);                //输出链表 
    void release(Node *head);              //释放链表 

    head=create();
    cout<<"Input the data that you want to delete:";
    cin>>data;
    head=Delete(head,data);
    print(head);

    cout<<"Input the data you want to insert:";
    cin>>stu.num;
    head=insert(head,&stu);
    print(head);

    release(head);
    return 0;
}

Node *create()
{
    Node *head;
    Node *p1,*p2;
    int i;
    cout<<"Input datas:\n";          //输入数据，数据要求不重复，以0为结束标志 
    cin>>i;
    head=NULL; 
    while(i!=0)
    {
        p1=new Node;
        p1->num=i;
        if(head==NULL)              //这是一个空表 
        {
            head=p1;
            p2=p1;
        }
        else
        {
            p2->next=p1;
            p2=p1;
        }
        cin>>i;
    }
    if(head) p2->next=0;
    return head;
} 

Node *Delete(Node *head,int data)
{
    Node *p1,*p2;
    if(head==NULL)            //这是一个空表 
    {
        cout<<"list NULL!"<<endl;
        return NULL;
    } 
    if(head->num==data)     //删除的结点是首结点 
    {
        p2=head;
        head=head->next;
        delete p2;
    }
    else 
    {
        p2=p1=head;
        while(p2->num!=data&&p2->next!=NULL)     //查找要删除的结点 
        {
            p1=p2;
            p2=p2->next;
        }
        if(p2->num==data)                       //删除的中间结点或尾结点 
        {
            p1->next=p2->next;
            delete p2;
        }
        else cout<<"Data not been found!";      //找不到要删除的结点 
    }
    return head;
}

Node *insert(Node *head,Node *p)
{
    Node *p1,*p2;
    if(head==NULL)                     //这是一个空表 
    {
        head=p;
        p->next=0;
        return head;
    }
    if(head->num>=p->num)            //插入的结点作为新链表的首结点 
    {
        p->next=head;
        head=p;
        return head;
    }
    p2=p1=head;             //查找插入位置，使p1和p2指向首结点 
    while(p2->next&&p2->num<p->num)
    {
        p1=p2;
        p2=p2->next;
    }
    if(p2->num<p->num)            //在链表尾部插入结点 
    {
        p2->next=p;
        p->next=NULL;
    }
    else                //在链表中间插入 
    {
        p->next=p2;
        p1->next=p;
    }
    return head;
}

void print(Node *head)
{
    Node *p=head;
    if(p==NULL)
    {
        cout<<"list NULL!"<<endl;
        return ;
    }
    cout<<"These data in list are:"<<endl;
    while(p!=NULL)
    {
        cout<<p->num<<'\t';
        p=p->next;
    }
    cout<<endl;
}

void release(Node *head)
{
    if(head==NULL)
    {
        cout<<"list NULL!"<<endl;
        return ;
    }
    Node *p;
    while(head)
    {
        p=head;
        head=head->next;
        delete p;
    }
    cout<<"Node has been released!"<<endl;
}
yyzsir
关注
专栏目录
单链表的删除操作的实现
weixin_44585204的博客
02-17 1861
建立长度为n的单链表，删除第i个结点之前的结点。 输入 第一行为自然数n，表示链式线性表的长度； 第二行为n个自然数表示链式线性表各元素值； 第三行为指定的删除参数i。 输出 指定删除位置合法时候，输出删除元素后的链式线性表的所有元素，元素之间用一个空格隔开。 输入不合法，输出"error!"。 样例输入 5 1 2 3 4 5 3 样例输出 1 3 4 5 #include&lt;stdio.h...
链表中结点的插入和删除
weixin_48072522的博客
01-12 1517
一、创建Node 二、插入结点 1.中间插入 2.头部插入 3.尾插 三、删除结点 1.中间删除 ①按值删除 ②按位置删除 ③按下标删除 2.头部删除 3.尾删 4.“移形换影”
链表的基础操作总结（链表创建，插入，删除，遍历等等）
[&] () {}
09-14 1963
直接上代码吧，感觉注释还可以，应该可以看的懂。。不懂的话。。 就再看看吧。。。 // 数据结构基础--链表的创建及链表基本操作 #include #include #include typedef struct Node { int data ; // 数据域 struct Node * pNext ; // 指针域 }NODE, *PNODE ; // NODE
链表(创建，插入，删除和打印输出
diaobaoxi6521的博客
10-05 334
/*-----------------------------------------------------------------------------时间:2011年9月28日文件功能:实现了动态建立一个学生信息的链表包括链表的创建、插入、删除、和打印输出学生信息包括姓名和分数本链表是带有头结点的，头结点的内容为空内容-------------------------------...
2.对链表的删除操作
qq_40191710的博客
01-02 222
代码部分：
在链表中插入和删除结点
qq_36237905的博客
10-11 416
#include #include #define N 5 typedef struct node { int data; struct node *next; }sn; sn *createlist(int a[]) { sn *h; sn *p,*q; int i; q=(sn *)malloc(sizeof(sn)); h=q; for(i=0;i { p=
java实现创建链表以及插入节点，查找结点，删除节点等操作
秦怀杂货店
08-31 4055
涉及两个类，一个DATA，一个是CLType 代码如下： class DATA{ String key; String name; int age; } public class CLType { DATA nodedata=new DATA(); CLType nextnode; CLType CLAddEnd(CLType head,DATA
C语言实现带头结点的链表的创建、查找、插入、删除操作
09-04
这种设计方便了链表的操作，尤其是对链表的创建、查找、插入和删除。 1. **链表的创建**： 在C语言中，创建链表首先需要定义一个结构体来表示链表节点，包含数据域`data`和指向下一个节点的指针`next`。创建带头...
双向链表的基本操作-结点插入、结点删除、整表删除、正序遍历、逆序遍历
asfd_4的博客
07-15 1126
第二期 双向链表的基本操作
单链表的基本操作-插入结点、删除结点、新建链表、查找结点位置
asfd_4的博客
03-06 5746
** C语言新手小白的学习笔记-------------目前持续更新中 ** 本人90后电气工程及其自动化大学生，大二开始接触C语言，写过前端，Python但是都不太精通，通过许多认识后明白了自身的许多不足，因此，想通过博客与大家分享我的学习过程和认识，如果有哪位大佬有更好的意见和认识，请你们一定要积极留言，如果有错误的地方，请大家能第一时间帮我指出，谢谢各位了，大家一起进步，每天进步一点点，加油，热爱技术的各位。 第一期 单链表的操作 下面是我根据单链表的结构特点和自己的理解以及借鉴其他博客大佬（MIN
在链表L中删除全部值为e的数据元素
12-11
创建一个链表(有头结点)，指定该链表的大小n，输入链表的n个元素，创建链表，输入要删除的值e，将链表L中所有值为e的元素删除，并输出删除元素后的链表。 仅有一组测试数据 第一行：输入一个整数n表示链表的长度（1<n<1000） 第二行：输入n个整数，整数之间用空格分隔 第三行：输入一个整数e表示要删除值 输出剩余的整数，用空格间隔。
链表中插入和删除结点
weixin_34216107的博客
09-06 377
设指针变量p指向单链表中结点A，若删除单链表中结点A，则需要修改指针的操作序列为（） q=p->next ； p->data=q->data ； p->next=q->next ； free(q) 转载于:https://www.cnblogs.com/fthjane/p/4786292.html...
c++ 实现结构体单链表的 创建 插入 删除等操作
热门推荐
u012746763的专栏
06-12 1万+
#include using namespace std; enum operation{create_List=1,print_List,insert_Node,delete_Node,delete_List,quit};//枚举类型，用于菜单选择结果 struct node //结点结构 { int data ; node * next; }; operation
SWUST数据结构--单链表的删除操作
CasT1R's Blog
03-31 377
#include&lt;cstdio&gt; #include&lt;iostream&gt; #include&lt;cstdlib&gt; using namespace std; typedef struct LNode { int data; struct LNode *next; } LinkList; void InitList(LinkLi...
链表的基本操作：创建、插入、删除
dengquanyan6606的博客
07-27 234
#include<iostream> using namespace std; //链表的定义 struct ListNode { int val; ListNode* next; ListNode(int n) :val(n), next(nullptr) {} }; //链表的打印 void printList(Li...
链表基本操作-删除
weixin_43164504的博客
08-20 205
链表基本操作-删除 题意:删除链表中等于给定值va的所有节点。 示例1 输入:head=[1,2,6,3,4,5,6],va|=6 输出:[1,2,3,4,5 例2 输入:head va|=1 输 示例3 输入:head=[777,7],va=7 输出:[ 分析：在需要删除的链表的头节点之前再加一个节点，统一删除方式 #include <vector> #include <iostream> using namespace std; struct ListNode{ int
有头单链表之完整操作（创建，头/尾/顺序插入，删除，遍历）
weixin_43621608的博客
05-27 166
#include <iostream> using namespace std; struct Node //创建结构体 { int data; Node* next; }; Node* creat_list() { //创建链表头 Node* head = (Node*)malloc(sizeof(Node)); if (head) { head->next = nullptr; } return head; } //从头部插入数据 void insert
单链表的插入、删除、遍历操作
wyd458677的博客
08-29 747
自己写的简单的单链表的创建，插入，删除，遍历操作 #include struct list { int data; struct list *next; }; //遍历链表 void show(struct list *li) { while(li) { printf("%d ",li->data); li=li->next; } printf("\n"); }
链表创建输入、插入、删除、遍历
写作业的猪崽
09-21 222
#include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR -1 typedef int Status; typedef int ElemType; typedef struct LNode { ElemType data; //结点的数据域 struct LNode *next; //结点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值