【数据结构】—— 单链表(single linked list)

已于 2024-07-10 09:37:25 修改
阅读量1.3k 收藏 32
点赞数 19
分类专栏： # 线性表 文章标签： 数据结构 c语言
于 2024-07-08 19:51:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xasdf338/article/details/140177122
版权

文章目录

1、单链表的定义

单链表（Singly LinkedList）是一种链式存储的数据结构，它由一系列节点组成，每个节点包含两部分：数据部分（存储数据元素）和指针部分（指向下一个节点的指针）。

在这里插入图片描述

优点和缺点

优点：简单易实现，插入和删除操作只需调整指针，时间复杂度为 O(1)。
缺点：不支持随机访问，访问某个节点的时间复杂度为 O(n)，并且需要额外的空间来存储指针。

单链表的构成

单链表由一系列节点构成，每个节点存储当前节点的数据和指向下一个节点的指针。

typedef struct SListNode
{
	SLDateType date;//存储当前节点的数据
	struct SListNode* next;//存储下一个节点的地址
	//struct SLNode* next;为什么这里不能用SLNode替换，因为程序运行到这个位置还没有成功typedef，因此提前使用会报错
}SLNode;

2、单链表的创建

初始化：

通过定义头节点来管理链表，头指针指向单链表的第一个节点，头节点内通常不存储数据，因此对头指针悬空即可。

SLNode* plist = (SLNode*)malloc(sizeof(SLNode));//动态分配内存
plist->next=NULL;//头指针悬空

Q:为什么使用malloc

1）动态分配内存: malloc 允许在程序运行时动态分配内存，我们可以动态地创建新的节点，而不必预先知道节点的数量或者大小。
2）避免静态内存限制：可以在运行时根据需要分配内存，灵活性更高。
3）内存生命周期管理:malloc分配的内存块无需free函数释放，避免内存泄漏问题，即程序运行过程中持续占用未使用的内存。

3、单链表的接口实现

打印

创建节点pcur从头节点开始遍历链表，直到pcur为空为止

void SLPrint(SLNode* headList)
{
	SLNode* pcur = headList;//头节点
	while (pcur)
	{
		printf("%d->", pcur->date);//打印当前节点的数据
		pcur = pcur->next;//指向下一个节点
	}
	printf("NULL\n");
}

申请节点函数
对申请节点功能进行封装，方便调用。

SLNode* SLBuyNode(SLDateType x)//封装
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));//创建新节点:malloc默认返回void*类执政，这里强制转换为SLNode*指针类型
	if (newnode == NULL)//如果malloc申请失败直接退出
	{
		perror("malloc fail");
		exit(1);
	}
	newnode->date = x;
	newnode->next = NULL;
	return newnode;
}

尾插

从头节点开始遍历，直到节点的next指向NULL后进行尾插。
Q:为什么使用二级指针

为了能够修改函数外部传入的单链表头指针的值,传入的是&plist,如果使用SLNode*phead会导致函数内部无法修改函数外部传入的头指针。因此这里应该采用传址调用而不是传值调用，用二级指针SLNode**pphead接收传入头节点的地址。
在这里插入图片描述

在这里插入图片描述

void SLPushBack(SLNode** pphead, SLDateType x){
	assert(pphead);
	SLNode* newnode=SLBuyNode(x);//调用申请节点函数
	//链表为空，新节点作为head
	if (*pphead == NULL) {//解引用一次，即为第一个节点的地址
		*pphead = newnode; 
		newnode->next = NULL; //新节点指向NULL
		return;
	}
	//链表不为空，找到尾节点
	SLNode* TailList = *pphead;//解引用一次，即为第一个节点的地址
	while (TailList->next)//当下一个节点不为NULL时继续循环
	{
		TailList = TailList->next;
	}
	//结束while后TailList即为尾节点,使尾节点指向新节点(更新尾节点)
	TailList->next = newnode;
	newnode->next = NULL;
}

头插

传入头节点直接插入即可

void SLPushFront(SLNode** pphead, SLDateType x)
{
	SLNode* newnode = SLBuyNode(x);//调用申请节点函数
	newnode->next = *pphead;
	*pphead = newnode;
}

尾删

分两种情况，当链表只有一个节点，直接删除头节点即可。否则遍历链表找到尾节点并删除。

在这里插入图片描述
注意：不能传入空地址

void SLPopBack(SLNode** pphead)
{
	assert(pphead);
	assert(*pphead);//链表不能为空(*pphead指向第一个节点的地址)
	//两种情况： 
	// 1）当链表只有一个节点 
	if ((*pphead)->next == NULL)
	{
		//释放动态分配的内存,提高系统的资源利用率和性能
		free(*pphead);
		*pphead = NULL;
		return;
	}
	// 2）链表有多个节点
	SLNode* ptail = *pphead;
	SLNode* newLnode = NULL;
	while (ptail->next)
	{
		newLnode = ptail;
		ptail = ptail->next;
	}
	//跳出后newLnode更新为最后一个节点
	newLnode->next = NULL;
	//销毁尾节点
	free(ptail);//释放内存
	ptail = NULL;
}

头删

创建节点保存要删除的节点，更新头节点，最后删除已经保存的节点

void SLPopFront(SLNode** pphead)
{
	assert(pphead);
	assert(*pphead);//链表不为空
	SLNode* head = *pphead;//保存要删除的节点
	*pphead = (*pphead)->next;//->的优先级高于*
	free(head);
	head = NULL;
}

查找

从头节点遍历链表，找到返回节点，否则返回-1

SLNode* SLFind(SLNode** pphead, SLDateType x)
{
	assert(pphead);//不能传NULL

	//遍历链表
	SLNode* pcur = *pphead;
	while (pcur!=NULL)
	{
		if (pcur->date == x) {//找到了返回节点
			return pcur;
		}
		pcur = pcur->next;
	}
	//没找到
	return NULL;
}

在指定位置之前插入

分两种情况，指定位置为头节点直接插入即可，否则从头节点开始遍历找到指定位置前一个结点prev，(修改对应指针连接)重新连接prev（指定位置前一个结点）,newnode（插入的节点），pos（指定的位置）
在这里插入图片描述

void SLInsert(SLNode** pphead, SLNode* pos, SLDateType x){
	assert(pphead);
	assert(pos);//pos是链表中某一个有效节点
	//要加上链表不能为空
	assert(*pphead);

	SLNode* newnode = SLBuyNode(x);//申请节点
	//pos刚好是头节点
	if (pos == *pphead) {
		SLPushFront(*pphead, x);
		return;
	}

	//找pos的前驱节点
	SLNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	//重新连接 prev->newnode->pos
	prev->next = newnode;
	newnode->next = pos;
}

在指定位置之后插入

申请节点后直接插入即可（注意传入的节点不能是NULL）

void SLInsertAfter(SLNode* pos, SLDateType x) {
	assert(pos);

	SLNode* newnode = SLBuyNode(x);//申请新节点

	//pos->newnode->(pos->next)
	//先将newnode指向下一个节点
	newnode->next = pos->next;
	pos->next = newnode;
}

删除指定位置的节点

分两种情况：如果pos为头节点，直接调用SLPopFront()进行删除，否则遍历链表找到指定节点后进行删除。

void SLErase(SLNode** pphead, SLNode* pos) {
	assert(pphead);
	assert(*pphead);//头节点不为NULL
	assert(pos);

	//pos刚好是头节点
	if (*pphead == pos) {
		SLPopFront(pphead);
		return;
	}

	SLNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);//释放空间
}

删除指定位置之后的节点

删除后释放空间即可

void SLEraseAfter(SLNode* pos) {
	assert(pos);
	assert(pos->next);
	SLNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

销毁链表

通过遍历删除所有节点

void SListDesTroy(SLNode** pphead) {
	assert(pphead);
	assert(*pphead);

	SLNode* pcur = *pphead;
	while (pcur)
	{
		SLNode* next = pcur->next;
		free(pcur);//删除节点
		pcur = next;
	}
	*pphead = NULL;
}

4、源代码

.h文件

#pragma once//防止头文件被二次引用
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDateType;
//链表由节点组成
typedef struct SListNode
{
	SLDateType date;//存储当前节点的数据
	struct SListNode* next;//存储下一个节点的地址
	//struct SLNode* next;为什么这里不能用SLNode替换，因为程序运行到这个位置还没有成功typedef，因此提前使用会报错
}SLNode;
//打印链表
void SLPrint(SLNode* phead);

//二级指针接受一级指针
void SLPushBack(SLNode** pphead,SLDateType x);//尾插
void SLPushFront(SLNode** pphead, SLDateType x);//头插

void SLPopBack(SLNode** pphead);//尾删
void SLPopFront(SLNode** pphead);//头删

//查找
SLNode* SLFind(SLNode** pphead, SLDateType x);

//在指定位置之前插入数据
void SLInsert(SLNode** pphead, SLNode* pos, SLDateType x);

//在指定位置之后插入数据
void SLInsertAfter(SLNode* pos, SLDateType x);

//删除指定位置的节点
void SLErase(SLNode** pphead, SLNode* pos);

//删除指定位置之后的节点
void SLEraseAfter(SLNode* pos);

//销毁链表
void SListDesTroy(SLNode** pphead);

**

.c文件

**

#include "SList.h"

void SLPrint(SLNode* headList)
{
	SLNode* pcur = headList;//头节点
	while (pcur)
	{
		printf("%d->", pcur->date);//打印当前节点的数据
		pcur = pcur->next;//指向下一个节点
	}
	printf("NULL\n");
}
//申请节点的函数
SLNode* SLBuyNode(SLDateType x)//封装
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));//创建新节点:malloc默认返回void*类执政，这里强制转换为SLNode*指针类型
	if (newnode == NULL)//如果malloc申请失败直接退出
	{
		perror("malloc fail");
		exit(1);
	}
	newnode->date = x;
	newnode->next = NULL;
	return newnode;
}
//尾插
void SLPushBack(SLNode** pphead, SLDateType x){
	assert(pphead);
	SLNode* newnode=SLBuyNode(x);//调用申请节点函数
	//链表为空，新节点作为head
	if (*pphead == NULL) {//解引用一次，即为第一个节点的地址
		*pphead = newnode; 
		newnode->next = NULL; //新节点指向NULL
		return;
	}
	//链表不为空，找到尾节点
	SLNode* TailList = *pphead;//解引用一次，即为第一个节点的地址
	while (TailList->next)//当下一个节点不为NULL时继续循环
	{
		TailList = TailList->next;
	}
	//结束while后TailList即为尾节点,使尾节点指向新节点(更新尾节点)
	TailList->next = newnode;
	newnode->next = NULL;
}
//头插
void SLPushFront(SLNode** pphead, SLDateType x)
{
	SLNode* newnode = SLBuyNode(x);//调用申请节点函数
	newnode->next = *pphead;
	*pphead = newnode;
}

void SLPopBack(SLNode** pphead)
{
	assert(pphead);
	assert(*pphead);//链表不能为空(*pphead指向第一个节点的地址)
	//两种情况： 
	// 1）当链表只有一个节点 
	if ((*pphead)->next == NULL)
	{
		//释放动态分配的内存,提高系统的资源利用率和性能
		free(*pphead);
		*pphead = NULL;
		return;
	}
	// 2）链表有多个节点
	SLNode* ptail = *pphead;
	SLNode* newLnode = NULL;
	while (ptail->next)
	{
		newLnode = ptail;
		ptail = ptail->next;
	}
	//跳出后newLnode更新为最后一个节点
	newLnode->next = NULL;
	//销毁尾节点
	free(ptail);
	ptail = NULL;
}


void SLPopFront(SLNode** pphead)
{
	assert(pphead);
	assert(*pphead);//链表不为空
	SLNode* head = *pphead;//保存要删除的节点
	*pphead = (*pphead)->next;//->的优先级高于*
	free(head);
	head = NULL;
}

SLNode* SLFind(SLNode** pphead, SLDateType x)
{
	assert(pphead);//不能传NULL

	//遍历链表
	SLNode* pcur = *pphead;
	while (pcur!=NULL)
	{
		if (pcur->date == x) {//找到了返回节点
			return pcur;
		}
		pcur = pcur->next;
	}
	//没找到
	return NULL;
}

void SLInsert(SLNode** pphead, SLNode* pos, SLDateType x){
	assert(pphead);
	assert(pos);//pos是链表中某一个有效节点
	//要加上链表不能为空
	assert(*pphead);

	SLNode* newnode = SLBuyNode(x);//申请节点
	//pos刚好是头节点
	if (pos == *pphead) {
		SLPushFront(*pphead, x);
		return;
	}

	//找pos的前驱节点
	SLNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	//重新连接 prev->newnode->pos
	prev->next = newnode;
	newnode->next = pos;
}

void SLInsertAfter(SLNode* pos, SLDateType x) {
	assert(pos);

	SLNode* newnode = SLBuyNode(x);//申请新节点

	//pos->newnode->(pos->next)
	//先将newnode指向下一个节点
	newnode->next = pos->next;
	pos->next = newnode;
}

void SLErase(SLNode** pphead, SLNode* pos) {
	assert(pphead);
	assert(*pphead);//头节点不为NULL
	assert(pos);

	//pos刚好是头节点
	if (*pphead == pos) {
		SLPopFront(pphead);
		return;
	}

	SLNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);
}

void SLEraseAfter(SLNode* pos) {
	assert(pos);
	assert(pos->next);
	SLNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

void SListDesTroy(SLNode** pphead) {
	assert(pphead);
	assert(*pphead);

	SLNode* pcur = *pphead;
	while (pcur)
	{
		SLNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

**

测试文件

**

#include "SList.h"

void SListTest01() 
{
	//新建节点
	/*Q:为什么使用malloc
	1）动态分配内存: malloc 允许在程序运行时动态分配内存，我们可以动态地创建新的节点，而不必预先知道节点的数量或者大小。
	2）避免静态内存限制：可以在运行时根据需要分配内存，灵活性更高。
	3）内存生命周期管理:malloc分配的内存块无需free函数释放，避免内存泄漏问题，即程序运行过程中持续占用未使用的内存。
	创建链表，方便展示链表打印*/
	SLNode* node1 = (SLNode*)malloc(sizeof(SLNode));//malloc默认返回void*类执政，这里强制转换为SLNode*指针类型
	node1->date = 1;//存储node1的数据
	SLNode* node2 = (SLNode*)malloc(sizeof(SLNode));
	node2->date = 2;
	SLNode* node3 = (SLNode*)malloc(sizeof(SLNode));
	node3->date = 3;
	SLNode* node4 = (SLNode*)malloc(sizeof(SLNode));
	node4->date = 4;
	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = NULL;
	SLNode* headList = node1;
	SListPrint(headList);
}

//测试尾插
void SListTest02()
{
	SLNode* plist = NULL;
	SLPushBack(&plist, 1);///plist本身是一级指针
	//现在对一级指针取地址，此时为二级指针，且必须用二级指针接受一级指针的地址
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 2);
	SLPrint(plist);
	//SLPushBack(NULL, 1);
	//SLPrint(NULL);
	//说明传入地址不能为空
}

void SListTest03() {
	SLNode* plist = NULL;
	SLPushFront(&plist, 1);
	SLPrint(plist);
	SLPushFront(&plist,3);
	SLPushFront(&plist,5);
	SLPrint(plist);
}

void SListTest04() {
	SLNode* plist = NULL;
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 5);
	SLPopBack(&plist);
	SLPrint(plist);//为什么打印就不用传地址
}

void SListTest05() {
	SLNode* plist = NULL;
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 5);
	SLPopFront(&plist);
	SLPrint(plist);//为什么打印就不用传地址
}

void SListTest06() {
	SLNode* plist = NULL;
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 5);
	SLPrint(plist);//为什么打印就不用传地址
    SLNode* node1=SLFind(&plist,3);
	if (node1) printf("找到了\n");
	else printf("未找到\n");
	SLNode* node2 = SLFind(&plist,4);
	if (node2) printf("找到了\n");
	else printf("未找到\n");
}

void SListTest07() {
	SLNode* plist = NULL;
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 5);
	SLPrint(plist);
	SLNode* FindRet = SLFind(&plist, 3);//返回链表中3的节点
	SLInsert(&plist, FindRet, 999);
	SLPrint(plist);
}

void SListTest08() {
	SLNode* plist = NULL;
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 5);
	SLPrint(plist);
	SLNode* FindRet = SLFind(&plist, 3);//返回链表中3的节点
	SLInsertAfter(FindRet, 999);
	SLPrint(plist);
}

void SListTest09() {
	SLNode* plist = NULL;
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 5);
	SLPrint(plist);
	SLNode* FindRet = SLFind(&plist, 3);//返回链表中3的节点
	SLErase(&plist, FindRet);
	SLPrint(plist);
}

void SListTest10() {
	SLNode* plist = NULL;
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 5);
	SLPrint(plist);
	SLNode* FindRet = SLFind(&plist, 3);//返回链表中3的节点
	SLEraseAfter(FindRet);
	SLPrint(plist);
}

void SListTest11() {
	SLNode* plist = NULL;
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 5);
	SLPrint(plist);
	SListDesTroy(&plist);
	SLPrint(plist);
}

int main()
{
	//SListTest01();//测试打印
	//SListTest02();//尾插
	//SListTest03();//头插
	//SListTest04();//尾删
	//SListTest05();//头删
	//SListTest06();//查找
	//SListTest07();//指定位置前插入节点
	//SListTest08();//指定位置后插入节点
	//SListTest09();//删除指定位置的节点
	//SListTest10();//删除指定位置之后的节点
	SListTest11();//销毁链表
	return 0;
}
ElvInR
关注
专栏目录
数据结构 单链表
ZY-JIMMY
12-09 1348
目录 线性表的链式存储结构 1、链接存储方法 2、结点结构 3、头指针head和终端结点 线性表链式存储结构的建立 单链表的基本操作 1、初始化单链表 2、得到一个结点 3、头插法 4、尾插法 5、pos 位置插入 6、是否为空 7、查找 key 的前驱 8、删除data域为key的结点 9、摧毁函数 10、求单链表的长度 11、打印单链表 completec...
【殷人昆数据结构】第二章2.2 单链表代码的调试
tianty1121的博客
08-21 373
Single Linked List单链表 文件： 主函数： #include <fstream> //调用文件输入输出流类 #include "LinkedList.h" //调用单链表头文件 using namespace std; //声明命名空间 int main(){ List<int> list; //实例化类List ifstream fin("list.txt"); //这里将输入文件设为ifstream类型 assert(fin);
SingleLinkedList
05-01
这是我对抽象数据类型SingleLinkedList的实验。 在我的代码中，我创建了任何方法。 有 ： isEmpty（）->检查SLL是否为空 getSize（）->大小属性的评估器 addFirst（int newElement）->在第一个SLL中创建节点 addLast（int newElement）->在最后一个SLL中创建节点 add（int Element，int newElement）->在节点元素之后创建节点 removeFisrt（）->删除第一个节点 removeLast（）->删除最后一个节点 remove（int Element）->删除节点元素 print（String comm）->打印带有注释的SLL中的所有元素节点 纠正我，如果我错了：微笑 感谢您访问我的仓库。 :-)
05_单链表简介及其java代码实现
jrrhjww的博客
09-02 254
05_单链表 1.逻辑结构 ​ 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 ​ 单链表(带头结点) 逻辑结构示意图如下： 2.单链表的创建与遍历 2.1 思路分析 2.2 代码实现 ​ 首先定义一个节点类 //定义一个HeroNode类，每个HeroNode对象就是单链表中的一个节点 class He
使用SingleLinkedList扩展类，允许Add,Remove,Contains
javatoyou
10-28 151
创建两个类 SingleLinkedList&lt;T&gt; using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Diagnostics; namespace DevGuideToCollections { /// &lt;summary&...
单链表 - SingleLinkedList
kayyoo的博客
11-28 477
链表是有序的列表，链表是以节点的方式存储的，是链式存储。每个节点包含data域，next域（指向下一个节点）。链表的各个节点不一定是连续存储。链表分为带头节点的链表和和不带头节点的链表
Ch3-SingleLinkedList
gaoxiangnumber1——Gao Xiang's Blog
09-26 343
Please indicate the source if you want to reprint: http://blog.csdn.net/gaoxiangnumber1 SingleLinkedList.h#ifndef SINGLELINKEDLIST_H_INCLUDED #define SINGLELINKEDLIST_H_INCLUDED using std::cout; using
数据结构与算法(java版)——单链表(single-linked list)
Kätzchen-408的博客
04-04 1131
单链表（single-linked list）链表结构应用实例分析数据结构算法类方法对象代码实现插入向尾部直接插入节点思路分析算法实现按照顺序插入指定位置思路分析算法实现修改思路分析代码实现删除思路分析代码实现查找思路分析代码实现面试题有效元素的个数代码实现查找倒数第k个值[新浪面试题]思路分析算法实现单链表的反转[腾讯面试题]思路分析算法实现从尾到头打印单链表[百度面试题]思路分析算法实现 链表结构 node包含data+next,指向下一个结点的地址。链式存储。 链表分为带头结点的链表和没有头结点的链
数据结构与算法(Python)——常见数据结构Part1(数组和链表)
王定桥的专栏
12-09 4766
写在前面 本节对常见数据结构做一个预览，我们的目的是快速了解他们，对于它们涉及到的复杂的数据结构和算法，在这里并不全部展开，留在后期详述。 1.数组 数组是我们要学习的第一个线性结构(Linear structure)，所谓线性结构，指的是在数据有限集合中，每个数据元素都有一个确定的位置，例如a0a0a_{0}是第一个元素，an−1an−1a_{n-1}是最后一个元素，aiaia_{i}...
数据结构算法代码实现——线性表的链式表示与实现(单链表)(三 )
编程侯的专栏
06-02 9937
线性表的链式表示 使用一组任意的存储单元存储线性表的数据元素（这些存储单元可以是连续也可以是不连续的）。 常见的链式表：单链表、静态链表、循环链表、双向链表。 链表的存储方式和特点我们修改一下上一篇文章的例子：假如现在是新生入校，按照新生的先来后到编号1-6，先到的同学可以随意选择床铺，但是需要记住下一位同学的床铺号（1舍友记住2舍友床铺号，2舍友记住3舍友床铺号，依次类推）。此时无形
SingleLinkedList.zip
07-19
单链表算法实现增删改查，就地逆置、倒数第k个节点。不使用java任何工具方法，纯原生单链表，前插，修改，尾插，逆置等
C语言——链表的归并_c语言链表详解
12-21
用c语言写链表归并
单链表Single Linked List
你好，时光的博客
09-14 174
链表(Linked List)介绍 链表是有序的列表，但是它在内存中是存储如下 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表介绍 单链表(带头结点) 逻辑结构示意图如下 单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理 完成对英雄人物的增删改查操作， 注: 删除和修改,查找 第一种方法在添加英雄时，直接添加到链
（新手学数据结构的小白必备！！）Python学习笔记之链表！！！
Kinght_123的博客
11-19 434
文章目录一、单向链表1.节点的实现2.创建单链表3.链表的基本操作①判断链表是否为空②返回链表的长度③遍历整个链表④链表头部添加元素，头插法⑤链表尾部添加元素,尾插法⑥指定位置添加元素,pos从0开始⑦删除节点⑧查找节点是否存在 一、单向链表 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 表元素域的elem用来存放具体的数据 链接域next用来存放下一个节点的位置（pytho
单链表singleLinkedList
wdg0809的博客
11-28 102
package com.shizhong.linkedlist; import java.util.Stack; public class SingleLinkedListDemo { public static void main(String[] args) { //创建节点 HeroNode hero1 = new HeroNode(1,"songjiang","jishiyu"); HeroNode hero2 = new...
单向链表SingleLinkedList
weixin_66598341的博客
09-09 1430
本文案例仅仅使用Java语言实现单向链表的一些简单的增删改查，完成反转单向链表，以及借助栈逆序遍历单向链表等功能。
【数据结构与算法】单链表（SingleLinkedList）
懂得一千零一种,赋予你失败的方法！
02-03 296
文章目录链表一、链表内存存储结构介绍二、链表逻辑结构介绍三、单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理♑ 添加英雄时，直接添加到链表的尾部♑ 添加英雄时，根据排名将英雄插入到指定位置 链表 一、链表内存存储结构介绍 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域：当前节点的值， next 域：指向下一个节点 链表的各个节点不一定是连续存储 ---- 靠next域进行节点间的连接指向，最后链表的以NULL值结束 链表分带头节点的链表和没有..
Java数据结构与算法之单链表SingleLinkedList
mos1896的博客
03-18 290
这里写目录标题一级标题二级标题三级标题四级标题五级标题六级标题1.顺序插入的单链表1.1 HeroNode.java(单链表中的节点类)1.2 SingleLinkedList.java(单链表类，每个对象对应一个单链表)1.2.1 代码分析1.3 Main1.java(测试类)1.3.1 结果分析1.3.2 原始代码（对象不可以作为左值，引用可以）2.添加额外功能（学会1，则2就水到渠成）2.1 修改指定no的节点和删除指定no的节点2.2 此时的Main1.java2.3 结果展示3.单链表常见面试题3
SingleLinkedList独立实现，无任何依赖包
心灵港
08-11 911
现在对Java原生数据结构特感兴趣，于是决定自己动手实现一些类，比如这个List类，在熟习了单链表和双链表的数据结构之后，终于实现了，代码如下： 源码SingleLinkedList.java package hk.inso.service; /**  * Created by IntelliJ IDEA.  * Date: 8/10/15 6:09 PM  * Aut
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值