理论基础 —— 线性表 —— 单链表

最新推荐文章于 2023-06-15 07:14:50 发布
最新推荐文章于 2023-06-15 07:14:50 发布
阅读量1.1k 收藏 4
点赞数 1
分类专栏： # 理论基础——线性表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011815404/article/details/88363603
版权

【实现类】

单链表的基本思想就是用指针表示结点之间的逻辑关系，因此要正确的对指针变量、指针、指针所指结点、结点的值进行区分。

设 p 是一个指针变量，则 p 的值是一个指针，若指针 p 指向某个 Node 类型的结点，则该结点用 *p 来表示，并称 *p 为结点变量，有时为了叙述方便，常将 " 指针变量 " 称为 " 指针 "，将 " 指针 p 所指的结点 " 称为 " 结点 p "。

在单链表中，结点 p 由两个域组成，其中，存放数据元素的部分用 p->data 表示，其值是一个数据元素；存放后继结点地址的指针部分用 p->next 表示，其值是一个指针。

template <class T>
struct Node{//结点
    T data;//数据域
    Node *next;//指针域
};

template <class T>
class linkList{
private:
    Node<T> *first;//头指针
public:
    linkList();//无参构造函数
    linkList(T a[],int n);//有参构造函数
    ~linkList();//析构函数
    int getLength();//获取单链表的长度
    T getElement(int i);//获取单链表的第i个元素
    int getPosition(T x);//获取单链表中值为x的元素序号
    void insertElement(int i,T x);//在单链表中第i个位置插入值为x的元素
    T deleteElement(int i);//删除单链表的第i的元素
    void print();//按序号依次输出单链表各元素
};

【构造函数】

1.带头结点的构造函数

1）无参构造函数

带头结点的无参构造函数，只需要生成一个头结点，让头指针指向头结点，并将头结点的指针域置空。

template <class T>
linkList<T>::linkList(){//无参构造函数
    first=new Node<T>;//头指针指向头结点
    first->next=NULL;//头结点的指针域置为空
}

2）头插法的有参构造函数

头插法就是每次将新申请的结点插到头结点的后面，即始终让新结点在第一的位置。

使用头插法建立有参构造函数，首先应建立一个头结点，让头指针指向头结点，同时将头结点的指针域置空（与无参构造函数相同），此后，对于 n 个数组元素：

  • 建立一个结点，为结点的数据域赋值
  • 将新结点的指针域指向头结点的指针域所指向的地址
  • 令头结点的指针域指向新结点

template <class T>
linkList<T>::linkList(T a[],int n){//头插法的有参构造函数
    first=new Node<T>;
    first->next=NULL;

    for(int i=0;i<n;i++){
        Node<T> *s=new Node<T>;//建立一个新结点
        s->data=a[i];//为新结点的数据域赋值
        s->next=first->next;//将新结点的指针域指向头结点的指针域所指向的位置
        first->next=s;//令头结点的指针域指向新结点
    }
}

3）尾插法的有参构造函数

尾插法就是每次将新申请的结点插到终端结点的后面，即始终让新结点在最后的位置。

使用尾插法建立有参构造函数，首先应建立一个头结点，然后再建立一个尾指针，代表单链表中最后一个数据元素的位置。此后，对于 n 个数据元素：

  • 建立一个结点，为结点的数据域赋值
  • 将尾指针指针域指向新建立的结点
  • 更改尾指针地址为新结点地址

最后，当单链表建立完毕时，将尾指针的指针域置空

template <class T>
linkList<T>::linkList(T a[],int n){//尾插法的有参构造函数
    first=new Node<T>;
    Node<T> *r=first;//尾指针初始化
    for(int i=0;i<n;i++){
        Node<T> *s=new Node<T>;//建立一个新结点
        s->data=a[i];为新结点数据域赋值
        r->next=s;//尾指针指针域指向新结点
        r=s;//更改尾指针地址为新结点地址
    }
    r->next=NULL;//单链表建立完毕，将尾指针指针域置空
}

2.不带头结点的构造函数

1）无参构造函数

不带头结点的无参构造函数，只需让头指针指向为空。

template <class T>
linkList<T>::linkList(){//无参构造函数
    first=NULL;//头指针置为空
}

2）头插法的有参构造函数

头插法就是每次将新申请的结点插到头结点的后面，即始终让新结点在第一的位置。

使用头插法建立有参构造函数，首先令头指针置为空（与无参构造函数相同），此后，对于 n 个数组元素：

  • 建立一个结点，为结点的数据域赋值
  • 将新结点的指针域指向头指针所指向的地址
  • 更改头指针地址为新结点地址
template <class T>
linkList<T>::linkList(T a[],int n){//头插法的有参构造函数
    first=NULL;
    for(int i=0;i<n;i++){
        Node<T> *s=new Node<T>;//建立一个新结点
        s->data=a[i];//为新结点的数据域赋值
        s->next=first;//将新结点的指针域指向头指针所指向的地址
        first=s;//更改头指针地址为新结点地址
    }
}

 3）尾插法的有参构造函数

尾插法就是每次将新申请的结点插到终端结点的后面，即始终让新结点在最后的位置。

使用尾插法建立有参构造函数，首先令头指针置为空（与无参构造函数相同），再建立一个尾指针，代表单链表中最后一个数据元素的位置，然后建立一个初始结点，将其作为头结点：

  • 初始结点的数据域赋值为第 1 个数据元素的值
  • 初始结点的指针域指向头指针指向的地址
  • 更改头指针地址为初始结点地址
  • 更改尾指针地址为初始结点地址。

此后，对于 n 个数据元素：

  • 建立一个结点，为结点的数据域赋值
  • 将尾指针指针域指向新建立的结点
  • 更改尾指针地址为新结点地址
template <class T>
linkList<T>::linkList(T a[],int n){//尾插法的有参构造函数
    first=null;
    Node<T> *r=first;//尾指针初始化
    Node<T> *s=new Node<T>;//建立一个初始结点
    
    s->data=a[0];//为初始结点数据域赋值
    s->next=first;//初始结点指针域指向头指针的地址
    first=s;/更改头指针地址为初始结点地址
    r=first;//更改尾指针地址为新结点地址

    for(int i=1;i<n;i++){
        s=new Node<T>;//建立一个新结点
        s->data=a[i];为新结点数据域赋值
        r->next=s;//尾指针指针域指向新结点
        r=s;//更改尾指针地址为新结点地址
    }
}

 3.带头结点和不带头结点的单链表的比较

操作带头结点不带头结点
空表first=new node<T>;
first->next=NULL;		first=NULL
在空表中插入一个结点 s

Node<T> *s=new node<T>;

s->next=first->next;
first->next=s

Node<T> *s=new node<T>;

first=s;

插入一个结点，使其成为首元结点

Node<T> *s=new node<T>;

s->next=first->next;
first->next=s

Node<T> *s=new node<T>;

s->next=first;
first=s;

在某一结点 p 后插入结点 s

Node<T> *s=new node<T>;

s->next=p->next;
p->next=s

Node<T> *s=new node<T>;

s->next=p->next;
p->next=s;

【析构函数】

单链表中的结点是用 new 申请的，在释放单链表的对象时无法自动释放这些结点的存储空间，因此析构函数应将单链表中的结点的存储空间释放

template<class T>
linkList<T>::~linkList(){
    while(first!=NULL){
        Node<T> *q=first;//暂存要被释放的结点
        first=first->next;//first指向要被释放的结点的下一个结点
        delete q;//删除结点
    }
}

【获取线性表长度】

求单链表的长度时，在将单链表扫描同时建立一个累加器，直到扫描到链表尾，时间复杂度为 O(n)

template<class T>
int linkList<T>::getLength(){
    int count=0;//累加器
    Node<T> p=first->next;//工作指针
    while(p!=NULL){//p不为空
        p=p->next;//指向下一结点
        count++;//累加器+1
    }
    return count;
}

【查找元素】

1.按位查找

按位查找时，不能像顺序表按序号访问，只能从头指针出发顺着 next 域逐个结点向下搜索

  • 工作指针 p、位置累加器初始化
  • 直到 p 为空或指向第 i 个节点：工作指针后移、位置累加器+1
  • 若 p 为空，则第 i 个元素不存在，抛出位置异常；否则查找成功，返回节点 p 的数据元素
template<class T>
T linkList<T>::getElement(int i){
    int pos=1;//位置累加器
    Node<T> p=first->next;//工作指针
    while(p!=NULL&&pos<i){//p不为空且位置小于i
        p=p->next;//指向下一结点
        pos++;//累加器+1
    }
    if(p==NULL)
        throw "查找位置异常";
    else
        return p->data;//返回数据元素
}

2.按值查找

按值查找时，需要对单链表中的元素依次进行比较，时间复杂度为 O(n)

  • 工作指针 p、位置累加器初始化
  • 直到 p 为空：工作指针后移、位置累加器+1
  • 若在循环中找到元素，则返回序号，即位置累加器的值；若退出循环，则查找失败，单链表中没有相关值
template<class T>
int linkList<T>::getPosition(T x){
    int pos=1;//位置累加器
    Node<T> p=first->next;//工作指针
    while(p!=NULL){//p不为空
        if(p->data==x)//找到值
            return pos;//返回位置
        p=p->next;//指向下一结点
        pos++;//累加器+1
    }
    return 0;//查找失败
}

【插入操作】

1.带头结点的插入

在单链表中的第 i 个位置插入元素，需要先找到第 i-1 个元素，若找不到则抛出位置异常，若找到则将新结点插入位置 i

  • 工作指针 p 、位置计数器初始化
  • 查找第 i-1 个节点，并使工作指针 p 指向该节点
  • 若查找不成功(P==NULL)，说明位置错误，抛出位置异常，否则生成一个元素值为 x 的新节点 s，并将 s 插入到 p 之后
template<class T>
void linkList<T>::insertElement(int i,T x){
    int pos=0;//位置累加器
    Node<T> *p=first->next;//工作指针
    while(p!=NULL&&pos<i-1){//p不为空且位置小于i-1
        p=p->next;//指向下一结点
        pos++;//累加器+1
    }
    if(p==NULL)
        throw "插入位置异常";
    else{
        Node<T> *s=new Node<T>;//新申请一个结点
        s->data=x;//新结点数据域赋值为x
        s->next=p->next;//新结点s指向工作结点p之后的结点
        p->next=s;//工作结点p指向新结点s
    }
}

2.不带头结点的插入

不带头结点的插入与带头结点的插入十分相似，区别仅在于当插入位置是第一个位置时

template<class T>
void linkList<T>::insertElement(int i,T x){
    if(i==1){//若在第一个位置插入
        Node<T> *s=new Node<T>;//新申请一个结点
        s->next=first;//新结点的指针域指向头指针所指向的结点
        first=s;//令头指针指向新结点
        return;
    }

    int pos=1;//位置累加器
    Node<T> *p=first;//工作指针
    while(p!=NULL&&pos<i-1){//p不为空且位置小于i-1
        p=p->next;//指向下一结点
        pos++;//累加器+1
    }
    if(p==NULL)
        throw "插入位置异常";
    else{
        Node<T> *s=new Node<T>;//新申请一个结点
        s->data=x;//新结点数据域赋值为x
        s->next=p->next;//新结点s指向工作结点p之后的结点
        p->next=s;//工作结点p指向新结点s
    }
}

【删除操作】

在单链表中删除第 i 个位置的元素，需要先找到第 i-1 个元素，若找不到则抛出位置异常，若找到将第 i-1 个结点指针域所指向的结点删除

  • 工作指针 p 、位置计数器初始化
  • 查找第 i-1 个节点，并使工作指针 p 指向该节点
  • 若查找不成功(P==NULL)，说明位置错误，抛出位置异常，否则将被删结点从链表中摘下并释放存储空间

template<class T>
T linkList<T>::deleteElement(int i){
    int pos=0;//位置累加器
    Node<T> *p=first;//工作指针
    while(p!=NULL&&pos<i-1){//p不为空且位置小于i-1
        p=p->next;//指向下一结点
        pos++;//累加器+1
    }

    if(p==NULL||p->next!=NULL)//p不存在或p的后继结点不存在
        throw "删除位置异常";
    else{
        Node<T> *s=p->next;//暂存被删结点
        T x=p->data;
        p->next=s->next;//摘链
        delete s;//释放空间
        return x;
    }
}

【遍历输出】

遍历输出即按照单链表的指针指向依次输出线性表各元素

  • 建立一个临时结点，令临时结点地址为头指针指向的结点
  • 当临时结点不为空时，输出数据域，并指向下一结点
template <class T>  
void LinkList<T>:: print(){//依次输出线性表各元素
    Node<T> *p;//新建一个临时结点
    p=first->next;//令临时结点地址为头指针所指向的结点
    while(p!=NULL){//当临时结点不为空时
        cout<<(p->data)<<endl;//输出数据域
        p=p->next;//指向下一结点
    }
}

 

Alex_McAvoy
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验——线性表子系统
07-31
在这个实验中，我们主要关注线性表的链式存储结构，特别是字符型的单链表。实验的目标是理解线性表的特点，掌握顺序存储和链式存储结构的基本操作，包括创建、插入、删除和显示线性表中的元素。 在C语言中，我们...
c语言中指针中 -＞ 和 。的区别？
魏波
09-12 2224
c语言中指针中 -> 和 。的区别？
数据结构，单链表及一些题目
JACKSONMHLK的博客
05-18 329
数据结构中，一个常用的数据结构--链表。 struct LNode { int val; LNode* next; }LNode, *Linklist; 首先，了解一下
lesson7-2 有一个表头为first的单链表，设计一个算法，通过遍历一趟链表，将链表中所有结点按逆序链接
csdner1998的博客
08-13 1646
思路： 头插法建立一个新表。 *表头为first就是链表的第一个结点，无论这个单链表带不带头结点。 代码： void reverse(LNode *first){//不妨令链表带头结点 LNode *p=first->next; LNode *q=p->next; first->next=NULL; while(p){ p->next=first->next; first->next=p; p=q; if(q) q=q->ne
数据结构 study 3：单链线性表 表头指针 结点指针
abc
08-19 810
数据结构 是用来解决现实生活中或者实际项目中遇到的问题的 那么在实际的项目中，会遇到哪些问题呢？ 有两组任意的数据 ， 假设为:La= {1， 2， 3， 4 ，5}， Lb= {2， 4， 6， 8， 10}. 将这两组数据 组合存放到一块。 变成一个新的组合:Lc = {1, 2, 3, 4, 5, 6, 8, 10}. 如何用 单链线性表的方式 实现呢？ ...
C语言 _ 指针（超详解析 3分钟完全掌握 总结性讲解 经典通俗）
热爱技术！
01-04 1252
用一句话概述：指针就是地址！ 指针 指针变量 指针的大小 指针类型 指针的解引用 指针运算 野指针 指针和数组 二级指针 指针数组 用一句话概述：指针就是地址！一个指针变量的大小就应该是8个字节。指针的定义方式是： type + * 。指针的类型决定了指针向前或者向后走一步有多大（距离）。 总结：1.对指针解引用代表指针所指目标，访问几个字节取决于指针的类型 2.对指针解引用可以看到sizeof（type）个数据 对指针加减1，其实是加减所指向类型的大小，既sizeof（type），
算法-理论基础- 线性表- 双向链表（包含源程序）.rar
09-16
线性表是计算机科学中数据结构的基础概念之一，它是由相同类型元素构成的有序序列。在实际应用中，线性表的实现方式多种多样，包括数组、链表等。本主题将聚焦于线性表的一个特殊形式——双向链表。双向链表与单链表...
数据结构——用C描述
12-15
总结起来，数据结构——用C描述主要涵盖了线性表的理论和实现，包括顺序存储和链式存储的特性，以及在实际操作中如何维护数据结构的完整性和效率。理解并熟练掌握这些基础知识对于进行有效的算法设计和程序编写至关...
《数据结构——用C语言描述》+课后题答案
11-15
总的来说，《数据结构——用C语言描述》这本书全面覆盖了数据结构的基础知识，通过实例和习题解答帮助学习者巩固理论并提升编程能力。对于计算机科学和软件工程专业的学生，或是想要深入理解数据结构的开发者来说，...
线性表实验报告.doc
03-11
实验中，我们使用了C语言实现了线性表的链式存储结构——单链表。单链表中，每个节点仅包含一个指针域，指向其后继节点。以下是实现单链表的一些关键操作： - 创建单链表：从用户输入读取数据，直到遇到终止标志...
链表的节点与指针 （重新理解）
热门推荐
nsjlive的博客
02-28 2万+
下图为头指针与头结点以及首元结点的关系。 链表定义：c语言 typedef struct LinkList { ...
数据结构之单链表的实现
sinkill345的博客
10-12 209
简要的单链表
数据结构——单链表的实现
weixin_46024145的博客
06-08 1161
一、单链表的定义 template <typename DataType> class LinkList { public: LinkList(); //建立只有头结点的单链表； LinkList(DataType a[], int n); //建立n个元素的单链表； ~LinkList(); //析构函数； int Length(); //求单链表的长度； DataType Get(int i); //按位查找，查找第i个结点的元素值； int Locate
【初识C语言】指针和指针变量
yycure的博客
08-16 467
文章目录1.指针2.指针变量2.1概念2.2指针变量大小2.3指针变量理解2.4举例 1.指针 指针就是地址（即一个数据）。 2.指针变量 2.1概念 （1）指针变量是变量，是变量在内存中就会开辟空间，会有自己对应的的地址，有自己的变量大小。 （2）指针变量里放的内容是地址（即指针）。 2.2指针变量大小 32位平台下，4字节。 48位平台下，8字节。 2.3指针变量理解 #include <stdio.h> int main() { int a = 10; int b = 20; i
数据结构 -- 单链表创建之头插法和尾插法
ithang的专栏
01-18 1299
头插法：需要保证每次插入的新节点，都是链表的首节点。 尾插法：需要保证每次插入的新节点，都是链表的最后一个节点，且其指向的下一个节点为NULL 一下代码在 vs2010 上测试通过： #include "stdafx.h" #include #include #define TRUE 1 #define FALSE 0 typedef struct NODE{ int value
单链表
cqc1161的博客
11-09 754
单链表 一、实验目的 巩固线性表的数据结构的存储方法和相关操作，学会针对具体应用，使用线性表的相关知识来解决具体问题。 二、实验内容 建立一个由n个学生成绩的顺序表，n的大小由自己确定，每一个学生的成绩信息由自己确定，实现数据的对表进行插入、删除、查找等操作。分别输出结果。 三、详细设计（C++） 1.算法设计 定义顺序表的数据类型——单链表类，包括插入、删除、查找、遍历等基本操作。
线性表---单链表
最新发布
qq_43216283的博客
06-15 152
/数据域 struct LinkList * next;//指针域 } LTNode;
线性表
MbaAlienware的博客
03-25 462
线性表的存储结构及实现线性表的逻辑结构线性表的Java接口定义线性表的顺序存储结构及实现顺序表的存储结构顺序表的实现顺序表的存储结构实现顺序表算法顺序表的使用线性表的链接存储结构及实现单链表的存储结构单链表的实现单链表的使用 线性表的逻辑结构   线性表(linear list)简称表，是n(n ≥\geq≥ 0)个数据元素的有限序列，线性表中的数据元素的个数称为线性表的长度。长度等于零的线性表称...
头插法和尾插法
眼泪划过的星空
03-12 570
简单来说： 头插法：将每次新的结点插在最前面 尾插法：将每次新的结点插在最后面 注意：设一个空的头结点，不含data #include<stdio.h> #include<stdlib.h> typedef struct Node{ int data; struct Node* next; }node; node* BuildList1(int num)//头插法 {//建造一个空的头结点 node* head = (node* )malloc(sizeof(node)
数据结构线性表的实现与应用完整版 (2).docx
11-12
...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值