链表的相关基本操作

已于 2022-07-10 16:06:48 修改
阅读量197 收藏 2
点赞数
文章标签： 链表 数据结构
于 2022-07-10 16:04:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53175146/article/details/125606288
版权

文章目录

一、单链表定义及其操作

1.定义
 //定义结构体
 typedef struct LNode{
    int data;
    struct LNode *next;
}*Linklist,Lnode;
2.建立单链表
①尾插法创建新链表（无头节点）
Linklist found(){
    Linklist L=NULL;
    Lnode *q=L,*s;
    int p;
    while (1){
        scanf("%d",&p);
        if(p!=9999){
            s=(Lnode*) malloc(sizeof (Lnode));
            s->data=p;
            if(L==NULL){
                L=s;
                s->next=NULL;
                q=s;
            } else{
                q->next=s;
                q=s;
                s->next=NULL;
            }
        } else break;
    }
    return L;
}
②尾插法创建新链表（有头节点）
Linklist found2(){
    Linklist L=(Lnode *) malloc(sizeof(Lnode));
    L->next=NULL;
    Lnode *q,*s;
    q=L;
    int p;
    while (1){
        scanf("%d",&p);
        if(p!=9999){
            s=(Lnode *) malloc(sizeof (Lnode));
            s->data=p;
            q->next=s;
            q=s;
            s->next=NULL;
        } else break;
    }
    return L;
}
③头插法创建新链表（无头节点）
Linklist found3(){
    Linklist L=NULL;
    int a;
    Lnode *p;
    while (1){
        scanf("%d",&a);
        if(a!=9999){
            p=(Lnode *) malloc(sizeof (Lnode));
            p->data=a;
            p->next=L;
            L=p;

        } else break;
    }
    return L;
}
④头插法创建新链表（有头节点）
Linklist found4(){
    Linklist L=(Linklist) malloc(sizeof (Lnode));
    L->next=NULL;
    int a;
    Lnode *p;
    while (1){
        scanf("%d",&a);
        if (a!=9999){
            p=(Lnode *) malloc(sizeof (Lnode));
            p->data=a;
            p->next=L->next;
            L->next=p;
        } else break;
    }
    return L;
}
3.查找
①按序号查找结点值（无头结点）
int found5(Linklist L,int i){
    int a=1;
    Lnode *p=L;
    while (p&& a<i){
        p=p->next;
        a++;
    }
    return p->data;
}
②按序号查找结点值（有头结点）
Lnode *found6(Linklist L,int i){
    Lnode *p=L->next;
    int a=1;
    while (p && a<i){
        p=p->next;
        a++;
    }
    return p;
}
③按值查找表结点（无头结点）
Lnode *found7(Linklist L,int a){
    Lnode *p=L;
    while (p&&p->data!=a){
        p=p->next;
    }
    return p;
}
④按值查找表结点（有头结点）
Lnode *found8(Linklist L,int a){
    int i=1;
    Lnode *p=L->next;
    while (p){
        if(p->data==a){
            break;
        } else{
            p=p->next;
            i++;
        }
    }
    if(p==NULL){
        printf("no number\n");
        return L;
    } else  return p;
}
4.插入
①在第i个结点后面插入一个结点（无头结点）
void insert1(Linklist &L, int i,int a){   //a是要插入的结点的data
    Lnode *p=L;
    Lnode *s;                                   //s：要插入的结点
    int k=1;
    while (p){
        if(k==i){
            s=(Lnode*) malloc(sizeof (Lnode));
            s->data=a;
            s->next=p->next;
            p->next=s;
            break;
        } else{
            p=p->next;
            k++;
        }
    }
}
②在第i个结点后面插入一个结点（有头结点）
void insert4(Linklist &L, int i,int a){   //a是要插入的结点的data
    Lnode *p=L->next;
    Lnode *s;                                   //s：要插入的结点
    int k=1;
    while (p){
        if(k==(i-1)){
            s=(Lnode*) malloc(sizeof (Lnode));
            s->data=a;
            s->next=p->next;
            p->next=s;
            break;
        } else{
            p=p->next;
            k++;
        }
    }
}
③在第i个结点前面插入一个结点（无头结点）
void insert2(Linklist &L, int i,int a){   //a是要插入的结点的data
    Lnode *p=L;
    Lnode *s;                                   //s：要插入的结点
    int k=1;
    while (p){
        if(k==(i-1)){
            s=(Lnode*) malloc(sizeof (Lnode));
            s->data=a;
            s->next=p->next;
            p->next=s;
            break;
        } else{
            p=p->next;
            k++;
        }
    }
}
④在第i个结点前面插入一个结点（有头结点）
void insert3(Linklist &L, int i,int a){   //a是要插入的结点的data
    Lnode *p=L->next;
    Lnode *s;                                   //s：要插入的结点
    int k=1;
    while (p){
        if(k==i){
            s=(Lnode*) malloc(sizeof (Lnode));
            s->data=a;
            s->next=p->next;
            p->next=s;
            break;
        } else{
            p=p->next;
            k++;
        }
    }
}
5.求链表长度：查找单链表中结点个数（有头结点）
int find_Link_nu(Linklist L){
    Lnode *p=L->next;
    int count=0;
    while (p){
        count++;
        p=p->next;
    }
    return count;
}
6.删除第i个结点（有头结点）
void Delet(Linklist &L,int i){
    Lnode *pre=L,*p=pre->next;
    int count=1;
    while (count!=i && p){
        pre=p;
        p=p->next;
        count++;
    }
    if (p==NULL){
        pre->next=p;
    } else{
        pre->next=p->next;
    }
    return;
}

二、双链表的定义和基本操作

1.定义
typedef struct Dlnode {
    int data;
    struct Dlnode *pre, *next;
}Dlnode,*DLinklist ;
2.建立有头结点的双链表
①头插法
DLinklist Df1(){
    DLinklist L=(DLinklist) malloc(sizeof (DLinklist));
    L->next=NULL;
    int data;
    Dlnode *p;
    while (1){
        scanf("%d",&data);
        if(data!=9999){
            p=(Dlnode*) malloc(sizeof (Dlnode));
            p->data=data;
            if (L->next!=NULL){
                p->next=L->next;
                L->next->pre=p;
                p->pre=L;
                L->next=p;
            } else{
                p->next=NULL;
                p->pre=L;
                L->next=p;
            }
        } else break;
    }
    return L;
}
②尾插法
DLinklist Df2(){
    DLinklist L=(DLinklist) malloc(sizeof (DLinklist));
    L->next=NULL;
    int a;
    Dlnode *q=L;
    while (1){
        scanf("%d",&a);
        if(a!=9999){
            Dlnode *p=(Dlnode*) malloc(sizeof (Dlnode));
            p->data=a;
            p->next=NULL;
            q->next=p;
            p->pre=q;
            q=p;
        } else break;
    }
    return L;
}
3.删除
①删除第i个结点的后继结点(有头结点)
int Ddelete(DLinklist &L,int i){
    if(L->next==NULL){
        return -1;
    }
    int count=1;
    Dlnode *pre=L,*q=pre->next;
    while (q && count<=i){
        pre=pre->next;
        q=q->next;
        count++;
    }
    if(q==NULL){
        return -1;
    }
    if (q->next==NULL){
        pre->next=NULL;
        free(q);
        return 1;
    }
    pre->next=q->next;
    q->next->pre=pre;
    free(q);
    return 1;
}
②删除第i个结点的前驱结点(有头结点)
int Ddelet2(DLinklist &L,int i){
    if(i==1 || L->next==NULL){
        return -1;
    }
    int count=1;
    Dlnode *p=L->next;
    while (p&&count<(i-1)){
         p=p->next;
        count++;
    }
    if (p==NULL){
        return -1;
    }
    p->pre->next=p->next;
    free(p);
    return 1;
}

三、循环单链表的定义及基本操作

1.建立循环单链表（有头结点）
①头插法
//头插法
Linklist refound4(){
    Linklist L=(Linklist) malloc(sizeof (Lnode));
    L->next=L;
    int a;
    Lnode *p;
    while (1){
        scanf("%d",&a);
        if (a!=9999){
            p=(Lnode *) malloc(sizeof (Lnode));
            p->data=a;
            p->next=L->next;
            L->next=p;
        } else break;
    }
    return L;
}
②尾插法
Linklist refound5(){
    Linklist L=(Linklist) malloc(sizeof (Lnode));
    L->next=L;
    int a;
    Lnode *s,*q=L;
    while (1){
        scanf("%d",&a);
        if (a!=9999){
            s=(Lnode *) malloc(sizeof (Lnode));
            s->data=a;
            s->next=q->next;
            q->next=s;
            q=s;
        } else break;
    }
    return L;
}
2.删除循环单链表中第i个结点（有头结点）
void delete_relink(Linklist &L,int i){
    int count=1;
    Lnode *pre=L,*q=pre->next;
    int a= find_reLink_nu(L);               //L循环单链表长度
    if (i>a || i<=0){
        printf("wrong!");
        return;
    }
    while (q!=L && count<i){
        q=q->next;
        pre=pre->next;
        count++;
    }
    if (count==i) {
        pre->next = q->next;
        free(q);
        printf("right");
        return;
    }
}
3.在第i个结点后插入一个值为a的结点（有头结点）
void insert_reLin(Linklist &L,int i,int a){
    int count=0;
    Lnode *pre=L,*p,*s=(Lnode*) malloc(sizeof (Lnode));
    int b= find_reLink_nu(L);
    if (i>b||i<1){
        printf("wrong!\n");
        return;
    }
    while (p!=L && count<i){
        p=pre->next;
        pre=pre->next;
        count++;
    }
    s->data=a;
    if (count==i){
        s->next=p->next;
        p->next=s;
    } else{
        s->next=L;
        p->next=s;
    }
    printf("right\n");
}
4.在第i个结点前插入一个值为a的结点（有头结点）
void insert_reLin2(Linklist &L,int i,int a){
    int count=0;
    Lnode *p=L,*s=(Lnode*)malloc(sizeof (Lnode));
    int b= find_reLink_nu(L);
    if (i>b||i<1){
        printf("wrong!\n");
        return;
    }
    while (count<i-1){
        p=p->next;
        count++;
    }
    s->data=a;
    s->next=p->next;
    p->next=s;
    printf("right\n");
}

三、建立循环双链表及基本操作（有头结点）

1.建立循环双链表
①定义
typedef struct Drelnode{
    int data;
    struct Drelnode *next,*pre;
}Drelnode,*DreLinklist;
②头插法
DreLinklist Dre_found(){
    DreLinklist L=(DreLinklist) malloc(sizeof (DreLinklist));
    L->next=L;
    L->pre=L;
    int a;
    Drelnode *p;
    while (1){
        scanf("%d",&a);
        if (a!=9999){
            p=(Drelnode*) malloc(sizeof (Drelnode));
            p->data=a;
            L->next->pre=p;
            p->next=L->next;
            p->pre=L;
            L->next=p;

        } else break;
    }
    return L;
}
②尾插法
DreLinklist Dre_found2(){
    DreLinklist L=(DreLinklist) malloc(sizeof (DreLinklist));
    int a;
    L->next=L;
    L->pre=L;
    Drelnode *p,*q=L;
    while (1){
        scanf("%d",&a);
        if (a!=9999){
            p=(Drelnode*) malloc(sizeof (Drelnode));
            p->data=a;
            q->next=p;
            p->pre=q;
            p->next=L;
            L->pre=p;
            q=p;

        } else break;
    }
    return L;
}
2.删除第i个结点
bool Delete_dre(DreLinklist &L,int i){
    int count=1;
    int a= find_DreLink_nu(L);
    if (L->next==L||i>a){
        return false;
    }
    Drelnode *pre=L,*p=pre->next;
    while (count<i){
        p=p->next;
        pre=pre->next;
        count++;
    }
        pre->next=p->next;
        p->next->pre=pre;
        free(p);
    return true;
}
3.在第i个结点后插入一个新结点
void insert_Dre(DreLinklist &L,int i,int data){
    Drelnode *p=L->next,*s;
    int count=1;
    int a = find_DreLink_nu(L);
    if (i>a||p==L){
        printf("wrong");
        return;
    }
    while (p!=L&&count<i){
        p=p->next;
        count++;
    }
    s=(Drelnode*) malloc(sizeof (Drelnode));
    s->data=data;
    s->next=p->next;
    p->next->pre=s;
    p->next=s;
    s->pre=p;
    printf("right\n");
    return;
}
4.在第i个结点前插入一个新结点
void insert_Dre_pre(DreLinklist &L,int i,int data){
    Drelnode *p=L->next,*s;
    int count=1;
    int length = find_DreLink_nu(L);
    if (i>length){
        printf("wrong\n");
        return;
    }
    while (p!=L&&count<i){
        p=p->next;
        count++;
    }
    s=(Drelnode*) malloc(sizeof (Drelnode));
    s->data=data;
    s->pre=p->pre;
    p->pre->next=s;
    s->next=p;
    p->pre=s;
    printf("right\n");
    return;
}
weixin_53175146
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python 链表基本操作
Yangcp_的博客
08-20 1785
python 链表题
链表的基本操作
05-24
链表很多同学不太理解，对此写了下链表的基本操作，头插法，对应位置修改删除等基本功能，仅提供自己学习。
双向链表的基本操作
weixin_54802873的博客
07-20 1779
双向链表的基本操作
链表基本操作（详解）
热门推荐
Czc1357618897的博客
11-30 1万+
链表的基本操作 这里写目录标题链表的基本操作一：单链表的基础知识二：单链表的建立头插法尾插法三：单链表的遍历四：单链表结点数目判断五：单链表的插入链表头插入任意结点插入链表尾部插入六：单链表的删除七 ：单链表的查询 一：单链表的基础知识 为什么需要链表？ 我们在使用数组存放数据是非常方便，但是由于数组的长度是固定的，所以当存储不同的元素数量时，就很容易出现问题。如果向数组中添加的数量大于数组大小时候，信息无法完全被保存。所以我们需要另一种存储方式来存储数据，其中存储的元素的个数不受限制。这种存储方式就是链
c语言 链表基本操作
weixin_63178060的博客
08-29 8395
当链表不为空时，则需循环遍历链表，找到链表中最后一个结点，然后将其的next域指向新节点，即cur->next=newnode，此时，不需要将新节点的next域赋值为空，因为在创建结点函数中已将next域赋值为空。在进行头插元素的时候，第一步和第二步不能进行交换，如果先进pre->next=s,此时pre->next指向了s,在进行s->next=pre->next，就会使s->next指向自己本身，无法达到预期效果。如果给定位置正常，则直接将给定位置的next指向，给定位置的next的next。...
C语言实现链表基本操作
qq_56066173的博客
08-20 4464
如果把数据比喻成珠子，指针就是线，链表通过指针这条线就是把数据这些珠子串起来。
双链表的基本操作
qq_44631587的博客
03-03 2719
带头结点的双向循环链表 链表结构如下： 每个节点都有一个数据域和两个指针域，这两个指针分别指向链表的前驱节点和后继节点，头节点的前驱节点是链表的最后一个节点，链表最后一个节点的后继节点是头节点。 正因为如此，带头结点的双向循环链表没有空节点，在进行遍历时，循环条件也与单链表不同： 单链表用cur->next为空判断当前节点是否为最后一个节点，带头的双向循环链表则需判断cur->next是否等于头节点。 定义： typedef int DataType; typedef struct ListN
链表基本操作
kakaka666的博客
06-13 816
链表基本操作 1.
链表--基本操作
weixin_61196797的博客
05-09 825
文章目录前言一、链表的创建二、反转链表1.三指针法2.使用头插法建立新链表来反转三、删除链表的倒数第K个结点1.遍历链表，求出倒数第K个结点2.快慢指针法进行删除四、合并两个有序链表总结 前言 关于五月考核前三题 1.反转链表 2.删除链表的倒数第n个结点 3.合并两个有序链表 先进行链表的动态创建 一、链表的创建 注意包含头文件<stdlib.h> //先创建一个结构体 struct Node { int data; struct Node* next; }; //创建表头 struc
c++链表基本操作
m0_60777643的博客
01-22 7339
单链表创建： struct linklist { int data; linklist* next; }; linklist* creat(int n) {//创建含有n个节点的链表 linklist* head; linklist* node; linklist* end; head = new linklist;//申请表头空间 end = head; head->data = n; //可以选择从表头开始存放所需数据，也可以选择独立表头； //这里选择独立表头，并且表头
c语言链表的基本操作整理
07-04
一个简单的单向链表的基本操作代码，包括链表节点的定义、链表的初始化、插入节点、删除节点、遍历链表和销毁链表的功能。 1.定义链表节点结构：Node 结构体包含一个整数数据和一个指向下一个节点的指针。 2.初始化...
lianbiao.rar_链表基本操作_链表操作
09-24
接下来，我们将深入探讨链表的基本操作，包括链表的创建、删除以及统计链表长度。 1. **链表的创建** 创建链表首先要定义节点结构，一般包括数据域（存储数据）和指针域（指向下一个节点）。例如，我们可以定义一...
c语言链表的基本操作实现
03-28
C语言链表的基本操作主要包括**初始化、创建节点、插入节点、删除节点和查找节点**。具体如下： 1. **初始化**：创建一个空的链表，通常指创建一个头指针，该指针指向NULL，表示链表的开始。 2. **创建节点**：在...
C语言对链表的基本操作
12-20
下面我们将详细探讨C语言中链表的基本操作。 1. **链表的定义** 在C语言中，链表由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针部分。一个简单的单链表节点结构可以定义为： ```c typedef ...
数据结构(5.4_1)——树的存储结构
m0_65240792的博客
08-02 287
每个结点中保存指向双亲的“指针” 新增数据元素无需按逻辑上的次序存储，之家在上一个结点后添加新结点，并记录双亲结点 1、删除结点数据域 2、将尾部数据移动至删除结点位置填充空缺寻找其双亲结点相同的结点顺序存储各个节点，每个结点中保存孩子的链表头指针 树和二叉树的转化： 使用孩子兄弟表示法
数据结构(面试)
Anterior_condyle的博客
08-01 1223
在含有n个带权叶节点的二叉树中，其中带权路径（WPL）最小的二叉树称为哈夫曼树，也称最优二叉树。
2024.7.24 作业
qq_64434282的博客
07-24 3192
【代码】2024.7.24 作业。
笔记222222222222222222222222222222
最新发布
08-04
笔记222222222222222222222222222222
仿拉钩App小程序.rar
08-04
小程序的设计源码通常包含多个文件和文件夹，组织结构清晰，以便开发者能够快速上手并进行定制化开发。主要文件和文件夹包括： 页面文件夹：存放小程序的各个页面，每个页面通常由.wxml、.wxss、.js和.json文件组成。WXML文件负责页面的结构，类似于HTML；WXSS文件负责样式，类似于CSS；JS文件负责页面的逻辑和交互；JSON文件用于页面的配置，如导航栏标题等。 组件文件夹：存放可复用的UI组件。组件与页面类似，也由.wxml、.wxss、.js和.json文件组成。通过组件化设计，可以提高代码的复用性和维护性，减少重复工作。 静态资源文件夹：存放图片、音频、视频等静态资源，便于在小程序中引用。这些资源通常放在一个名为assets或static的文件夹中。 配置文件：小程序的根目录下通常有一个app.json文件，用于全局配置，如页面路径、导航栏样式、底部Tab栏等。此外，还有app.wxss和app.js文件，分别用于全局样式和全局逻辑。 工具文件夹：存放一些工具函数和库文件，便于在小程序中调用。这些文件通常放在一个名为utils的文件夹中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值