【数据结构--单链表】

已于 2022-10-06 19:26:49 修改
阅读量1.2k 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 链表 c语言
于 2022-04-30 00:20:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61719813/article/details/124506855
版权

文章目录

单链表

一、单链表的定义

​ 由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——单链表。

单链表示意图

在这里插入图片描述

二、线性表的链式存储结构

​ 线性表的链式存储结构：线性表中数据元素（结点）在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理位置上不一定相邻。

单链表的链式存储结构

在这里插入图片描述

三、单链表的实现

单链表存储结构代码
typedef struct Node
{
    char data;
    struct Node* next;
} Node,*LinkList;
初始化单链表
//初始化单链表
LinkList initLinkList()
{
    Node* LinkHead = (Node*)malloc(sizeof(Node));
    LinkHead->data = '\0';
    LinkHead->next = NULL;
    return LinkHead;
}
打印单链表
//打印单链表
void printList(Node* LinkHead)
{
    Node* p = LinkHead->next;
    while(p != NULL)
    {
        printf("%c",p->data);
        p = p->next;
    }
    printf("\n\n");
}
向单链表中添加元素
//向单链表中添加元素
void addElement(Node* LinkHead,char addChar)
{
    Node* p,*q;
    q = (Node*)malloc(sizeof(Node));
    q->data = addChar;
    q->next = NULL;
    p = LinkHead;
    while(p->next != NULL)
    {
        p = p->next;
    }
    p->next = q;
}
单链表的读取

思路：

（1）声明一个指针 p 指向链表第一个节点，初始化 j 从 1 开始；

（2）当j < i时，遍历链表，让p的指针向后移动，不断指向下一节点，j 累加1；

（3）若到链表末尾 p 为空，则说明第 i 个节点不存在；

（4）否则查找成功，打印节点 p 的数据。

代码如下：

//单链表的读取（打印单链表中第i个数据元素的值）
void GetElement(Node* LinkHead, int i)
{
    Node* p;
    p = LinkHead->next;
    int j = 1;
    while(p != NULL && j < i)
    {
        p = p->next;
        ++j;
    }
    if(p == NULL || j > i)
    {
        printf("Can't get it !\n\n");
        return ;
    }
    printf("The element at its %d-th position is %c\n\n",i,p->data);
}
单链表的插入

​ 设储存元素 e 的节点为 q ，若要实现将节点 q 插入到节点 p 和 p->next 之间，只需要让 q->next和 p->next 的指针做一点改变即可。

单链表的插入

单链表的插入
在这里插入图片描述

代码如下：

//单链表的插入
void ListInsert(Node* LinkHead, int position, char InsertChar)
{
    if(position <= 0)
    {
        printf("The position %d out of range of linked list!\n\n",position);
        return ;
    }
    Node* p, *q;
    p = LinkHead; 
    for(int i = 0; i < position; ++i)
    {
        p = p->next;
        if(p == NULL)
        {
            printf("The position %d out of range of linked list!\n\n ",position);
            return ;
        }
    }
    q = (Node*)malloc(sizeof(Node));
    q->data = InsertChar;
    q->next = p->next;
    p->next = q;
}
单链表的删除

​ 设存储元素 ai 的节点为 q，要实现将节点 q 删除单链表的操作，其实就是将它的前继节点的指针绕过，指向它的后继节点即可。

单链表的删除

在这里插入图片描述

代码如下：

//单链表的删除（删除第i个数据元素）
void ListDelete(Node* LinkHead, int i)
{
    int j = 1;
    Node *p, *q;
    p = LinkHead;
    while(p->next != NULL && j < i)
    {
        p = p->next;
        ++j;
    }
    if(p->next == NULL || j > i)
    {
        printf("Can't delete it!\n\n");
        return ;
    }
    q = p->next;
    p ->next = q->next;
    free(q);
}
单链表的整表删除

​ 当我们不打算使用这个单链表时，我们需要把它销毁，即在内存中将其释放，思路如下：

（1）声明一指针 p 和 q

（2）将第一个节点赋值给 p

（3）循环：

​ ① 将下一节点赋值给 q ；

​ ② 释放 p ；

​ ③ 将 q 赋值给 p 。

代码如下：

//单链表的整表删除
void ClearList(Node* LinkHead)
{
    Node *q,*p;
    p = LinkHead->next;
    while(p != NULL)
    {
        q = p->next;
        free(p);
        p = q;
    }
    LinkHead->next = NULL;
}
完整代码
#include <stdio.h>
#include <stdlib.h>

typedef struct Node
{
    char data;
    struct Node* next;
} Node,*LinkList;

//初始化单链表
LinkList initLinkList()
{
    Node* LinkHead = (Node*)malloc(sizeof(Node));
    LinkHead->data = '\0';
    LinkHead->next = NULL;
    return LinkHead;
}

//打印单链表
void printList(Node* LinkHead)
{
    Node* p = LinkHead->next;
    while(p != NULL)
    {
        printf("%c",p->data);
        p = p->next;
    }
    printf("\n\n");
}

//向单链表中添加元素
void addElement(Node* LinkHead,char addChar)
{
    Node* p,*q;
    q = (Node*)malloc(sizeof(Node));
    q->data = addChar;
    q->next = NULL;
    p = LinkHead;
    while(p->next != NULL)
    {
        p = p->next;
    }
    p->next = q;
}

//单链表的读取（打印单链表中第i个数据元素的值）
void GetElement(Node* LinkHead, int i)
{
    Node* p;
    p = LinkHead->next;
    int j = 1;
    while(p != NULL && j < i)
    {
        p = p->next;
        ++j;
    }
    if(p == NULL || j > i)
    {
        printf("Can't get it !\n\n");
        return ;
    }
    printf("The element at its %d-th position is %c\n\n",i,p->data);
}

//单链表的插入
void ListInsert(Node* LinkHead, int position, char InsertChar)
{
    if(position <= 0)
    {
        printf("The position %d out of range of linked list!\n\n",position);
        return ;
    }
    Node* p, *q;
    p = LinkHead; 
    for(int i = 0; i < position; ++i)
    {
        p = p->next;
        if(p == NULL)
        {
            printf("The position %d out of range of linked list!\n\n ",position);
            return ;
        }
    }
    q = (Node*)malloc(sizeof(Node));
    q->data = InsertChar;
    q->next = p->next;
    p->next = q;
}

//单链表的删除（删除第i个数据元素）
void ListDelete(Node* LinkHead, int i)
{
    int j = 1;
    Node *p, *q;
    p = LinkHead;
    while(p->next != NULL && j < i)
    {
        p = p->next;
        ++j;
    }
    if(p->next == NULL || j > i)
    {
        printf("Can't delete it!\n\n");
        return ;
    }
    q = p->next;
    p ->next = q->next;
    free(q);
}

//单链表的整表删除
void ClearList(Node* LinkHead)
{
    Node *q,*p;
    p = LinkHead->next;
    while(p != NULL)
    {
        q = p->next;
        free(p);
        p = q;
    }
    LinkHead->next = NULL;
}

//测试
void test()
{
    LinkList tempLinkList = initLinkList();
    printList(tempLinkList);

    //添加元素测试
    printf("--------------addElementTest--------------\n\n");
    addElement(tempLinkList,'I');
    addElement(tempLinkList,' ');
    addElement(tempLinkList,'l');
    addElement(tempLinkList,'o');
    addElement(tempLinkList,'v');
    addElement(tempLinkList,'e');
    addElement(tempLinkList,' ');
    addElement(tempLinkList,'d');
    addElement(tempLinkList,'a');
    addElement(tempLinkList,'t');
    addElement(tempLinkList,'a');
    addElement(tempLinkList,'!');
    printList(tempLinkList);

    //读取测试
    printf("--------------GetElementTest--------------\n\n");
    GetElement(tempLinkList,1);

    //插入测试
    printf("--------------ListInsertTest--------------\n\n");
    ListInsert(tempLinkList,12,'!');
    ListInsert(tempLinkList,14,'!');
    ListInsert(tempLinkList,-1,'!');
    printList(tempLinkList);

    //删除测试
    printf("--------------ListDeleteTest--------------\n\n");
    ListDelete(tempLinkList,13);
    ListDelete(tempLinkList,15);
    printList(tempLinkList);

    //清空测试
    printf("--------------ClearListTest--------------\n\n");
    ClearList(tempLinkList);
    printList(tempLinkList);
}

int main()
{
    test();
}
运行截图

在这里插入图片描述

闵版代码（略改）
#include <stdio.h>
#include <malloc.h>

/*
	Linked list of characters. The key is data.
*/

typedef struct LinkNode{
	char data;
	struct LinkNode* next;
} LNode,*LinkList,*NodePtr;

/*
	Initialize the list with a header.
	@return The pointer to the header.
*/

LinkList initLinkList()
{
	NodePtr tempHeader = (NodePtr)malloc(sizeof(LNode));
	tempHeader->data = '\0';
	tempHeader->next = NULL;
	return tempHeader;
}	// Off initLinkList

/*
	Print the list.
	@param paraHeader The header of the list.
*/

void printList(NodePtr paraHeader)
{
	NodePtr p = paraHeader->next;
	while(p != NULL)
	{
		printf("%c",p->data);
		p = p->next;
	}printf("\r\n");
}	//Off printList

/*
	Add an element to the tail.
	@param paraHeader The header of the list.
	@param paraChar the given char.
*/

void appendElement(NodePtr paraHeader, char paraChar)
{
	NodePtr p,q;

	// Step 1. Construct a new node.
	q = (NodePtr)malloc(sizeof(LNode));
	q->data = paraChar;
	q->next = NULL;

	// Step 2. Search to the tail.
	p = paraHeader;
	while (p->next != NULL)
	{
		p = p->next;
	}	//Off while 
	
	// Step 3. Now add/link.
	p->next = q;
}	//Off appendElement

/*
	Insert an element to the given position.
	@param paraHeader The header of the list.
	@param paraChar The given char.
	@param paraPosition The given position.
*/

void insertElement(NodePtr paraHeader,char paraChar,int paraPositon)
{
	NodePtr p,q;

	// Step 1. Search to the position.
	p = paraHeader;
	for(int i = 0; i < paraPositon; ++i)
	{
		p = p->next;
		if(p == NULL)
		{
			printf("The position %d is beyond the scope of the list.",paraPositon);
			return ;
		}	//Off if
	}	//Off for i

	// Step 2. Construct a new node.
	q = (NodePtr)malloc(sizeof(LNode));
	q->data = paraChar;

	// Step 3. Now link.
	printf("linking\r\n");
	q->next = p->next;
	p->next = q;
}	//Off insertElement

/*
	Delete an element from the list.
	@param paraHeader The header of the list.
	@param paraChar The given char.
*/

void deleteElement(NodePtr paraHeader,char paraChar)
{
	NodePtr p,q;
	 p = paraHeader;
	 while((p->next != NULL) && (p->next->data != paraChar))
	 {
		 p = p->next;
	 }	//Off while

	 if(p->next == NULL)
	 {
		 printf("Can't delete %c\r\n",paraChar);
		 return ;
	 }	//Off if

	 q = p->next;
	 p->next = q->next;
	 free(q);
}	//Off deleteElement

/*
	Unit test
*/

void appendInsertDeleteTest()
{
	// Step 1. Initialize an empty list.
	LinkList tempList = initLinkList();
	printList(tempList);

	// Step 2. Add some characters.
	appendElement(tempList,'H');
	appendElement(tempList,'e');
	appendElement(tempList,'l');
	appendElement(tempList,'l');
	appendElement(tempList,'o');
	appendElement(tempList,'!');
	printList(tempList);

	//Step 3. Delete some characters(the first occurence).
	deleteElement(tempList,'e');
	deleteElement(tempList,'a');
	deleteElement(tempList,'o');
	printList(tempList);

	// Step 4. Insert to a given position.
	insertElement(tempList,'o',1);
	printList(tempList);
}	//Off appendInsertDeleteTest

/*
	Address test: beyond the book.
*/

void basicAddressTest()
{
	LNode tempNode1,tempNode2;
	tempNode1.data = 4;
	tempNode1.next = NULL;
	tempNode2.data = 6;
	tempNode2.next = NULL;
	printf("The first node: %p, %p, %p\r\n",&tempNode1,&tempNode1.data,&tempNode1.next);
	printf("The second node: %p, %p, %p\r\n",&tempNode2,&tempNode2.data,&tempNode2.next);
}	//Off basicAddressTest

/*
	The entrance.
*/

int main()
{
	appendInsertDeleteTest();
	basicAddressTest();
}	//Off main

四、总结

​ 单链表与顺序表的简单对比：

  • 若线性表需要频繁查找，很少进行插入及删除操作时，宜采用顺序表

  • 当线性表中元素格式变化较大或不知道有多大时，最好采用单链表

总之，单链表和顺序表各有其优缺点，不能简单评判其好坏，应当根据实际情况，综合考虑使用哪种数据结构更优。

黎子想写好代码
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
数据结构-26个英文字母的存储
12-11
数据结构-26个英文字母的存储。呵呵，参考一下吧
线性表练习之Example001-创建不重复字母字符的单链表
二木成林
03-27 475
键盘输入 `n` 个英文字母，输入格式为`n、c1、c2、.…、cn`，其中 `n` 表示字母的个数。请编程用这些输入数据建立一个单链表，并要求将字母不重复地存入链表。
单链表的建立，把a~z 26个字母插入到链表中，并且倒叙，还要打印
costeeer的博客
01-25 2629
#include #include typedef struct linklist { char ff; struct linklist *next; }Node; typedef Node* Linklist; int main() { Linklist L, new; L = (Linklist)malloc(sizeof(Node)); L->next = NULL
c语言随机生成字母链表,C语言 尾插法建立单链表 插入26个英文字母
weixin_39616565的博客
05-16 577
C语言尾插法建立单链表插入26个英文字母0uosnmzer2016.09.13浏览131次分享举报#include #include #include /* run this program using the console pauser or add your own getch, system("pause") or input loop */ typedef struct LN...
26个字母单链表，实现插入，删除，查找操作
zy20167344的博客
11-20 2781
26个字母单链表，实现插入，删除，查找操作
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。 2.再从键盘输入顺序任意的5个整数，按有序插入的要求生成第二个有序单链表，将该链表输出显示。 3.将这两个有序单链表...
数据结构-C语言实现单链表-数据结构学习
05-26
C语言实现的数据结构中的单链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对链表边界的判定 实现了以下功能： 创建单链表 向顺序表中插入元素(头插法，尾插...
数据结构-单链表的操作
最新发布
06-28
数据结构-单链表的操作
数据结构--单链表操作--实验报告.doc
07-11
数据结构中的单链表是一种线性数据结构，由一系列节点（也称为元素或记录）组成，每个节点包含数据域和指针域。在本实验中，我们关注的是单链表的创建、查找、插入和合并等基本操作。实验的目标是通过Visual C++编程...
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（1）掌握线性表的顺序存储结构； （2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； ...
图书管理系统 链表索引
06-30
图书管理基本业务活动包括：对一本书的采编入库、清除库存、借阅和归还等等。由于上述四项基本业务活动都是通过书号（即关键字）进行的，所以要用链表对书号建立索引，以获的高效率。故重点是要完成B树的建立、查找、插入、删除等基本操作。 既为图书管理，就需要一个模块来完成对借阅者的注册、登记和记录借阅情况，本程序使用文件来完成上述操作。 演示程序是以用户于计算机的对话方式执行，这需要一个模块来完成使用者与计算机语言是转化。 程序执行时的命令： 本程序为了使用时的方便，采用菜单式的方式来完成程序的演示，几乎不用输入什么特殊的命令，只需按提示输入选者即可
数据结构——单链表的建立
晓风岚月
04-25 1791
引言 如果有很多个数据元素，要把它们存到一个单链表里边，咋办？ Step 1: 初始化一个单链表 Step 2:每次取一个数据元素，插入到表尾/表头 目录 一、尾插法 二、头插法 三、总结 一、尾插法 LinkList_List_TailInsert(LinkList &L){ //正向建立单链表 int x; //设ElemT...
单链表
w_45678910的博客
03-04 488
https://www.icourse163.org/learn/IDXY-1206905801?tid=1450771731#/learn/content?type=detail&id=1217619479 https://www.icourse163.org/learn/IDXY-1206905801?tid=1450771731#/learn/content?type=detail&id=1217619480&sm=1 一、静态链表 #include<stdio.
链表及索引
KwokWyman的博客
07-28 1042
链表中数据单位的名称叫做“结点”，结点和结点的分布在内存中可以是的。相对于数组来说，链表添加和删除元素都不需要挪动多余的元素高效的增删明确插入/删除的目标位置，只需要改变目标结点及其前驱/后继结点的指针指向麻烦的访问试图读取某一个特定的链表结点时，必须遍历整个链表来查找它在数组中直接访问索引可以做到一步到位。...
数据结构 二叉树 索引链表 及其索引话 输出
ACM2272902662的专栏
11-09 1144
#include #include using namespace std; class tree { public: char c; tree *lchild,*rchild; int ltag,rtag; }; char c; tree *pre; int main() { void build(tree * &p); void inthread(t
【数据结构】链表
程序员小潘
06-29 735
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 链表也是属于「线性表」的一种，它和数组最大的区别就是数据元素无需存储在一块连续的内存空间里。内存空间不连续了，那该如何判断元素之间的前后顺序呢？ ​ 链表要求每个节点除了保存数据元素本身，还需要包含一个或多个额外的指针，来指向它关联的元素，元.
写出单链表存储结构的C语言描述,数据结构第2章–2线性表的单链表存储结构.ppt...
weixin_42357837的博客
05-19 767
数据结构第2章–2线性表的单链表存储结构讨论： 例： 单链表的建立和输出 例：用单链表结构来存放26个英文字母组成的线性表(a，b，c，…，z),请写出C语言程序。 二、单链表的操作实现 定义单链表结点的结构体如下:typedef struct Node { DataType data; struct Node *next;}SLNode; １、初始化 void ListInitiat...
链表看这篇就够了
weixin_68993502的博客
08-09 373
Java链表
数组和链表
m0_37634615的博客
06-17 413
数组和链表 文章目录数组和链表剖析数组和链表的区别1.长度2.索引3.新增4.删5.改6.查7.内存分配数组的声明1.静态声明 说到数组和链表，一般会从长度、索引、增删改查的效率、内存分配等方面去剖析他们的区别。 剖析数组和链表的区别 1.长度 数组的长度是固定的，声明一个数组后长度就是固定的了；而链表是链式存储，可以随之延长。 2.索引 数组有索引，数组内每个元素的位置是有一个唯一的索引，并且有序；而链表虽说也是有序，但是没有索引，并不能知道某个节点在链表 3.新增 增：数组中新增一个元素的时候，必须
c语言数据结构--单链表 算法函数的实现(查找位序)
09-04
单链表是一种常见的数据结构，它由一个或多个节点组成，每个节点包含一个数据域和一个指针域，指针域指向下一个节点。 实现单链表的查找位序算法函数需要以下步骤： 1. 定义一个指针p指向链表的头节点，并定义一个...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

黎子想写好代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值