数据结构：单链表

最新推荐文章于 2023-09-01 10:09:01 发布
最新推荐文章于 2023-09-01 10:09:01 发布
阅读量441 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yy_0733/article/details/97968056
本文详细介绍了链式存储结构及其优势，重点讲解了单链表的概念，它是由节点构成，每个节点包括数据域和指针域指向后继节点。讨论了单链表与顺序表的区别，并给出了单链表头插、尾插的操作，以及相关代码实现。

1、链式存储结构：在链式存储的过程中，每个元素Node不仅包含元素本身的信息，还包含元素之间的逻辑信息。前驱结点包含后继结点的地址信息（指针域），可以很方便的找到后继结点的位置。

2、链表：通过一组任意的存储单元来存储线性表中的数据元素，由一个个结点构成。

3、单链表：每个结点除包含数据域外，只设置一个指针域，来指向后继结点，这样构成的链表就是单链表。

      单链表是一种链式存取的数据结构，用一组任意地址空间（地址空间即存储单元）来存放线性表的数据元素。单链表中的数据是以节点的形式来表示，而节点是用结构体来描述，每个节点都是由元素和指针构成，即该结构体中包含两个成员变量：存放元素的成员变量和存放下一个节点地址的成员变量。单链表的节点结构为如下所示：

4、链表与顺序表的区别：

顺序表的特点为：逻辑相邻的两节点其物理地址也是相邻的；链表的特点为：逻辑相邻的两节点其物理地址不相邻。顺序表的存储方式是：节点元素连续存放在存储单元；链表的存储方式是：节点元素随机存放在存储单元。

5、单链表的结构：

6、单链表的头插

 

//头插法
bool Insert_head(List plist,int val)
{
	Node *p = (Node *)malloc(sizeof(Node));  //p即为新节点
	p->data = val;                           //p的data域设为val
	p->next = plist->next;                   //将plist存储的下一个节点的地址赋值给p
	plist->next = p;                         //将头结点的下一个节点设置为p
	return true;
}

7、单链表的尾插

 

 

//尾插法
bool Insert_tail(List plist,int val)
{
	//第一步，设置新节点
	Node *p = (Node *)malloc(sizeof(Node));
	assert(p != NULL);
	if(p == NULL)
	{
		return false;
	}
	p->data = val;
	//第二步，找尾节点
	Node *q;
	for(q = plist;q->next != NULL;q = q->next);
	//将p插入到q的后面
	p->next = q->next;
	q->next = p;
	return true;
	
}

8、完整代码

（1）list.h:

#pragma once
//带头节点的单链表
//单链表尾节点的next为NULL
//List为一条链表；Node *一个节点的地址
typedef struct Node
{
    int data; //数据
    struct Node *next;//下一个节点的地址
}Node,*List;//List == Node *

//初始化
void InitList(List plist);

//头插法
bool Insert_head(List plist,int val);

//尾插法
bool Insert_tail(List plist,int val);

//在pos下标插入数据val
bool Insert_pos(List plist,int pos,int val);

//查找，找到返回节点地址，没有找到返回NULL
Node *Search(List plist,int key);

//删除第一个key对应的节点
bool Delete(List plist,int key);

//删除第一个数据节点，并通过rtval获得删除的值
bool Delete_head(List plist,int *rtval);

//删除最后一个数据节点，并通过rtval获得删除的值
bool Delete_tail(List plist,int *rtval);

//获取长度，统计数据节点的个数
int GetLength(List plist);

//判空
bool IsEmpty(List plist);


//销毁所有节点
void Destroy(List plist);

//打印
void Show(List plist);

(2)list.cpp：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "list.h"

//初始化
void InitList(List plist) //List == Node *,plist即为头结点
{
	assert(plist != NULL);
	plist->next = NULL;

}

//头插法
bool Insert_head(List plist,int val)
{
	Node *p = (Node *)malloc(sizeof(Node));  //p即为新节点
	p->data = val;                           //p的data域设为val
	p->next = plist->next;                   //将plist存储的下一个节点的地址赋值给p
	plist->next = p;                         //将头结点的下一个节点设置为p
	return true;
}

//尾插法
bool Insert_tail(List plist,int val)
{
	//第一步，设置新节点
	Node *p = (Node *)malloc(sizeof(Node));
	assert(p != NULL);
	if(p == NULL)
	{
		return false;
	}
	p->data = val;
	//第二步，找尾节点
	Node *q;
	for(q = plist;q->next != NULL;q = q->next);
	//将p插入到q的后面
	p->next = q->next;
	q->next = p;
	return true;
	
}

//在pos下标插入数据val
bool Insert_pos(List plist,int pos,int val)
{
	//判断输入的位置是否正确
	if(pos < 0)
	{
		return false;
	}

	//找到pos位置的前一个节点
	Node *q;
	int i;
	for(i = 0,q = plist;q->next != NULL && i < pos;q = q->next,i++);

	Node *p = (Node *)malloc(sizeof(Node));
	p->data = val;
	p->next = q->next;
	q->next = p;
	return true;
}

//查找，找到返回节点地址，没有找到返回NULL
Node *Search(List plist,int key)
{
	assert(plist != NULL);
	for(Node *p = plist->next;p->next != NULL;p = p->next)
	{
		if(p->data == key)
		{
			return p;
		}
	}
	return NULL;
}

//查找key的前驱节点
static Node *SearchPri(List plist,int key)
{
	for(Node *p = plist;p != NULL;p = p->next)
	{
		if(p->next->data == key)
		{
			return p;
		}
	}
	return NULL;
}

//删除第一个key对应的节点
bool Delete(List plist,int key)
{
	Node *p = SearchPri(plist,key);
	if(p == NULL)
	{
		return false;
	}
	Node *q = p->next;  //q指向要删除的节点
	p->next = q->next;  //将q从链表中剔除
	free(q);            //释放内存

	return true;
}

//删除第一个数据节点，并通过rtval获得删除的值
bool Delete_head(List plist,int *rtval)
{
	if(plist->next  == NULL)
	{
		return false;
	}

	Node *p = plist->next;

	if(rtval == NULL)
	{
		*rtval = p->data;
	}

	plist->next = p->next;
	free(p);
	return true;
}

//删除最后一个数据节点，并通过rtval获得删除的值
bool Delete_tail(List plist,int *rtval)
{
	assert(plist != NULL);
	if(plist == NULL)
	{
		return false;
	}
	if(plist->next  == NULL)
	{
		return false;
	}
	Node *p = plist;//p为要删除的节点
	Node *q = p;   //q保存p的上一节点
	while(p->next!= NULL)
	{
		q = p;
		p = p->next;
	}
	if(rtval != NULL)
	{
		*rtval = q->data;
	}
	
	free(p);
	q->next = NULL;

	return true;

}

//获取长度，统计数据节点的个数
int GetLength(List plist)
{
	int count = 0;
	for(Node *p = plist->next;p != NULL;p = p->next)
	{
		count++;
	}
	return count;
}

//判空
bool IsEmpty(List plist)
{
	if(plist->next == NULL)
	{
		return true;
	}
	return false;
}


//销毁所有节点
void Destroy(List plist)
{
	Node *p;
	while(plist -> next != NULL)
	{
		p = plist->next;
		plist->next = p->next;
		free(p);
	}
}

//打印
void Show(List plist)
{
	if(IsEmpty(plist))
	{
		return;
	}
	for(Node *p = plist->next;p != NULL;p = p->next)
	{
		printf("%d ",p->data);
	}
	printf("\n");
}

（3）main.cpp:

#include <stdio.h>
#include "list.h"

int main()
{
    Node head;//CreateList();
    InitList(&head);

    //Node p;//Node *p
    //InitList(&p);
    for(int i=0;i<10;i++)
    {
		Insert_tail(&head,i);
	//Insert_head(&head,i);
    }

    Show(&head);
    
    Insert_pos(&head,0,-30);
	Show(&head);

    Insert_pos(&head,5,30);
	Show(&head);

    Insert_pos(&head,12,300);
	Show(&head);

    Insert_pos(&head,14,3000);
    Show(&head);

    Delete(&head,30);
	Show(&head);

    Delete(&head,-30);
	Show(&head);

    Delete(&head,300);
    Show(&head);
	
	int a;
	int *rtval = &a;
	Delete_tail(&head,rtval);
	Show(&head);

    Destroy(&head);
    Destroy(&head);
	Show(&head);

    return 0;
}

(4)OOP的实现：

class Link
{
public:
    Link()
    {
        phead=new Node;
    }
    ~Link()
    {
        Node*pcur=phead;
        while(pcur!=NULL)
        {
            phead=phead->pnext;
            delete phead;
            pcur=phead;
        }
    }
    void inserthead(int val)
    {
        Node*pcur=new Node(val);
        pcur->pnext=phead->pnext;
        phead->pnext=pcur;
    }
    void inserttail(int val)
    {
        Node*pcur=phead;
        while(pcur->pnext!=NULL)
        {
            pcur=pcur->pnext;
        }
        pcur->pnext=new Node(val);
    }
    void deleteNode(int val)
    {
        Node*pcur1=phead;
        Node*pcur2=phead->pnext;
        while(pcur2!=NULL)
        {
            if(pcur2->data==val)
            {
                pcur1->pnext=pcur2->pnext;
                delete pcur2;
                pcur2=pcur1->pnext;
            }
            else
            {
                pcur1=pcur2;
                pcur2=pcur2->pnext;
            }
        }
    }
    void show()
    {
        Node*pcur=phead->next;
        while(pcur!=NULL)
        {
            cout<<pcur->data<<" ";
            pcur=pcur->pnext;
        }
    }
 private:
    class Node
    {
     public:
        Node(int data):pdata(data),pnext(NULL){}
        int pdata;
        Node*pnext;
    };
    Node*phead;
};

 

 

【数据结构】单链表
无意呢的博客
01-18 304
单链表是一种线性数据结构，每个元素都存放在链表的一个结点中，结点之间由指针串联在一起，这样就形成了一条如同链的结构，固称作链表。**所谓单链表顾名思义就是只能单方向遍历的链表。**如下图所示： 单链表的基本操作 单链表最基本的操作包括创建一个单链表、向单链表中插入结点、从单链表中删除结点等。 java版本的实现 package dataStructure; public class N...
数据结构：单链表的基本操作
weixin_45213079的博客
08-17 1315
数据结构：单链表的基本操作
数据结构-单链表
ChrisChao1992的博客
12-29 156
1 #include <iostream> 2 #include <stdlib.h> 3 using namespace std; 4 //单链表 5 typedef struct LNode 6 { 7 int data; 8 struct LNode *next; 9 }LNode; ...
算法导论 单链表
梦幻DUO的游戏开发之路
09-17 676
单链表1. 单链表是什么？ 单链表是一种常见的简单数据结构，链表由很多个结点组成，每个结点有储存数据的数据域和指向下一个结点的地址。因为每个结点都有下一个结点的地址，因此通过当前结点可以找到下一个结点，将各种数据就像链子一样连接起来。相比于数组，链表的优点就是大小可以改变，删除和插入数据也不必作太大的改动，缺点是不可以随机访问（必须通过一个结点访问下一个结点来访问你想访问的结点）。 2. 单链表
单链表的实现
growth_path_的博客
04-26 330
typedef struct node { int data; node *next; }node; node* Create(); // 创建单链表 int length(node *head); // 计算单链表的长度 void print(node *head); ...
数据结构：单链表的创建与遍历及优化
最新发布
12-26
首先定义了链表的基本结构和操作，包括创建节点、添加节点、删除节点和遍历链表等。接着通过具体示例演示了如何在 Python 中实现单链表的基本操作。文章还讨论了链表在电话簿管理和音乐播放列表中的实际应用，并介绍...
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列
10-19
单链表是一种线性数据结构，每个元素（节点）包含两个部分：数据域和指针域。数据域存储实际的数据，而指针域指向下一个节点的地址。单链表的头节点通常用来初始化链表，其指针域指向第一个元素。插入和删除操作...
深入理解数据结构：单链表的实现与应用
在这个文件中，标题为“数据结构单链表”，描述了单链表的数据结构定义和源代码，同时也提到了运行结果，最后给出了相关的标签为“数据结构”和压缩包文件的名称。接下来，我将详细解释文件中包含的知识点。 首先，...
数据结构链表：单链表的代码实现
03-20
本文通过数据结构教程的方法利用C++语言写了单链表的各项功能 功能包括 1.链表的初始化 2.链表的查找和判断是否为空表 3.插入 4.取值 5.插入（尾插法） 6.链表的输出 7.//删除指定元素 8.//链表的释放 其中有着详细...
单链表的建立
Node_Su的博客
11-12 393
头插法建立 typedef struct LNode{ int data; struct LNode next; }LNode,*LinkList; LinkList Init(){ LinkList p = (LinkList)malloc(sizeof(LNode)); p->next = NULL; return p; } //L...
数据结构
这是一个菜鸡的博客
09-06 421
//数据结构对 int *p;的操作，其中开阔数组空间最重要 #include <stdio.h> #include <stdlib.h> typedef int ElemType; typedef int Status; #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define OK 1 #define ERROR 0 typedef
数据结构_P2
Pop_Rain的博客
06-01 445
预备知识：指针
数据结构_P6
Pop_Rain的博客
06-01 580
如何通过函数修改实参的值(i的值) --指针; 如何通过函数修改一个指针变量的值int *p中p的值 --也是指针
冰冰学习笔记：一步一步带你实现《单链表》
bingbing_bang的博客
04-26 1736
单链表会实现吗？这篇文章带你一步一步实现完整的单链表。 各位老铁，点赞收藏了！！！
一看就懂-c语言单向链表【初阶】
weixin_64524066的博客
01-07 2255
一篇一定能让你看懂的链表解析
c++使用malloc来做内存分配创建链表
feinifi的博客
12-02 2666
c++中创建链表可以直接通过new对象的方式创建节点，然后将节点之间的关系通过next指针来关联起来，另外，也可以通过malloc来分配内存，创建节点。这里介绍如何通过malloc来创建链表。 malloc分配内存的方式为malloc(sizeof(typename))，最后 还需要通过类型转换，将它转为(typename *)，如下所示： node *p=NULL; p =...
【数据结构回顾】
qq_42733748的博客
09-01 923
【代码】【数据结构回顾】
node* p 和 node *p 和 node * p 的区别
weixin_30460489的博客
12-26 3153
这其实是代码风格问题， node* p = node *p =node * p； 但是建议用 node *p的写法，因为这样方便定义多个指针变量。 比如： node *p,*a,*b； 就创建了3个node类型的指针变量。 转载于:https://www.cnblogs.com/Romanti...
探索数据结构: 单链表操作与逆序打印实现
单链表是一种常见的线性数据结构，由一系列节点组成，每个节点包含数据域和指向下一个节点的指针。在CodeBlocks软件中建立的工程文件夹内包含了对单链表的插入删除操作函数定义，意味着它可能涵盖了单链表的基本操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值