单链表的相关操作

已于 2022-04-27 21:03:09 修改
阅读量2.1k 收藏 1
点赞数 3
分类专栏： 链表 文章标签： 数据结构
于 2022-04-27 21:01:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63010894/article/details/124451263
版权

目录


提示：以下是本篇文章正文内容，下面案例可供参考

一、闵版（char类型）

1.完整代码

#include <stdio.h>
#include <iostream>

using namespace std;
/**
 * Linked list of characters. The key is data.
 */
typedef struct LinkNode
{
	char data;
	struct LinkNode *next;
}LNode,*LinkList,*NodePtr;

/*链表初始化*/
LinkList initLinkList()
{
	NodePtr tempHeader = new LNode;

	if(!tempHeader)
		return NULL;

	tempHeader->data = '\0';
	tempHeader->next = NULL;

	return tempHeader;
}

//尾插法插入元素
void appendElement(NodePtr paraHeader,char paraChar)
{
	NodePtr p,q;

	// Step 1. Construct a new node.
	q = new LNode;
	q->data = paraChar;
	q->next = NULL;

	// Step 2. Search to the tail.
	p = paraHeader;

	while(p->next)
	{
		p = p->next;
	}

	// Step 3. Now add/link.
	p->next = q;
}

//任意位置插入元素
void insertElement(NodePtr paraHeader, char paraChar, int paraPosition)
{
	NodePtr p, q;

	// Step 1. Search to the position.
	p = paraHeader;
	int pos = 0;

	while(p!= NULL && pos<paraPosition)
	{
		p = p->next;
		pos++;
	}

	if(!p || pos>paraPosition)
	{
		cout<<endl<<"非法插入!!!"<<endl;
		return;
	}

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

	// Step 3. Now link.
	cout<<"linking"<<endl;
	q->next = p->next;
	p->next = q;
}

/*删除元素*/
void deleteElement(NodePtr paraHeader, char paraChar)
{
	NodePtr p,q;

	p = paraHeader;

	while((p->next != NULL) && (p->data != paraChar))
	{
		p = p->next;//找到目标节点的前一个节点
	}

	if(!p->next)//目标节点为空
	{
		cout<<paraChar<<endl;
		return;
	}
	
	q = p->next;
	p->next = q->next;

	delete q;
}

void printList(NodePtr paraHeader){
	NodePtr p = paraHeader->next;
	while (p != NULL) {
		cout<<p->data<<" ";
		p = p->next;
	}
	printf("\n");
}// Of printList

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 occurrence).
	deleteElement(tempList, 'e');
	deleteElement(tempList, 'a');
	deleteElement(tempList, 'o');
	printList(tempList);

	/* Step 4. Insert to a given position.*/
	insertElement(tempList, 'o', 1);
	printList(tempList);
}
int main(){
	appendInsertDeleteTest();
	
	system("pause");
	return 0;
}

2.运行效果

在这里插入图片描述

二、钦版（int 类型）

0.链表的概念

在这里插入图片描述
简单来说，就是一条线性数据链。

1.链表结构体创建

typedef struct _LinkNode
{
	int data;
	struct _LinkNode *next;
}LinkNode,LinkList;

上面采用char 类型，这里采用int 类型。

2.初始化

bool InitList(LinkList* &L)
{
	L = new LinkNode;
	
	if(!L)
		return false;
	
	L->next = NULL;
	
	return true;
}

注：
（1）LinkList* &L ：结构体指针的引用，相当于就是给main函数里面的结构体指针取了个别名“L”。
（2）new: 动态内存申请，后面直接给数据类型就可以了，不用强制性转换。
（3）记住这里申请了动态内存，后面一定要记得用完了，自己释放！
在这里插入图片描述

3.头插法

//头插法 
bool ListInsertByHead(LinkList* &L,LinkNode *node)
{
	if(!L||!node)//防御性编程
		return false;
		
	node->next = L->next;//新结点指向头结点曾经指向的结点 
	L->next = node;     //头结点指向新结点 
	
	return true; 
}

在这里插入图片描述
注：
（1）传入的结点，可能是空结点，此时建议加上防御性编程

4.尾插法

//尾插法
bool LinkInsertByTail(LinkList* &L,LinkNode *node)
{
	LinkNode *last = NULL;
	
	if(!L||!node)
		return false;
	
	last = L;
	
	while(last->next != NULL)
	{
		last = last->next;//循环直至保存倒数第二个节点位置 
	}	
	
	node->next = NULL;//先把新节点指向空 
	last->next = node;//曾经的最后一个节点指向新插入的节点 
	
	return true; 
}

在这里插入图片描述
尾插法比头插法多了一个循环移动，关键是最后的指针的指向，根据注释和图解，加以理解。

5.指定位置插入

//指定位置插入
bool LinkInsertByApoint(LinkList* &L,int i,int &e)//链表名，插入的位置，插入的数据
{
	if(!L||!e)
		return false;
	
	int pos = 0;
	
	LinkList *p,*s;
	
	p=L;
	
	while(p!=NULL && pos<i-1)//查找位置为i-1的结点 
	{
		p = p->next;
		pos++; 
	}
	
	if(!p || pos>i-1) // 在两个空位置间插入数据  or  想在下标为负的位置插入数据 
	{
		cout<<"\n非法插入！";
	 	return false;
	}

	s = new LinkNode;
	s->data = e;
	
	s->next = p->next;//新结点指向第i个结点 
	p->next = s;     //新结点被第i-1个结点所指向 
	
	return true;	
	
}

在这里插入图片描述
我这里说的位置，不是下标位置，就是普通的物理位置。

6.指定值插入（多个同样元素取首个元素插入）

bool inserElementByValue(LinkList* &L,int i,int &Value)
{
	if(!L)
		return false;

	LinkList *p = NULL,*q = NULL;

	p = L->next;

	while(p->next && p->next->data != i)
	{
		p = p->next;
	}
	
	q = new LinkNode;

	q->data = Value;
	q->next = p->next;//新结点指向目标结点 
	p->next = q;     //新结点被目标结点的前一个结点指向 

	return true;

}

在这里插入图片描述

7.指定位置获取数据

//指定位置获取数据
bool LinkGetsDataByPos(LinkNode* &L,int i,int &e)
// i-->位置 ， e -- >要返回的数据 
{
	int index = 1;
	LinkList *p = L->next;
	
	if(!L || !L->next)
	{
		cout<<"空玩意儿！";
		return false;
	}
	
	while(p && index <i)//顺着链表向下扫描，不扫描链表头结点 
	{
		p=p->next;
		index++;//计数器 
	}
	
	if(!p || index>i)
	{
		return false;//i值 不合法 :i>n 或 i<=0 
	} 
	
	e = p->data;
	
	return true;
}

注：
（1）引用可以把 e 带出去，所以采用了习惯的bool返回方式。
（2）采用引用带出数据是C++的代码风格，不习惯的小伙伴可以采用int 等的返回类型return e;即可

8.按值获取元素位置

//按值获取元素
bool LinkGetsDataByData(LinkNode* &L,int e,int &index) 
{
	LinkList *p = L->next; //p 当前结点 
	index = 1;
	
	if(!L || !L->next)
	{
		return false;
	}
	
	while(p && p->data != e)
	{
		index++;
		p=p->next;//p->next 是下一个结点 
	}
	
	if(!p)
	{
		return false;
	}
	
	return true;
}

9.删除结点

//按位置删除
bool LinkDeleteByPos(LinkList* &L,int i)
{
	LinkList *p = L,*q;//要删除的前面一个结点 
	
	int index = 0;
	
	if(!L || !L->next)
	{
		return false;
	}
	
	while((p->next) && (index<i-1)) //p->next 指的是当前的结点 
	{
		p = p->next;//找到要删除的节点的前一个结点 
		index++;
	}
	
	if((!p->next) || (index>i-1))// 当 i>n  或 i < 1 时不合理 
	{
		return false; 
	}
	
	q = p->next; //临时保存被删除的结点的地址，以备释放空间 
	p->next = q->next; //使得被删除的结点的前一个结点，指向被删除结点的下一个结点 
	
	delete q; //把被删除的结点的内存释放掉 
	
	return true;
}

注：
（1）C++里new 对应delete
在这里插入图片描述

10.打印链表

//打印链表 
void PrintLink(LinkList* &L)
{
	LinkNode *pMove = NULL;
	
	if(!L)
	{
		cout<<"链表为空链表！！！";
		return ;
	}
	
	pMove = L->next;//指向头结点了
	
	while(pMove!=NULL)
	{
		cout<<pMove->data<<" ";
		
		pMove=pMove->next;
	}
	cout<<endl; 
}

pMove ：循环指针

11.摧毁链表

//销毁链表
bool LinkDestroy(LinkList* &L)
{
	LinkList *p = L;

	while(p)
	{
		L= L->next;//指向下一个结点 
		delete p;  //释放当前结点 
		
		p = L;    //赋给p，让p去循环执行释放的工作 
	}
	
	cout<<"\n销毁链表！！！" <<endl<<endl;
	return true; 
}

12.完整代码

#include <iostream>
#include <stdio.h>
#include <stdlib.h>

using namespace std;

typedef struct _LinkNode
{
	int data;
	struct _LinkNode *next;
}LinkNode,LinkList;

bool InitList(LinkList* &L)
{
	L = new LinkNode;
	
	if(!L)
		return false;
	
	L->next = NULL;
	
	return true;
}

//头插法 
bool ListInsertByHead(LinkList* L,LinkNode *node)//引用写不写问题不大，由于是指针可以直接访问地址 
{
	if(!L||!node)
		return false;
	node->next = L->next;//新结点指向头结点曾经指向的结点 
	L->next = node;     //头结点指向新结点 
	
	return true; 
} 
//尾插法
bool LinkInsertByTail(LinkList* &L,LinkNode *node)
{
	LinkNode *last = NULL;
	
	if(!L||!node)
		return false;
	
	last = L;
	
	while(last->next != NULL)
	{
		last = last->next;//循环直至保存倒数第二个节点位置 
	}	
	
	node->next = NULL;//先把新节点指向空 
	last->next = node;//曾经的最后一个节点指向新插入的节点 
	
	return true; 
} 

//指定位置插入
bool LinkInsertByApoint(LinkList* &L,int i,int &e)//链表名，插入的位置，插入的数据
{
	if(!L||!e)
		return false;
	
	int pos = 0;
	
	LinkList *p,*s;
	
	p=L;
	
	while(p!=NULL && pos<i-1)//查找位置为i-1的结点 
	{
		p = p->next;
		pos++; 
	}
	
	if(!p || pos>i-1) // 在两个空位置间插入数据  or  想在下标为负的位置插入数据 
	{
		cout<<"\n非法插入！";
	 	return false;
	}

	s = new LinkNode;
	s->data = e;
	
	s->next = p->next;//新结点指向第i个结点 
	p->next = s;     //新结点被第i-1个结点所指向 
	
	return true;	
	
} 

/*按值插入元素*/
bool inserElementByValue(LinkList* &L,int i,int &Value)
{
	if(!L)
		return false;

	LinkList *p = NULL,*q = NULL;

	p = L->next;

	while(p->next && p->next->data != i)
	{
		p = p->next;
	}
	
	q = new LinkNode;

	q->data = Value;
	q->next = p->next;
	p->next = q;

	return true;

}
//指定位置获取数据
bool LinkGetsDataByPos(LinkNode* &L,int i,int &e)
{
	int index = 1;
	LinkList *p = L->next;
	
	if(!L || !L->next)
	{
		cout<<"空玩意儿！";
		return false;
	}
	
	while(p && index <i)//顺着链表向下扫描，不扫描链表头结点 
	{
		p=p->next;
		index++;//计数器 
	}
	
	if(!p || index>i)
	{
		return false;//i值 不合法 :i>n 或 i<=0 
	} 
	
	e = p->data;
	
	return true;
}

//按值获取元素
bool LinkGetsDataByData(LinkNode* &L,int e,int &index) 
{
	LinkList *p = L->next; //p 当前结点 
	index = 1;
	
	if(!L || !L->next)
	{
		return false;
	}
	
	while(p && p->data != e)
	{
		index++;
		p=p->next;//p->next 是下一个结点 
	}
	
	if(!p)
	{
		return false;
	}
	
	return true;
}

//按位置删除
bool LinkDeleteByPos(LinkList* &L,int i)
{
	LinkList *p = L,*q;//要删除的前面一个结点 
	
	int index = 0;
	
	if(!L || !L->next)
	{
		return false;
	}
	
	while((p->next) && (index<i-1)) //p->next 指的是当前的结点 
	{
		p = p->next;//找到要删除的节点的前一个结点 
		index++;
	}
	
	if((!p->next) || (index>i-1))// 当 i>n  或 i < 1 时不合理 
	{
		return false; 
	}
	
	q = p->next; //临时保存被删除的结点的地址，以备释放空间 
	p->next = q->next; //使得被删除的结点的前一个结点，指向被删除结点的下一个结点 
	
	delete q; //把被删除的结点的内存释放掉 
	
	return true;
} 

//打印链表 
void PrintLink(LinkList* &L)
{
	LinkNode *pMove = NULL;
	
	if(!L)
	{
		cout<<"链表为空链表！！！";
		return ;
	}
	
	pMove = L->next;//指向头结点了
	
	while(pMove!=NULL)
	{
		cout<<pMove->data<<" ";
		
		pMove=pMove->next;
	}
	cout<<endl; 
} 

//销毁链表
bool LinkDestroy(LinkList* &L)
{
	LinkList *p = L;

	while(p)
	{
		L= L->next;//指向下一个结点 
		delete p;  //释放当前结点 
		
		p = L;    //赋给p，让p去循环执行释放的工作 
	}
	
	cout<<"\n销毁链表！！！" <<endl<<endl;
	return true; 
} 

void Test()
{
	LinkList *L = NULL;
	LinkNode *newNode =NULL;
	//1.初始化空链表 
	InitList(L);
	
	//2.头插法，插入数据
	int num;
	
	cout<<"请输入插入的元素个数:"<<endl;
	cin>>num;
	printf("请以此输入%d个元素:\n",num);
	
	for(int i=0;i<num;i++)
	{
		newNode = new LinkNode;
		
		cin>>newNode->data;
		
		ListInsertByHead(L,newNode);
		
		delete newNode;
	} 
	cout<<"\n录入完毕!\n";
	
	int num1;
	 
	 PrintLink(L);
	
	//3.尾插法 
	cout<<"\n请输入插入的元素个数:"<<endl;
	cin>>num;
	printf("请以此输入%d个元素:\n",num);
	
	for(int i=0;i<num;i++)
	{
		newNode = new LinkNode;
		
		cin>>newNode->data;
		
		LinkInsertByTail(L,newNode);
		delete newNode;
	} 
	cout<<"\n录入完毕!\n";
	
	//4.单链表的输出 
	PrintLink(L);
	
	//5.任意位置插入
	int pos;
	int e;
	int n;
	
	cout<<"\n请输入要插入的次数:";
	cin>>n;
	
	for(int i=0;i<n;i++)
	{
		cout<<"\n请输入要插入的位置和数据:";
	 
		cin>>pos;
		cin>>e;
		
		if(LinkInsertByApoint(L,pos,e) == false)
		{
			cout<<"\n插入失败!!!\n";
			PrintLink(L);
		}else 
		{
			cout<<"\n插入成功！\n";
			PrintLink(L);
		}	
			
		
	}
	
	//6.按位置获取元素
	
	int element = 0;

	cout<<"\n请输入要按位置获取的次数:";
	cin>>n;
	
	for(int i=0;i<n;i++)
	{
		cout<<"请输入要获取的元素的位置:"<<endl;
		cin>>pos;
		if(LinkGetsDataByPos(L,pos,element))
		{
			printf("\n获取第%d个元素成功!!!\n",pos);
			cout<<"\n获取的数据为:"<<element<<endl<<endl;
		}else
		{
			cout<<endl<<"获取失败！"<<endl; 
		} 
	}
	
	//7.按值获取元素 
	 int post = 0;

	cout<<"\n请输入要按值获取的次数:";
	cin>>n;
	
	for(int i=0;i<n;i++)
	{
		cout<<"请输入要获取的元素的值:"<<endl;
		cin>>element;
		
		if(LinkGetsDataByData(L,element,post))
		{
			printf("\n获取元素成功!!!");
			cout<<"\n获取元素的链表位置为:"<<post<<endl;
		}else
		{
			cout<<endl<<"获取失败！"<<endl; 
		} 
	}
	
	//8.按位置删除
	cout<<"\n请输入要按位置删除的次数：";
	cin>>n;
	
	for(int i=0;i<n;i++)
	{
		cout<<"\n请输入要删除的元素位置:";
		cin>>post;
		
		if(LinkDeleteByPos(L,post))
		{
			printf("\n删除成功!\n");
			PrintLink(L);		
		}else
		{
			cout<<"删除失败"<<endl; 
		}
	} 
	//9.按值插入元素
	int i,el;
	cout<<"请输入按值插入的目标元素：";
	cin>>i;
	cout<<"请输入插入的元素:";
	cin>>el;
	inserElementByValue(L,i,el); 
	PrintLink(L);	
	
	//9.销毁单链表
	LinkDestroy(L);
	
}
int main()
{
	Test();
	system("pause"); 
	return 0; 
}

三、总结

1.函数的传递有三种：值传递、指针传递（地址传递）、引用传递。
2.引用传递的作用：
（1）二级指针的传递可以借助一级指针的引用。
（2）“引用”不会产生新的变量，形参就是实参的别名，减少传递时的开销。
（3）引用后对形参的修改，就是对实参的修改。因此可以把“引用”理解成“类指针”。
（4）引用可以把形参，在不用return 的情况下就可以把值带出来。
3.弄懂链表操作的关键是画图，理解每个结点的指针域的指向！一般对一个结点进行操作时，循环指针指向的是其上一个结点，通过上一个结点的*next指针对其进行操作。

C++New不出对象
关注
专栏目录
单链表常见操作图文详解
程序猿老樊的博客
04-15 2万+
     单链表的最大特点是可以将物理地址上不连续的数据连接起来，通过指针来对物理地址进行操作，实现增删改查等功能。     单链表分为两种：有头链表和无头链表。     无头单链表，也就是phead一只是一个指针，指向链表的第一个节点。     带头节点的单链表：只不过头结点的data不保存信息。//构建一个节点typedef struct Node { DataType data; ...
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。 2.再从键盘输入顺序任意的5个整数，按有序插入的要求生成第二个有序单链表，将该链表输出显示。 3.将这两个有序单链表...
单链表相关操作
帝轩的博客
04-14 808
实现单链表的反转 1.最简单暴力的方法，遍历链表，并创建节点采用头插法即可，时间复杂度为O（ n），空间需要创建n个节点。 2.采用指针转向方法 我们知道单链表只能单向顺序遍历，不能往回倒着走。那么，如何实现单链表的反转呢，我们可以借助引用（指针）将链表分成相互隔离的两个部分，前面部分是已经逆好序的链表，而后一部分是未遍历的部分，由于指针的单向性，我们必须确保两个部分都有指针指向，否则就会导致链表...
【数据结构】单链表相关操作
码农印象
07-04 256
前言 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 今天来一起学习单链表的相关操作： 参考代码： linklist.h： #ifndef __LIST_H__ #define _...
单链表操作基本运算_单链表的基本操作_
10-03
在这个文档“单链表操作基本运算.docx”中，可能会详细解释以上概念，并提供相关的代码示例，帮助读者理解和实现这些基本操作。同时，文档可能还会涉及错误处理和性能优化技巧，比如在插入或删除节点时避免无效遍历...
单链表相关的基本操作（从文件中读入）
01-20
在本文件中，我们探讨了如何使用C++进行单链表的相关操作，包括初始化、构建链表、插入元素、删除元素、判断链表是否为空以及倒置链表。 首先，`initLinkList`函数用于初始化链表，创建一个带头结点的空链表。这...
基于Java实现的单链表基本操作之获取链表长度.zip
最新发布
04-26
本教程主要探讨的是如何在Java编程语言中实现单链表的基本操作，特别是如何获取链表的长度。下面我们将深入讨论相关知识点。 首先，我们需要理解单链表的概念。单链表是由一系列节点构成的，每个节点包含两部分：...
Java实现单链表以及单链表的操作.zip
09-02
本教程将深入探讨如何使用Java语言来实现单链表及其相关操作。 首先，我们来理解单链表的基本概念。单链表由一系列节点组成，每个节点包含两部分：数据域（用于存储数据）和指针域（指向下一个节点）。链表的最后一...
有关操作单链表的函数
lc578626的博客
12-15 244
slist.h#ifndef __SLIST_H__ #define __SLIST_H__#include<stdio.h> #include<assert.h> #include<stdlib.h>typedef int DataType;typedef struct SListNode { struct SListNode *_next; DataType _data; }SL
单链表的一些基本操作
pigff的博客
06-19 383
顺序表与链表各自的优缺点： 1. 顺序表支持随机访问，单链表不支持随机访问。 2. 顺序表插入 / 删除数据效率很低，时间复杂度为O(N)（除尾插尾删），单链表插入 / 删除效率更高，时间复杂度为O(1)。 3. 顺序表的CPU高速缓存效率更高，单链表CPU高速缓存效率低 1.倒着打印单链表 void PrintTailToHead(ListNode* pList)//倒着打印单
单链表的基本操作
liumce的博客
06-09 4370
（1） 用表头插入法创建单链表； （2） 用表尾插入法创建单链表； （3） 在单链表的第i个结点前插入一个结点； （4） 删除单链表中第i个结点； （5） 删除单链表中指定值的结点； （6） 删除单链表中结点值等于e的所有结点； （7） 输出链表元素； （8） 清空单链表。 #define OVERFLOW -1 #define OK 1 #define ERROR 0 #define TRUE 1 #define FLASE 0 #include<stdio.h> ...
单链表的十三个基本操作（全）
兔子王
10-03 6347
有关单链表的十三个基本操作，包括了 1、初始化单链表 2、插入 3、删除 4、查找 5、逆置 6、排序 7、删除指定数 8、指定交换顺序 9、求单链表长度 10、修改 11、最大值 12、按序插入 13、删除重复值
数据结构（03）——单链表
08-20 571
单链表概念 链表的节点均单向指向下一个节点，形成一条单向访问的数据链。 单链表的初始化 typedef struct _LinkNode { int data; //结点的数据域 struct _LinkNode *next; //结点的指针域 }LinkNode, LinkList; //链表节点、链表 bool InitList(LinkList* &L)//...
初学数据结构——链表
orange_monkey的博客
08-25 258
#include<iostream> using namespace std; //声明链表结点的结构体 typedef struct LinkNode { int data; struct LinkNode *next; }LinkNode, *Linklist; //初始化链表 const bool Init_List(Linklist &l) throw(bool) { //为头结点分配内存 l = (LinkNode*)malloc(sizeof(LinkNode))
P9 链表 清空链表|销毁链表
weixin_73901182的博客
12-04 1653
🎬 个人主页：@ChenPi🐻推荐专栏1: 《》✨✨✨🔥 推荐专栏2: 《》✨✨✨📝推荐专栏3: ​​​​​​《》 ✨✨✨🍉本篇简介 : 链表清空链表|销毁链表✨ 只有我努力了 才有机会接触成功✨链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。
单链表基本操作（C语言）
weixin_65132948的博客
05-01 7444
目录 一、链表的介绍 二、单链表的实现 1、定义单链表 2、接口函数 1）打印函数 2）创建结点 3）尾插 4） 头插 5） 尾删 6）头删 7) 查找 8） 修改 9） 指定位置前插入 10）删除指定位置节点 11）指定位置后插入节点 12） 删除指定位置后的节点 首先我们回顾一下线性表的两种存储方式--顺序存储和链式存储 在中已经讲解过了顺序存储的方式，对于顺序表的优缺点总结来说就是，查找方便，增删复杂。 而链表...
C语言实现单链表基础操作与遍历示例
本资源主要介绍了单链表操作的相关概念和技术细节。单链表是一种基础的数据结构，它由节点组成，每个节点包含一个元素值（`ElemType`）和一个指向下一个节点的指针。在提供的代码片段中，定义了以下关键函数： 1. *...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值