数据结构笔记1：链表

最新推荐文章于 2024-04-20 08:00:00 发布
最新推荐文章于 2024-04-20 08:00:00 发布
阅读量543 收藏 1
点赞数 3
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaiyi7788/article/details/104084534
版权

数据结构笔记1：链表

链表主要需要掌握，头插法尾插法创建链表。插入删除操作。还有就是遍历了，

很简单。

最关键的一点就是，考虑好头节点的应用。

Node.h

#ifndef _NODE_H_
#define _NODE_H_
//结构体一般定义在.h文件中
#define ElemType int
typedef struct LNode //单链表节点
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;
/*与上面等价
struct LNode{
    ElemType data;
    struct LNode *next;
};
typedef struct LNode LNode;  //LNode就是 struct LNode的一个别名
typedef struct LNode*  LinkList; //LinkList是struct LNode*的一个别名

LNode a;//声明了一个struct LNode型变量a，与写　struct LNode a;　等价；
LinkList p;//声明了一个struct LNode *型指针变量p，与写　struct LNode *p;　等价。
*/
typedef struct DNode //双链表节点
{
    ElemType data;
    struct DNode *prior,*next;
}DNode,*DLinklist;
#endif

LinkList.h

#ifndef _LINKLIST_H_
#define _LINKLIST_H_
#include"Node.h"
using namespace std;
//单链表
LinkList LinkList_HeadInsert_Init(LinkList &L);
LinkList LinkList_TailInsert_Init(LinkList &L);
void LinkList_All_Out(LinkList L);
LinkList LinkList_Search(LinkList L,int i);
void LinkList_Insert(LinkList L,int i);
void LinkList_Delete(LinkList L,int i);
int LinkList_GetLenth(LinkList L);
//双链表
DLinklist DLinklist_Init(DLinklist &D);
void DLinklist_All_Out(DLinklist D);
DLinklist DLinklist_Search(DLinklist D,int i);
void DLinklist_Insert(DLinklist D,int i,bool j);
//这次写的函数都是传入的头结点，但是事实上很多情况下需要传入的
//是中间某个节点返回的p指针，比如先用search函数得到对应的指针。
#endif

LinkList.cpp

#include <iostream>
#include "LinkList.h"
#include "Node.h"
using namespace std;
/****************************单链表*********************************/

//最核心的思想，头结点的处理如何进行
//头插法，但是得到的元素和输入的元素是倒序的
LinkList LinkList_HeadInsert_Init(LinkList &L)
//引用，改变函数内Ｌ的值函数返回值也发生改变,同时引用定义了L,无需重新定义可直接调用
//需要对传入的参数进行改变时就要用引用
{
    LinkList p;
    int x;
    L = new(LNode); //头结点，不存放数据 ，
    //分配的内存是用来存放节点的，然后让一个指针指向这段内存。
    L->next = NULL;
    cin >> x;
    while(x != 9999)
    {
        p = new(LNode); //创建新节点
        p->data = x;
        p->next = L->next; //插在头结点和现在第一个节点之间变成第一个节点
        L->next = p;
        cin >> x;
    }
    return L ;
}
//尾插法
LinkList LinkList_TailInsert_Init(LinkList &L)
{
    int x;
    LinkList p,r; //尾插法需要多定义一个指针作为中间变量
    L = new(LNode);//要先分配空间，再把L赋给r
    r = L;
    cin >> x;
    while(x != 9999)
    {
        p = new(LNode); //创建新节点
        p->data = x;
        r->next = p;
        r = p;
        cin >> x;
    }
    r->next = NULL;//尾插法让最后一个节点指向空即可
    return L;
}
//遍历所有元素并全部输出
void LinkList_All_Out(LinkList L)
{
    LinkList p = L->next;
    while(p != NULL)
    {
        cout<< p->data <<endl;
        p = p->next;
    }
}
//访问特定元素并输出
LinkList LinkList_Search(LinkList L,int i)
{
    LinkList p = L->next;
    int j = 1;
    if(i == 0) return L;
    if(i<1) return NULL;
    while(p->next) //判断条件(p->next)为真等价于判断(p->next != NULL)为真
    {
        if(j == i) break; //遍历＋下标
        j++;
        p = p->next;
    }
    return p;
}
void LinkList_Insert(LinkList L,int i) //插入节点
{
    LinkList p,q;
    int x;
    p = LinkList_Search(L,i);
    q = new(LNode);
    cin >> x ;
    q->data = x;
    q->next = p->next;
    p->next = q;
}
void LinkList_Delete(LinkList L,int i)
{
    int j = 1;
    LinkList p,q;
    p = L;
    while(p && j < i)
    {
        j++;
        p = p->next;
    }
    q = p->next; //这里为什么要把p->next保存给ｑ呢
    //因为我们最后要把删去的节点对应的内存给释放，注意释放的是指针指向的内存而并非指针本身。
    //而执行了 p->next = p->next->next 之后，我们就无法找到该节点这段内存了，用q保存p->next，
    //本质上保存的是这段内存，因此最后直接释放q,就相当于释放掉这段内存了。初始化q时也无需给q分配内存。
    p->next = p->next->next;
    delete q; //delete()和free()的操作对象是指针，清除的是指针指向的内存。

}
int LinkList_GetLenth(LinkList L)
{
    LinkList p = L->next;
    int n = 0;
    while(p)
    {
        n++;
        p = p->next;
    }
    return n;
}
/**************************************************************/

/**************************双链表*******************************/
DLinklist DLinklist_Init(DLinklist &D)
{
    DLinklist p,q;
    int x;
    D = new(DNode);//建空双向循环链表
    D->next = D;
    D->prior = D;
    q = D;
    cin>>x;
    while(x != 9999)
    {
        p = new(DNode);
        p->prior = q;
        q->next = p;
        p->next = D;
        D->prior = p;
        p->data = x;
        q = p;
        cin>>x; 
    }
    return D;
}
void DLinklist_All_Out(DLinklist D)
{
    DLinklist p = D->next;
    while(p != D)
    {
        cout<< p->data <<endl;
        p = p->next;
    }
}
DLinklist DLinklist_Search(DLinklist D,int i)
{
    DLinklist p = D->next;
    int j = 1;
    if(i == 0) return D;
    if(i<1) return NULL;
    while(p->next) //判断条件(p->next)为真等价于判断(p->next != NULL)为真
    {
        if(j == i) break; //遍历＋下标
        j++;
        p = p->next;
    }
    return p;
}
void DLinklist_Insert(DLinklist D,int i,bool j) //插入节点,bool为0，
//插入在i节点之后，为1插在之前
{
    DLinklist p,q;
    int x;
    p = DLinklist_Search(D,i);
    q = new(DNode);
    cin >> x ;
    q->data = x;
    if(j == 0) //后插
    {
        p->next->prior = q;//先链接新增节点和未被移动指针p指向的节点
        q->next = p->next; //1和2指令可对调，3和4指令可对调，
        //但12要在34之前执行
        p->next = q;
        q->prior = p;
    }
    else //前插
    {
        p->prior->next = q;
        q->prior = p->prior;
        p->prior = q;
        q->next = p;
    }   
}
void DLinklist_Delete(DLinklist D,int i) //删除访问到的那个节点
{
    int j = 1;
    DLinklist p,q;
    p = D;
    while(p && j < i)
    {
        j++;
        p = p->next;
    }
    q = p->next; 
    p->next = p->next->next;
    delete q;
}

main.cpp

#include <iostream>
#include "LinkList.h"
using namespace std;
// int main()
// {
//    LinkList L;
//    int num;
//    //L =  LinkList_HeadInsert_Init(L); //引用时在定义里用到了&L,因此在调用函数时直接将L传参进去即可
//    L =  LinkList_TailInsert_Init(L);
//    //LinkList_All_Out(L);
//    //p = LinkList_Search(L,5);
//    //cout<<p->data<<endl;
//    LinkList_Insert(L,5);
//    LinkList_All_Out(L);
//    LinkList_Delete(L,4);
//    LinkList_All_Out(L);
//    num = LinkList_GetLenth(L);
//    cout << num << endl;
//    //cout << L->next->next->data<<endl;
//    return 0;
// }  
#define Next 0
#define Prior 1
int main()
{
   DLinklist D;
   D = DLinklist_Init(D);
   // cout << D->next->data <<endl;
   // cout << D->prior->data <<endl;
   DLinklist_Insert(D,5,Prior);
   DLinklist_All_Out(D);
   return 0;
}

易错整理：

一、链表总的首元结点、头结点、头指针的区别

三者的基本概念：

1、首元结点：就是指链表中存储第一个数据元素a1的结点。

2、头结点：它是在首元结点之前设的一个节点，其指针域指向首元结点。头

结点的数据域可以不存储信息，也可以存储与数据元素类型的其他附加信息。

3、头指针：它是指向链表中的第一个结点的指针。若链表设有头结点，则头

指针所指结点为线性表的头结点；若链表不设头结点，则头指针所指结点为该线

性表的首元结点。

4、尾指针：指向链表中的终端节点的指针。

链表增加头结点的作用有以下几点：

在这里插入图片描述
1、增加了头结点后，首元结点的地址保存在头结点（就是所说的“前驱”结点）的

指针域中，则对链表的第一个数据元素的操作与其他数据元素相同，无需进行特

殊处理

2、便于空表的和非空表的统一处理；当链表不设头结点时，假设L为单链表的头

指针，它应该指向首元结点，则当单链表为长度n为0的空表时，L指针为空（判断

空表的条件可记为：L==NULL）

3、增加头结点后，无论链表是否为空，头指针都是指向头结点的非空指针，若链

表为空的话，那么头结点的指针域为空。

二、单循环链表的尾指针

在单循环链表中，一般使用尾指针而非头指针。

尾指针是指向终端结点的指针，用它来表示单循环链表可以使得查找链表的开始

结点和终端结点都很方便。

设一带头结点的单循环链表，其尾指针为rear，则开始结点和终端结点的位置分别

是rear->next->next和rear,查找时间都是O(1)。 若用头指针来表示该链表，则查找

终端结点的时间为O(n)。

三、关于删除链表最后一个元素

因为删除链表最后一个元素需要访问到终端结点的前驱结点，让该节点指向

NULL，再将终端结点free掉，因此应该采用双链表便于访问前驱结点。

其实删除首元素也是同理的应灵活分析，关键在于，进行删除或者插入操作，需

要先访问哪个节点，用哪种链表最容易访问到。
在这里插入图片描述
在这里插入图片描述

四、关于引用传参和指针传参

先看一下插入结点的这个操作：

void LinkList_Insert(LinkList L,int i) //传入指针
或者
void LinkList_Insert(LinkList &L,int i) //引用操作
{
    LinkList p,q;
    int x;
    p = LinkList_Search(L,i);
    q = new(LNode); //给形参分配内存
    cin >> x ;
    q->data = x;
    q->next = p->next;
    p->next = q;
}

这种情况下，这两种操作其实都可以，没有本质区别。但是指针传参和引用有时

还是不同的，下面做一下辨析。

1、传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为

原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参

变量的操作就是对其相应的目标对象（在主调函数中）的操作。

2、使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接

对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参

分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝

构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效

率和所占空间都好。

3、使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被

调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的形式进行

运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点

处，必须用变量的地址作为实参。而引用更容易使用，更清晰。

4、如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数

中被改变，就应使用常引用。

const int &d = c;
//常引用 是让 变量引用 具有只读属性 不能通过d 去修改c，但改变c会让d的值变
gaiyi7788
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在链表中使用头结点与尾指针
TITANIC上的小景
05-17 3万+
1 头结点 首先，不要被以下三个词组弄混了： 链表头：数据内容为第一个元素的结点。 头指针：指向头结点元素的指针。 头结点：数据内容无效，其指针是头指针。 一句话描述为：头指针是指向头结点的指针，头结点是指向链表头的结点。 对于一个链表来说，头指针和是一定存在的，是访问链表的入口，如果没有头指针则无法对其进行访问；链表头对于非空表来说是一定存在的，非空表则不存在。 注意到，如
五 . 动态链表
qq_36549593的博客
09-20 858
一 . 链表定义： 为了表示每个元素ai与其直接后继数据元素ai+1之间的逻辑关系，对数据元素ai来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的存储位置。我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称做指针域。指针域中存储的信息称作指针或链。这两部分信息组成数据元素ai的存储映像，称为结点（Node）。 n个结点（a1的存储映像）链结成一个链表，即为线性表（...
单链表的程序实现
dididisailor的博客
11-16 346
#include<stdio.h> //#include<malloc.h> #include<stdlib.h> typedef struct Node { int data; struct Node * pnext; }NODE, * PNODE; PNODE create_list() { PNODE phead=(PNODE)malloc(sizeof(NODE));
数据结构—链表
小芦荟同学的博客
08-06 696
链表 目录 一、概述 二、单链表 三、双链表 四、双指针 五、经典问题—反转链表 一、概述 1.链表是什么 2.链表的基本结构 3.链表的分类 4.链表和数组的比较 5.设计链表：源代码（含测试用例） 1.链表是什么 链表数一种线性数据结构。它是动态地进行储存分配的一种结构。 什么是线性结构，什么是非线性结构？ 线性结构是一个有序数据元素的集合。常用的线性结构有：线性表，栈，队列，双队列，数组，串。 非线性结构，是一个结点元素可能有多个直接前趋和多个直接后继。常见的非线性结构有：二维数组，多维数组，广义表，
【数据结构】单链表的头节点与尾节点
最新发布
m0_74195174的博客
04-20 1070
头节点和尾节点在单链表中的作用主要体现在简化链表操作和提高代码的可读性和可维护性。它们使得链表的插入、删除和遍历等操作更加高效和一致。然而，并不是所有的单链表实现都会使用头节点，这取决于具体的应用场景和需求。在某些情况下，为了节省内存空间或简化数据结构，可能会选择不使用头节点。这篇文章到这里就结束了如果觉得这篇博客对你有用的话，别忘记三连哦。我是豌豆射手^，让我们我们下次再见。
2021-01-17
平平无奇孤寡王的博客
01-17 440
栈的相关知识 1：栈和队列具有相同的逻辑结构，属于线性结构，只是他们的数据运算不同。 2：设链表不带头结点，且所有操作均在表头进行，不适合作为链栈的是： （1）：只有表头结点指针，没有表尾指针的单向循环链表。 （2）：只有表尾结点指针，没有表头指针的单向循环链表。 （1）中，表头结点指针通过遍历整个链表即可找到表尾结点指针。时间复杂度为O （n） （2）表尾结点指针可直接找到表头结点指针。时间复杂度为O（1）. 所以（1）不适合作为链栈。 3：关于C语言标识符：由数字，字母，下划线三部分构成，首字符不可以是
数据结构笔记：单向链表
12-22
分类目录——数据结构笔记 离散存储，手拉手，每一块有指向下一块的指针（形象描述，python中没有指针），就好像形成了一条链 一个元素包括两部分：value 和 next 链表与顺序表都是线性表 知识点补充 b = 20 a = 'a...
数据结构笔记：栈
01-20
分类目录——数据结构笔记](https://blog.csdn.net/bbjg_001/category_9753496.html) 栈（stack），有些地方也成为堆栈，是一种容器，可存储元素、访问元素、删除元素，他的特点是值能允许在容器的一段（称之为 栈顶...
数据结构高分笔记part1
10-30
这份“数据结构高分笔记part1”显然是为了帮助备考研究生入学考试的专业学生准备的，旨在提供深入的数据结构理解，助力他们在考试中取得优异成绩。 笔记可能涵盖以下几个关键知识点： 1. **基本概念**：首先，笔记...
数据结构复习笔记-静态链表
10-29
图和代码相结合，详细讲解静态链表。通过生动活泼的对话让读者理解内村动态申请。
数据结构学习笔记.zip
12-30
笔记：详细且系统的笔记，涵盖了数据结构的各个方面，从基础概念到复杂的数据结构如堆、B树等。这些笔记有助于你系统地复习和学习数据结构。 相关书籍推荐：为了更深入地理解数据结构，我们推荐了几本经典的教材和...
数据结构学习笔记
大雄号的博客
10-18 350
目录 第一部分 数据结构概述 一、定义（研究是数据结构的存储和数据的操作的） 二、算法 三、数据结构的地位 第二部分 预备知识 一、指针 二、结构体 三、动态内存的分配和释放 第三部分 模块一：线性结构 [把所有的结点用一条直线穿起来] 一、连续存储[数组] 二、离散存储[链表] 三、线性结构的两种常见应用之一 栈 四...
尾指针及其简单应用
Fabio的博客
08-14 7357
尾指针及其简单应用 循环链表如果拿到最后结点，若没有尾指针(rear)，那么需要O(n)的时间。如果有的话，只需要O(1)的时间。 如果有两个链表，需要将他们连接，拥有尾指针只需要O(1)的时间复杂度。 此时，判断循环链表是否为空的方法：rear是否等于rear-&gt;next。 一道题目：将两个线性表A(a1,a2,a3...)和B(b1,b2,b3...)连接成一个线性表。 思路：...
客观题测试-第2章线性表
a61233的博客
10-23 6403
由于链表的元素在内存中是分散存储的，访问特定元素需要从链表的头部开始逐个遍历节点，直到找到目标元素为止，因此链表不适用于随机存取。但是，链表在插入和删除元素方面具有优势，因为只需要修改指向目标元素的前一个节点的指针即可，无需移动其他元素。这是因为顺序存储方式需要在指定的位置插入或删除元素，而这个位置需要通过一定的计算才能得到，所以插入和删除的效率较低。因此，这个说法是错误的。3、在顺序表上可以从前向后顺序访问，也可以从后向前访问，还可以按元素序号随机访问，因此从查找的角度来看，顺序表比链表更灵活。
（含有头指针以及尾指针）单链表各类功能的实现
zyh_helen的专栏
04-30 7754
对单链表实现如下功能： void InitList(List *list); //初始化单链表 bool push_back(List *list,ElemType x); //尾插法 void show_seqlist(List *list); //显示链表内容 bool push_front(List *list,ElemType x);//头插法 b
循环链表尾指针
So_discrepancy的博客
10-28 4381
循环链表-尾指针
链表中的头和尾节点/指针的常规用法(来自:算法:C语言实现)
weixin_42480264的博客
08-10 3666
下面是基本链表处理操作的5种常规用法的实现.这类代码用于内嵌链表处理代码的简单应用中 循环,永远非空 头插入 head-&gt;next = head; 在x节点后插入t节点 t-&gt;next = x-&gt;next, x-&gt;next = t; 删除x后的节点 t = x-&gt;next, x-&gt;next = t-&gt;next, free(t); 遍历循环 t = h...
数据结构--循环链表--尾指针
qq_33531400的博客
11-22 1174
举个程序例子 要是将两个循环链表合并成一个表时，同尾指针就特别简单 操作的思路图如下   核心程序： p = rearA -&gt; next; rearA -&gt; next = rearB -&gt; next -&gt; next; rearB -&gt; next = p; free(p);  ...
数据结构学习笔记（王道）
12-29
数据结构学习笔记（王道）是一份针对考研数据结构的复习资料，由作者根据个人经验整理而成，旨在帮助备考者系统理解和掌握数据结构的核心概念。本文主要涵盖了数据结构的基础理论和核心概念。 首先，文章从数据结构...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值