顺序表和单向链表练习

已于 2023-02-06 09:14:49 修改
阅读量322 收藏
点赞数 1
文章标签： 链表 数据结构
于 2023-02-04 23:08:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38175059/article/details/128886792
版权

/*单向链表练习:

链表中存储数据类型为字符申，请完成以下功能

1.在堆区申请空间

2.实现头插、头删、尾插、尾删

3，遍历链表

4.在任意位置插入

5，任意位置删除

6,按元素修改

7,按元素查找

8.单向链表逆置

9,链表降序排序

10，释放链表空间*/

#ifndef __LINKLIST_H__
#define __LINKLIST_H__
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
typedef struct node{
	union {
		int len;
		char data[20];
	};
	struct node*next;
}Linklist;
//单向链表练习:
 //链表中存储数据类型为字符申，请完成以下功能
//1.在堆区申请空间
Linklist*RequestSpace();
//创建头节点
Linklist* CreatTrailNode();
//创建新节点
Linklist* CreatNewNode();
//2.实现头插、头删、尾插、尾删
void InsertTrail(Linklist*L,char value[]);
//尾插
void InsertEnd(Linklist*L,char value[]);
//3，遍历链表
void OutPutLinklist(Linklist *L);
//4.在任意位置插入
void InsertPos(Linklist*L,int pos,char value[]);
//5，任意位置删除
void DelPos(Linklist*L,int pos);
//6,按元素修改
void ModElement(Linklist*L,char value[],char value1[]);
//7,按元素查找
void FindElement(Linklist*L,char value[]);
//8.单向链表逆置
void RevLinklist(Linklist*L);
//9,链表降序排序
void SortLinklist(Linklist*L);
//10，释放链表空间
void FreeSpace(Linklist**L);	

#endif

/*单向链表练习:
链表中存储数据类型为字符申，请完成以下功能
1.在堆区申请空间
2.实现头插、头删、尾插、尾删
3，遍历链表
4.在任意位置插入
5，任意位置删除
6,按元素修改
7,按元素查找
8.单向链表逆置
9,链表降序排序
10，释放链表空间*/
#include"link_list.c"

int main(int argc, const char *argv[])
{
	Linklist*L=RequestSpace();
	if(L==NULL){
		printf("创建链表失败\n");
		return -1;
	}
	printf("输入插入的个数\n");
	char arr[20];
	int num;
	scanf("%d",&num);
	for(int i=0;i<num;i++){
		scanf("%s",arr);
		//InsertTrail(L,arr);
		//尾部插入
		InsertEnd(L,arr);
	}
	OutPutLinklist(L);
#if 1

	//4.在任意位置插入
	printf("任意位置插入\n");
	int pos;
	char value[20];
	printf("输入要插入的位置\n");
	scanf("%d",&pos);
	printf("输入要插入的字符串\n");
	scanf("%s",value);
	InsertPos(L,pos,value);
	OutPutLinklist(L);

	//4.在任意位置删除
	printf("任意位置删除\n");
	int a;
	printf("输入要删除的位置\n");
	scanf("%d",&a);
	DelPos(L,a);
	OutPutLinklist(L);

	putchar(10);	
	printf("***********\n");
	char b[20];
	char c[20];
	printf("查找要修改的元素\n");
	scanf("%s",b);
	printf("输入元素修改\n");
	scanf("%s",c);
	ModElement(L,b,c);
	OutPutLinklist(L);

	printf("***********\n");
	char e[20];
	printf("查找元素\n");
	scanf("%s",e);
	FindElement(L,e);

	printf("逆序\n");
	RevLinklist(L);
	OutPutLinklist(L);

	//9,链表降序排序
	SortLinklist(L);
	OutPutLinklist(L);

	//10，释放链表空间
	FreeSpace(&L);
	if(L==NULL){
		printf("释放成功\n");
	}
	else{
		printf("释放空间失败\n");
	}
#endif
	return 0;
}

#include"link_list.h"
//单向链表练习:
//链表中存储数据类型为字符申，请完成以下功能
//1.在堆区申请空间
Linklist*RequestSpace()
{
	Linklist*p=(Linklist*)malloc(sizeof(Linklist));
	if(p==NULL){
		printf("申请空间失败\n");
		return NULL;
	}
	return p;
}
//创建头节点
Linklist* CreatTrailNode()
{
	Linklist*p=RequestSpace();
	if(p==NULL){
		printf("创建头节点失败\n");
		return NULL;
	}
	p->next=NULL;
	p->len=0;
	return p;
}
//创建新节点
Linklist* CreatNewNode()
{
	Linklist*p=RequestSpace();
	if(p==NULL){
		printf("创建头节点失败\n");
		return NULL;
	}
	p->next=NULL;
	strcpy(p->data,"0");
	return p;
}
//2.实现头插、头删、尾插、尾删
void InsertTrail(Linklist*L,char value[])
{
	Linklist*p=CreatNewNode();
	if(p==NULL){
		printf("创建新节点失败\n");
		return;
	}
	p->next=L->next;
	L->next=p;
	strcpy(p->data,value);
	L->len++;
}
//尾插
void InsertEnd(Linklist*L,char value[])
{
	Linklist*p=CreatNewNode();
	Linklist*q=L;
	if(p==NULL){
		printf("创建新节点失败\n");
		return;
	}
	while(q->next!=NULL){
		q=q->next;
	}
	strcpy(p->data,value);
	q->next=p;
	L->len++;
}
//3，遍历链表
void OutPutLinklist(Linklist *L)
{
	Linklist*p=L;
	for(int i=0;i<L->len;i++){
		p=p->next;
		printf("%s\t",p->data);
	}
}
//4.在任意位置插入
void InsertPos(Linklist*L,int pos,char value[])
{
	Linklist*p=L;
	if(pos>L->len||pos<=0){
		printf("插入位置非法\n");
	}
	for(int i=0;i<pos-1;i++){
		p=p->next;
	}
	Linklist*q=CreatNewNode();
	q->next=p->next;
	p->next=q;
	strcpy(q->data,value);
	L->len++;
}
//5，任意位置删除
void DelPos(Linklist*L,int pos)
{
	if(pos>L->len||pos<=0){
		printf("输入位置参数错误\n");
		return ;
	}
	Linklist*p=L;
	for(int i=0;i<pos-1;i++){
		p=p->next;
	}
	Linklist*q=p->next;
	p->next=p->next->next;
	free(q);
	q=NULL;
	L->len--;
}
//6,按元素修改
void ModElement(Linklist*L,char value[],char value1[])
{
	Linklist*p=L;
	int count=0;
	for(int i=0;i<L->len;i++){
		p=p->next;
		if(strcmp(value,p->data)==0){
			strcpy(p->data,value1);
			count++;
		}
	}
	if(count==0){
		printf("该元素不存在\n");
	}
}
//7,按元素查找
void FindElement(Linklist*L,char value[])
{
	Linklist*p=L;
	int count=0;
	for(int i=0;i<L->len;i++){
		p=p->next;
		if(strcmp(p->data,value)==0){
			printf("该元素在%d位置上\n",i+1);
			count++;
		}
	}
	if(count==0){
		printf("该元素不存在\n");
	}
}
//8.单向链表逆置
void RevLinklist(Linklist*L)
{
	Linklist*q=L;
	Linklist*p=L->next;
	L->next=NULL;
	while(p!=NULL){
		Linklist*t=p;
		p=p->next;
		t->next=q->next;
		q->next=t;
	}

}
//9,链表降序排序
void SortLinklist(Linklist*L)
{

	Linklist*p=L->next;
	L->next=NULL;
	while(p!=NULL){
		Linklist *q=L;
		Linklist*t=p;
		p=p->next;
		if(q->next==NULL){
			t->next=L->next;
			L->next=t;
		}
		else{
			while((strcmp(q->next->data,t->data))>0){
				q=q->next;
			}
			t->next=q->next;
			q->next=t;
		}
	}
}
//10，释放链表空间
void FreeSpace(Linklist**L)
{
	Linklist**p=L;
	for(int i=0;i<(*L)->len;i++){
		*p=(*p)->next;
		free(*p);
	}
	*p=NULL;
}

1.在堆区申请空间

2,实现顺序表数据元素在表尾录入

3，实现顺序表输出

4.实现顺序表按下标插入商品信息

5,实现顺序表按下标删除商品信息

6,查找商品名称key是否在购物车信息中出现

7，修改商品名称key的购买数量，修改为n

8,删除最贵的商品信息

9,对商品总价实现升序排序

10，如果有两个商品名称相同的商品信息.则去重

11,释放堆区空间*/


#ifndef __SHOOPCARSQELIST_H__
#define __SHOOPCARSQELIST_H__
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXSIZE 20
typedef struct{
	char name[20];
	char arrriture[20];
	float price;
	int num;
}Goods;
typedef struct{
	Goods data[MAXSIZE];
	int len;
}Seqlist;
//1.在堆区申请空间
Seqlist* RequestSpace();
//2,实现顺序表数据元素在表尾录入
void TrialSeqlist(Seqlist*L,int number);
//3，实现顺序表输出
void OutPutSeqlist(Seqlist*L);
//顺序表判满
//０表示满了，－１表示没满;
int FullSeqlist(Seqlist*L);
//顺序表判空
//０表示空了，－１表示没空;
int EmptySeqlist(Seqlist*L);
//4.实现顺序表按下标插入商品信息
int InserIndexBydata(Seqlist*L,int index);
//5,实现顺序表按下标删除商品信息
int DelByGood(Seqlist*L,int index);
//6,查找商品名称key是否在购物车信息中出现
int* FindName(Seqlist*L,char key[]);
//7，修改商品名称key的购买数量，修改为n
int ModifyGoodsBynameBysum(Seqlist*L,char key[],int n);
//8,删除最贵的商品信息
int DelExpensiveBygood(Seqlist*L);
//9,对商品总价实现升序排序
void SortPrice(Seqlist*L);
//10，如果有两个商品名称相同的商品信息.则去重
void RemovSame(Seqlist*L);
//11,释放堆区空间*/
void FreeSpace(Seqlist**L);
#endif

顺序表练习:
请实现购物车系统，把商品[商品名称，商品属性.价格，个数]信息存储到顺序表中，请完成- : 下操作操作
结构体定义
typedef struct
char name[201://名称
char arrri ture[201;//圖性
float price;//价格
nt num://个数
}Goods:
typedef struct
Goods data[MAXSIZE];
int 1en;
}5eqlist;
1.在堆区申请空间
2,实现顺序表数据元素在表尾录入
3，实现顺序表输出
4.实现顺序表按下标插入商品信息
5,实现顺序表按下标删除商品信息
6,查找商品名称key是否在购物车信息中出现
7，修改商品名称key的购买数量，修改为n
8,删除最贵的商品信息
9,对商品总价实现升序排序
10，如果有两个商品名称相同的商品信息.则去重
11,释放堆区空间

#include"ShoopCarSqelist.c"
int main(int argc, const char *argv[])
{
	Seqlist*L=RequestSpace();
	if(L==NULL){
		printf("创建顺序表失败\n");
		return -1;
	}
	int number=0;
	printf("请输入插入多少不同种类的商品\n");
	scanf("%d",&number);
//2,实现顺序表数据元素在表尾录入
	TrialSeqlist(L,number);
#if 0
	//3，实现顺序表输出
	OutPutSeqlist(L);
//4.实现顺序表按下标插入商品信息
	int index=0;
	printf("请输入插入的下标\n");
	scanf("%d",&index);
	InserIndexBydata(L,index);

	int index1=0;
	printf("请输入删除的下标\n");
	scanf("%d",&index1);
	DelByGood(L,index1);
	//3，实现顺序表输出
	OutPutSeqlist(L);

	char key[20]="";
	printf("输入查找的商品名称\n");
	scanf("%s",key);
	int *p=FindName(L,key);
	for(int i=0;i<10;i++){
		if(*(p+i)==-1){
			continue;
		}
		printf("在下标%d出现\n",*(p+i));
	}

	//7，修改商品名称key的购买数量，修改为n
	int n=0;
	char key2[20]="";
	printf("输入要修改商品的名称\n");
	scanf("%s",key2);
	printf("输入修改的商品的购买数量\n");
	scanf("%d",&n);
	ModifyGoodsBynameBysum(L,key2,n);
	//3，实现顺序表输出
	OutPutSeqlist(L);

//8,删除最贵的商品信息
	ptintf("删除最贵的商品信息\n");
	DelExpensiveBygood(L);
	//3，实现顺序表输出
	OutPutSeqlist(L);

	//9,对商品总价实现升序排序
	printf("根据价格排序\n");
	SortPrice(L);
	//3，实现顺序表输出
	OutPutSeqlist(L);

	//10，如果有两个商品名称相同的商品信息.则去重
	printf("删除商品名称相同的商品信息:\n");
	RemovSame(L);
	//3，实现顺序表输出
	OutPutSeqlist(L);

	//11,释放堆区空间*/
	printf("释放堆区空间\n");
	FreeSpace(&L);
	if(L==NULL){
		printf("释放成功\n");
	}
	else{
		printf("释放失败\n");
	}
	return 0;
}

#include"SchoopCarSqelist.h"
//1.在堆区申请空间
Seqlist* RequestSpace()
{
	Seqlist*p=(Seqlist*)malloc(sizeof(Seqlist));
	if(p==NULL){
		printf("申请空间失败\n");
		return NULL;
	}
	p->len=0;
	return p;
}
//2,实现顺序表数据元素在表尾录入
void TrialSeqlist(Seqlist*L,int number)
{
	for(int i=0;i<number;i++){
		printf("名称:\n");
		scanf("%s",L->data[i].name);
		printf("属性:\n");
		scanf("%s",L->data[i].arrriture);
		printf("价格:\n");
		scanf("%f",&L->data[i].price);
		printf("输入商品的个数\n");
		scanf("%d",&L->data[i].num);
		L->len++;
	}
}
//3，实现顺序表输出
void OutPutSeqlist(Seqlist*L)
{
	for(int i=0;i<L->len;i++){
		printf("名称%s\t属性%s\t价格%.1f\t个数%d\n",L->data[i].name,L->data[i].arrriture,L->data[i].price,L->data[i].num);
	}
}
//顺序表判空
//０表示空了，－１表示没空;
int EmptySeqlist(Seqlist*L)
{
	return 0==L->len?0:-1;
}
//顺序表判满
//０表示满了，－１表示没满;
int FullSeqlist(Seqlist*L)
{
	return L->len==MAXSIZE?0:-1;
}
//4.实现顺序表按下标插入商品信息
int InserIndexBydata(Seqlist*L,int index)
{
	if(index<0||index>L->len){
		printf("输入的下表位置非法\n");
		return -1;
	}
	int i=0;
	if(FullSeqlist!=0){
		for(i=L->len;i>index;i--){
			L->data[i]=L->data[i-1];
		}
	}
	printf("输入插入商品的信息\n");
	printf("名称:\n");
	scanf("%s",L->data[i].name);
	printf("属性:\n");
	scanf("%s",L->data[i].arrriture);
	printf("价格:\n");
	scanf("%f",&L->data[i].price);
	printf("输入商品的个数\n");
	scanf("%d",&L->data[i].num);
	L->len++;
	return 0;
}
//5,实现顺序表按下标删除商品信息
int DelByGood(Seqlist*L,int index)
{
	if(index<0||index>L->len){
		printf("输入的位置参数非法\n");
		return -1;
	}
	if(EmptySeqlist==0){
		printf("空表,无需删除\n");
		return -1;
	}
	int i=0;
	for(i=index;i<L->len;i++){
		L->data[i]=L->data[i+1];
	}
	L->len--;
	return 0;
}
//6,查找商品名称key是否在购物车信息中出现
int* FindName(Seqlist*L,char key[])
{
	static int arr[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
	int k=0;
	if(EmptySeqlist==0){
		printf("空表，无需查找\n");
		return NULL;
	}
	for(int i=0;i<L->len;i++){
		if(strcmp(L->data[i].name,key)==0){
				arr[k++]=i;
		}
	}
	if(k==0){
		printf("购物车没有此商品\n");
	}
	return arr;
}
//7，修改商品名称key的购买数量，修改为n;
int ModifyGoodsBynameBysum(Seqlist*L,char key[],int n)
{
	if(EmptySeqlist==0){
		printf("空表，无需查找\n");
		return -1;
	}
	int *p=FindName(L,key);
	for(int i=0;i<10;i++){
		if(*(p+i)==-1){
			continue;
		}
		L->data[i].num=n;
	}
	return 0;

}
//8,删除最贵的商品信息
int DelExpensiveBygood(Seqlist*L)
{
	if(EmptySeqlist==0){
		printf("空表，无需查找\n");
		return -1;
	}
	int max_index=0;
	int max=L->data[0].price;
	for(int i=1;i<L->len;i++){
		if(max<L->data[i].price){
			max_index=i;
		}
	}
	DelByGood(L,max_index);
	L->len--;
}

//9,对商品总价实现升序排序
void SortPrice(Seqlist*L)
{
	for(int i=1;i<L->len;i++){
		for(int j=0;j<L->len-i;j++){
			if(L->data[j].price>L->data[j+1].price){
				Goods temp=L->data[j];
				L->data[j]=L->data[j+1];
				L->data[j+1]=temp;
			}
		}
	}
}
//10，如果有两个商品名称相同的商品信息.则去重
void RemovSame(Seqlist*L)
{
	for(int i=0;i<L->len;i++){
		for(int j=i+1;j<L->len;j++){
			if(strcmp(L->data[i].name,L->data[j].name)==0){
				DelByGood(L,i);
				j--;
			}
		}
	}
}
//11,释放堆区空间*/
void FreeSpace(Seqlist**L)
{
	free(*L);
	*L=NULL;
}
骑着单车飘移
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2020西南交通大学数据结构实验报告单向链表算法练习.doxc
03-16
从键盘输入若干整数，直到输入0时停止，按输入整数顺序建立单向链表存储结构。然后用字符界面菜单提供以下功能： 1.插入元素--输入i, e，在单向链表第i个元素之前插入元素e，输出插入e后的单向链表（已知有效的插入...
【数据结构】顺序表和单链表所有知识点（附带面试题）
龙跃十二
02-06 3029
一、顺序表 顺序表定义 ：顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
24. 两两交换链表中的节点
qq_41553240的博客
10-13 152
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 输入：head = [1,2,3,4] 输出：[2,1,4,3] 示例 2： 输入：head = [] 输出：[] 示例 3： 输入：head = [1] 输出：[1] 分析： 解法一：递归 这个有点难想，要画个图，简单来说就是 从最后一个往前面转换 /*...
数据结构与算法：顺序表和链表的学习
m0_66030479的博客
11-11 213
顺序表和链表的学习
队列的应用、栈的应用
微信公众号: 后端码匠
12-06 1068
实验一：队列的应用、栈的应用 一． 实验目的 1、掌握队列的特点(先进先出 FIFO)及基本操作，如入队、出队等。 2、利用循环队列的特点解决实际问题，提高编程能力。 3、掌握栈的特点(先进后出 FILO)及基本操作，如入栈、出栈等。 4、利用栈的特点解决实际问题，提高编程能力。 二． 实验内容 1、编写一个程序实现循环队列的各种基本运算，并在此基础上设计一个主程序，完成如下功能： (1)初始化循环队列； (2)给定一个元素，将此元素插入此队列中； (3)将队头一个元素出队。 2、编程实现顺序栈的各种基本运
链表和顺序表习题（一）
centor的博客
06-15 1924
1.比较顺序表和链表的优缺点，说说它们分别在什么场景下使用？ 链表 顺序表 每个元素的访问 每个节点都需要通过指针找到内存然后加载到缓存中 内存访问时，不需要多次从内存到缓存的步骤 头插，头删，中间位置 直接增加或删除节点 在插入或删除之前要先对之后的数据进行挪动 尾插，尾删 需要对空间进行操作 直接对数据进行操作，空间是之前一次性开辟好的 空间操
数据结构章节练习题（全。含答案）
01-01
数据结构1800试题及答案 按章节来分。内容比较全面。
test:平时练习代码
03-06
测试平时练习代码，自己实现顺序表，单链表，双向链表代码； 20201009一些容易错的地方； 20201010三个数字求准； 20201011八大基本类型的基础代码； 20201012关于，同时，切换的使用以及一些代码练习，某种求前100...
有关约瑟夫环（持有密码版和经典版）C++信息学竞赛13个文件
06-06
基本要求一：利用单向循环链表模拟此过程，按照出列的顺序印出各人的编号。程序运行后，首先要求用户指定初始报数上限值，然后读取各人的密码。可设n。此题所用的循环链表中不需要头结点，注意空表和非空表的界限。 ...
leetcode2-DataStructureDemo:数据结构学习。1、啊哈算法
06-29
3、单向链表是否有环 4、合并两个有序链表 5、删除链表倒数第 n 个结点 6、求单向链表的中间结点 二、栈 1、Java实现顺序栈、链式栈 三、队列 1、顺序队列、链式队列 2、循环队列 四、排序算法 1、冒泡排序 2、插入...
【C++】顺序表，链表，栈的练习（千万要会做）每日小细节007
weixin_71138261的博客
11-12 537
【C++】顺序表，链表，栈的练习（千万要会做）
数据结构逻辑
qq_42129915的博客
06-10 289
1、线性关系2：树型关系3：图像关系。
二叉树顺序结构——堆的结构与实现
qq3304968099的博客
06-10 851
二叉树顺序结构——堆的结构与源代码实现
数据结构-二叉树的基本操作
最新发布
WinterXJujube的博客
06-13 332
顺序存储结构适用于完全二叉树，用一组连续的存储单元按照完全二叉树的每个结点编号的顺序存放结点内容。顺序存储利用了完全二叉树的结点编号的性质。特点是空间利用率高，便于寻找孩子和双亲。但是如果二叉树不是完全二叉树，则需要将空缺的位置用其他符号填补，如果空缺的结点过多则会导致空间利用率的下降。因此，为了更好的应对一般情况，需要对二叉树的结点个数进行动态存储。
数据结构（树）
lazy_girl_666的博客
06-07 615
原先的左子节点变成新的父节点，并把多余的右子节点出让，给已经降级的根节点当左子节点。原先的右子节点变成新的父节点，并把多余的左子节点出让，给已经降级的根节点当右节点。如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些Nil视为叶节点，每个叶节点（Nil）是黑色的；步骤： 1） 把不平衡的点作为支点，把支点左旋降级，变成左子结点，晋升原来的右子节点。对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点。当根节点左子树的左子树有节点插入，导致二叉树不平衡。
数据结构和矩阵细节用法：double、cell和complex #matlab
m0_56619132的博客
06-08 1003
简单来说，结构矩阵的每一列为一个变量，即类似于分类变量，每个变量下的数据类型是相同的，例如姓名下的数据全是文本，学号下的数据全是数值；而单位矩阵的各个矩阵是不同的，第一行第一列是数值，第一行第二列可能是文本，第二行第一列可能又是包含n个元素的矩阵，即你可以理解为单元矩阵是“乱输一通”的的矩阵。注：在这个例子中，T是一个table，包含三列：一列是double类型的数字，一列是char类型的字母，还有一列是logical类型的标志。用“()”输出整行，用“.”和“()”结合输出具体的某行某列的元素。
数据结构---查找
code袁的博客
06-10 934
🦁作者简介：一名喜欢分享和记录学习的在校大学生💥个人主页code袁💥个人QQ🐯个人wechat：code8896手动码字，如有错误，欢迎在评论区指正💬~你的支持就是我更新的最大动力💪~
考研系列-数据结构第二章、线性表
Nelson_hehe的博客
06-09 1697
本文是408考研付费专栏系列-数据结构线性表章节，本文章详细地总结了线性表的相关知识，其中包括：顺序表、链表（单链表、双链表、循环链表、静态链表等）的细节和重要知识点汇总。考研听课、复习的好帮手。
数据结构重要知识总结
A18937260063的博客
06-11 624
数据结构重要知识总结
双向链表和单向链表的区别
05-25
单向链表是一种链式存储结构，每个节点只有一个指针指向下一个节点，而最后一个节点的指针指向空。双向链表是在单向链表的基础上增加了一个指向前一个节点的指针，这样每个节点就有两个指针，一个指向前一个节点，一个指向下一个节点。 因此，双向链表相较于单向链表具备以下优点： 1. 可以双向遍历链表，访问某个节点的前驱节点和后继节点更加方便。 2. 在某些操作中，双向链表可以比单向链表更快速地找到某个节点的前驱节点。 3. 双向链表相对于单向链表需要更多的空间来存储节点的前驱指针，但是在某些情况下，这种额外空间可以换来更高效的操作。 但是，相对于单向链表，双向链表的实现会更复杂，需要更多的代码和更高的维护成本。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值