数据结构单链表的基础操作

最新推荐文章于 2024-07-25 17:43:13 发布
最新推荐文章于 2024-07-25 17:43:13 发布
阅读量213 收藏 1
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45693781/article/details/123916416
版权

学习23王道数据结构笔记（整体代码在最后）

  一、分析

        数据结构的三要素：数据的逻辑结构、存储结构、运算。

      ① 在逻辑结构中，分为线性结构和非线性结构。线性结构中有：一般线性表、栈、队列、串、数组；非线性结构有：集合、一般树、二叉树、有向图、无向图。

       ② 在存储结构中，主要分为四大存储：顺序存储、链式存储、索引存储、散列存储

       ③ 运算包括：定义和实现。       

                定义：针对逻辑结构，指出运算的功能；

                实现：针对存储结构，指出运算的具体操作步骤。

二、特点

        我对线性表的顺序存储以及链式存储记一下它们的不同点。这里的单链表是就典型的线性表通过链式存储实现的线性表。

顺序表链表
弹性（可扩容）不太行可行
增删不太行可行
查可行不太行

1.对扩容分析：

                                顺序表                                                        链表

               ① 逻辑上相邻的元素，对应的物理存             ①逻辑上相邻的元素，物理存

                储位置也相邻。费空间                                  储位置不一定相邻。

                ②需要一开始给足空间，空间过大闲            ②可扩充

                置，过小易溢出。不可扩充

2.对增删改查操作分析：

                                      顺序表                                                       链表

                                有序        无序                                         有序        无序

按值查找              O(log2n)     O(n)                                        O(n)        O(n)

按序号查找            O(1)          O(1)                                        O(n)         O(n)

插入删除      需要移动插入删除后的后面所有元素          只需要修改相关结点的指针域即可

三、代码操作

下面是对单链表的基本操作：(均为带头结点操作)

①定义单链表

//定义单链表
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;
 

②初始化结点

        只有当这个结点需要开辟空间存储数据时才会用到，这里用LNode *开辟而不用LinkList就是为了强调这个是一个单纯的结点，后面没跟链表。

//初始化结点
void InitLNode(LNode *&s,ElemType e){
    s = (LNode *)malloc(sizeof(LNode));     //强调结点
    s->next = NULL;
    s->data = e;
}

③头插法建立单链表

          一直在头结点L的后面插入结点

转变过程

 

 输入后的链表

 

 

//头插法建立单链表（带头结点）
LinkList List_HeadInsert(LinkList &L){
    LNode *s;
    int x;
    L = (LinkList)malloc(sizeof(LNode));    //创建头结点,强调链表
    L->next = NULL;
    cin >> x;
    
    while(x != -1){                         //循环输入这里是关键，先给s开空间，再给指，但后通过L，s的赋值定义为头插还是尾插，一定要熟练
        InitLNode(s, x);
        s->next = L->next;
        L->next = s;
        cin >> x;
    }
    
    return L;                               //L指向的是表头
}

④输出链表

        顺便加了一个gross记录表长哈，这个可以在定义链表在中加个length赋值给它哈。

//单链表的遍历
void PrintList(LinkList head){
    LNode* current = head;
    int gross = 0;
    cout << "遍历单链表的值：" << endl;
    
    /*while(current != NULL){     //不带头结点时,带头结点用这个输出会将头结点也一并输出
        gross ++;
        cout << current->data << "->";
        current = current->next;
    }*/
    
    while(current->next != NULL){
        gross++;
        current = current->next;
        cout << current->data << "->";
    }
    
    cout << "\n链表的数量为：\n" << gross << endl << endl;
}

④测试

        到这就可以测试了，输出一下代码看看：

int main(){             //编号从1开始
    
    //头插法建立单链表
    LinkList L1;
    cout << "头插法建立单链表，输入-1结束：" << endl;
    List_HeadInsert(L1);        //头插法建立单链表
    PrintList(L1);

    return 0;
}

运行截图

                                 

⑤尾插法建立单链表

         头插法会一直往插入的结点后插入。来张图要好理解的多

        

//尾插法建立单链表（带头结点）
LinkList List_TailInsert(LinkList &L){
    int x;
    L = (LinkList)malloc(sizeof(LNode));    //创建头结点，强调链表
    LNode *s, *r=L;
    cin >> x;
    
    while(x != -1){
        InitLNode(s, x);
        r->next = s;
        r = s;              //r指向新的表尾指针
        cin >> x;
    }
    r->next = NULL;         //尾结点指针置空
    return L;
}

⑥按序号查找结点

//按序号查找结点
LNode *GetElem(LinkList L, int i){          //强调结点
    int j = 1;    //计数
    LNode *p = L->next;
    //对i进行逻辑判断，加强代码的健壮性
    if(i == 0)
        return L;
    if(i < 0)
        return NULL;
        
    while(p && j<i){            //判断了p就不用再去通过头结点判断链表是否为空了
        p = p->next;
        j++;
    }
    return p;
}

⑦按值查找表结点

//按值查找表结点
LNode *LocateElem(LinkList L, ElemType e){
    LNode *p = L->next;
    int gross = 1;              //记录第几个数
    while(p && p->data!=e){
        p = p->next;
        gross++;
    }
    return p;
}

⑧尾插法插入结点 (在给定结点后插入一个结点)

//尾插法插入结点 (在给定结点后插入一个结点)
bool InsertLNode(LinkList &L, ElemType e, int i){        //（需要插入的链表，插入值，插入的位置）
    if(L == NULL)
        return false;
    else{
        LNode *p = GetElem(L , i), *s;
        if(p == NULL)
            return false;
        else{
            InitLNode(s , e);
            s->next = p->next;
            p->next = s;
        }
    }
}

⑨前插法插入结点（在给定结点前插入一个结点）

//前插法插入结点（在给定结点前插入一个结点）
bool FrontInsertNode(LinkList &L, ElemType e, int i){
    if(L == NULL)
        return false;
    else{
        LNode *p = GetElem(L, i), *s;
        if(p == NULL)
            return false;
        else{
            InitLNode(s, e);
            s->next = p->next;
            p->next = s;
            
            temp = p->data;             //这里区别与后插
            p->data = s->data;
            s->data = temp;
        }
    }
}

⑩删除结点操作


//删除结点操作
bool DelectLNode(LinkList L, int i){
    if(L == NULL)
        return false;
    else{
        LNode *p = GetElem(L, i-1),*s;     //找该结点的前驱结点
        if(p == NULL)
            return false;
        else{
            InitLNode(s, 0);
            s = p->next;
            p->next = s->next;
            free(s);
        }
    }
}

 

五、整体代码

#include <iostream>
#include <bits/stdc++.h>

using namespace std;

#define MaxSize 50
typedef int ElemType;

int n,m;
int arr[MaxSize],brr[MaxSize];
bool flag,judge;
ElemType temp,over;     //用于过度

//单链表的应用

//定义单链表
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

//初始化结点
void InitLNode(LNode *&s,ElemType e){
    s = (LNode *)malloc(sizeof(LNode));     //强调结点
    s->next = NULL;
    s->data = e;
}

//头插法建立单链表（带头结点）
LinkList List_HeadInsert(LinkList &L){
    LNode *s;
    int x;
    L = (LinkList)malloc(sizeof(LNode));    //创建头结点,强调链表
    L->next = NULL;
    cin >> x;
    
    while(x != -1){                         //循环输入这里是关键，先给s开空间，再给指，但后通过L，s的赋值定义为头插还是尾插，一定要熟练
        InitLNode(s, x);
        s->next = L->next;
        L->next = s;
        cin >> x;
    }
    
    return L;                               //L指向的是表头
}

//尾插法建立单链表（带头结点）
LinkList List_TailInsert(LinkList &L){
    int x;
    L = (LinkList)malloc(sizeof(LNode));    //创建头结点，强调链表
    LNode *s, *r=L;
    cin >> x;
    
    while(x != -1){
        InitLNode(s, x);
        r->next = s;
        r = s;              //r指向新的表尾指针
        cin >> x;
    }
    r->next = NULL;         //尾结点指针置空
    return L;
}

//按序号查找结点
LNode *GetElem(LinkList L, int i){          //强调结点
    int j = 1;    //计数
    LNode *p = L->next;
    //对i进行逻辑判断，加强代码的健壮性
    if(i == 0)
        return L;
    if(i < 0)
        return NULL;
        
    while(p && j<i){            //判断了p就不用再去通过头结点判断链表是否为空了
        p = p->next;
        j++;
    }
    return p;
}

//按值查找表结点
LNode *LocateElem(LinkList L, ElemType e){
    LNode *p = L->next;
    int gross = 1;              //记录第几个数
    while(p && p->data!=e){
        p = p->next;
        gross++;
    }
    return p;
}

//单链表的遍历
void PrintList(LinkList head){
    LNode* current = head;
    int gross = 0;
    cout << "遍历单链表的值：" << endl;
    
    /*while(current != NULL){     //不带头结点时,带头结点用这个输出会将头结点也一并输出
        gross ++;
        cout << current->data << "->";
        current = current->next;
    }*/
    
    while(current->next != NULL){
        gross++;
        current = current->next;
        cout << current->data << "->";
    }
    
    cout << "\n链表的数量为：\n" << gross << endl << endl;
}

//尾插法插入结点 (在给定结点后插入一个结点)
bool InsertLNode(LinkList &L, ElemType e, int i){        //（需要插入的链表，插入值，插入的位置）
    if(L == NULL)
        return false;
    else{
        LNode *p = GetElem(L , i), *s;
        if(p == NULL)
            return false;
        else{
            InitLNode(s , e);
            s->next = p->next;
            p->next = s;
        }
    }
}

//前插法插入结点（在给定结点前插入一个结点）
bool FrontInsertNode(LinkList &L, ElemType e, int i){
    if(L == NULL)
        return false;
    else{
        LNode *p = GetElem(L, i), *s;
        if(p == NULL)
            return false;
        else{
            InitLNode(s, e);
            s->next = p->next;
            p->next = s;
            
            temp = p->data;             //这里区别与后插
            p->data = s->data;
            s->data = temp;
        }
    }
}

//删除结点操作
bool DelectLNode(LinkList L, int i){
    if(L == NULL)
        return false;
    else{
        LNode *p = GetElem(L, i-1),*s;     //找该结点的前驱结点
        if(p == NULL)
            return false;
        else{
            InitLNode(s, 0);
            s = p->next;
            p->next = s->next;
            free(s);
        }
    }
}


int main(){             //编号从1开始
    
    //头插法建立单链表
    LinkList L1;
    cout << "头插法建立单链表，输入-1结束：" << endl;
    List_HeadInsert(L1);        //头插法建立单链表
    PrintList(L1);
    
    //尾插法建立单链表
    LinkList L2;
    cout << "尾插法建立单链表，输入-1结束：" << endl;
    List_TailInsert(L2);        //尾插法建立单链表
    PrintList(L2);
    
    //按序号查找结点
    LinkList L3;
    cout << "按序号查找结点,序号为 3 的结点值为：" << endl;
    List_HeadInsert(L3);        //头插法建表
    LNode *p1 = GetElem(L3 , 3); //序号查结点
    if(p1 == NULL)
        cout << "查无此值" << endl << endl;
    else
        cout << p1->data << endl << endl;
    
    //按值查找表结点
    LinkList L4;
    cout << "按值查找表结点，值为 35 的结点为：" << endl;
    List_TailInsert(L4);            //尾插法建表
    LNode *p2 = LocateElem(L4 , 35); //按值查结点
    if(p2 == NULL)
        cout << "查无此值" << endl << endl;
    else
        cout << p2->data << endl << endl;
    
    //在给定结点位置后插入一个结点
    LinkList L5;
    cout << "在序号为5的结点后插入值 555 ：" << endl;
    List_HeadInsert(L5);            //头插法建表
    InsertLNode(L5, 555, 5);        //插入一个结点
    PrintList(L5);
    
    //在给定结点位置前插入一个结点
    LinkList L6;
    cout << "在序号为6的结点前插入 666 ：" << endl;
    List_TailInsert(L6);
    FrontInsertNode(L6, 666, 6);
    PrintList(L6);
    
    //删除给定结点位置的结点
    LinkList L7;
    cout << "删除给定结点位置的结点： " <<endl;
    List_HeadInsert(L7);
    DelectLNode(L7, 7);
    PrintList(L7);
    
    return 0;
}

整体运行截图：

 

小唐2761
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构-单链表基本操作带图完整详解
oorik的博客
01-09 7096
1.什么是链表 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指 针链接次序实现的。 2.为什么要使用链表 在未学习链表时，我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快，但是它的弊端也很明显： 1.使用前需声明数组的长度，一旦声明长度就不能更改 2.插入和删除操作需要移动大量的数组元素，效率慢 3. 只能存储一种类型的数据 顺序表就是在计算机中内存以数组的形式保存的线性表，因此这些弊端同理 而链表则可以实现以上这些数组所不具备的功
C语言数据结构单链表基本操作
黑锤的博客
01-28 758
#include<iostream> #include<stdio.h> #include<string.h> #include<stdlib.h> typedef struct Lnode { int data; struct Lnode *next; }Lnode,*Linklist; int InitList(Linklist...
数据结构——单链表的基本操作
m0_56069910的博客
11-20 490
单链表详解
数据结构：单链表的基本操作
weixin_45213079的博客
08-17 1152
数据结构：单链表的基本操作
数据结构-单链表基本操作-C语言代码
热门推荐
suxiaorui的博客
01-22 6万+
单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码，具体思路讲解请看这篇博客：数据结构-线性结构-单链表 1.头插法建立单链表 #include<stdio.h> #include<stdlib.h> //单链表的结构定义 typedef struct LNode { int data...
【数据结构】单链表的操作
qq_45972928的博客
04-21 6106
内容： 1）实现单链表的以下基本操作：建立单链表，查找单链表，插入单链表，删除单链表。 2）采用单链表结构编程实现：两个有序单链表的归并运算。 实现思路： ① 定义数据域类型； ② 定义单链表，分为数据域和指针域； ③ 分别编写实现前插法创建单链表、后插法创建单链表、初始化单链表、单链表的查找、向单链表插入元素、删除单链表中某元素、遍历单链表并显示、求单链表最大节点、判断单链表是否为空、求单链表长度、逆转单链表、两个有序单链表的归并等函数功能； ④ 在主函数中定义单链表； ⑤ 使用while实现循环操.
数据结构单链表插入和删除操作
weixin_45349814的博客
04-22 8112
单链表的创建及插入删除操作
数据结构单链表基本操作（C/C++实现）
JunsIr的技术栈
10-22 6684
数据结构-单链表-基本操作（C/C++实现） 注意：本代码为了测试运行默认含有操作所需数据，如有需要可自己增删改相关数据 涉及基本运算 初始化单链表 依次采用尾插法插入元素 输出单链表 输出单链表的长度 判断单链表是否为空 输出单链表的第n个元素 输出元素x的位置 在第n个元素位置上插入x元素 输出单链表 删除单链表的第n个元素 输出单链表 释放单链表 GitHub地址（包含.cpp文件和可执...
数据结构 | 单链表的基本实现
m0_68732914的博客
07-26 670
最近刚在学习《数据结构与算法》，单纯地跟课、看书觉得并不能很好的掌握好这些知识点，所以决定尝试将学习的知识点归纳总结，也将其进行代码实现，强化对知识点的理解。即作为笔记、实践，又作为我的思路分享。因为初学，难免有不正确、不恰当之处，敬请指正！单链表（singly linked list）是用一组任意的存储单元存放线性表的元素，这组存储单元可以连续也可以不连续，甚至可以零散分布在内存中的任意位置。结点（node）是存放了数据元素和其后续元素所在的地址信息的存储映像。其中。data为数据域，存放数据元素；
数据结构实现单链表的基本操作
Strive_0902的博客
04-01 1157
该程序在vs2013中完成!!!单链表的基本函数：#include&lt;stdio.h&gt; #include&lt;malloc.h&gt; typedef char ElemType; typedef struct LNode { ElemType data; struct LNode *next; } LinkList; void InitList(LinkList *&amp;L...
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。 2.再从键盘输入顺序任意的5个整数，按有序插入的要求生成第二个有序单链表，将该链表输出显示。 3.将这两个有序单链表...
C语言 数据结构之单链表基本操作
10-05
单链表的各种操作，适合于初学，也适合于复习 单链表操作介绍 1. 创建头节点 2. 创建有数据节点 3. 判断链表是否为空 4. 遍历链表(有头节点链表) 5. 遍历链表(无头节点链表) 6. 头插、头删、尾插、尾删 7. 按照顺序...
数据结构单链表的基本操作实现(包含源代码)上机报告
07-13
数据结构中的单链表是一种常见的线性数据结构，它的每个节点包含两部分：一部分是数据域，用于存储数据；另一部分是指针域，用于指向下一个节点。本实验报告旨在通过C++实现单链表的基本操作，包括初始化、销毁、...
数据结构单链表的详细介绍
09-03
总结来说，单链表是一种重要的数据结构，理解和掌握其基本操作对于学习更复杂的算法和数据结构至关重要。通过实验报告的方式，学习者不仅能理论联系实际，还能培养解决实际问题的能力。在C语言中实现单链表，有助于...
【初阶数据结构篇】单链表的实现（赋源码）
最新发布
2301_79849925的博客
07-25 1476
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
《Java初阶数据结构》----5.＜二叉树的概念及使用＞
m0_73456341的博客
07-24 1407
1.树的基本概念、2.二叉树概念及特性、3.二叉树的基本操作、4.二叉树相关编程题
数据结构——单链表OJ题（上）
2301_81888634的博客
07-24 844
一起加油，敬请期待“单链表OJ题（下）”~
数据结构（2）
m0_62881487的博客
07-23 1150
为建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息之外，还需要存放一个指向其后继的指针。为指针域，存放其后继结点的地址。由于单链表的元素离散地分布在存储空间中，因此是非随机存取的存储结构。1. 线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。3. 顺序表的特点是表中元素的逻辑顺序与其存储的物理顺序相同。2. 线性表的顺序存储又称顺序表。，分别指向其直接前躯和直接后继。
数据结构单链表基本操作
10-07
单链表是一种常见的数据结构，它由一个节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。下面是单链表的基本操作： 1. 创建链表：创建一个空链表，即将头指针置为 null。 2. 插入节点：在链表的指定位置插入一个新节点。需要注意的是，插入节点需要更新前一个节点的指针和新节点的指针。 3. 删除节点：从链表中删除指定位置的节点。需要更新前一个节点的指针和释放内存空间。 4. 查找节点：在链表中查找指定值的节点。需要遍历链表并逐个比较节点的值。 5. 遍历链表：按顺序访问链表中的每个节点，并对其进行相应的操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值