数据结构：单链表

最新推荐文章于 2023-09-01 10:09:01 发布
原创 最新推荐文章于 2023-09-01 10:09:01 发布 · 440 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了链式存储结构及其优势，重点讲解了单链表的概念，它是由节点构成，每个节点包括数据域和指针域指向后继节点。讨论了单链表与顺序表的区别，并给出了单链表头插、尾插的操作，以及相关代码实现。

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 922
【代码】【数据结构回顾】
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...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值