数据结构---线性表---顺序表

最新推荐文章于 2024-07-22 19:36:52 发布
最新推荐文章于 2024-07-22 19:36:52 发布
阅读量222 收藏 3
点赞数 7
分类专栏： 数据结构 文章标签： 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74288306/article/details/129351784
版权

目录

前言

在前面数据结构章节的学习中，我们一起学习了通过时间复杂度和空间复杂结构来判断一个算法的好坏，而我们本章节将一起学习线性表中的数据结构–顺序表。

1.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串。线性表在逻辑上是线性结构，也就是说是连续的一条直线，但在物理结构上并不是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
在这里插入图片描述

2.顺序表的概念及结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。

顺序表一般可以分为：

1.静态顺序表：使用定长数组存储元素
在这里插入图片描述
2.动态顺序表：使用动态开辟的数组存储：
在这里插入图片描述

3.接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了空间开多浪费，开少了空间不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间的大小，所以下面我们就一起实现动态顺序表。

3.1创建动态结构体：

#define INIT_CAPICITY 3
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a;//指向动态开辟的数组
	size_t size;//有效数据的个数
	size_t capicity;//容量的大小
}SeqList;

解释： 在创建动态结构体的同时用#define定义一个标识符INIT_CAPICITY，为后面开辟空间做准备，同时方便我们进行调试；用typedef对存储值的数据类型进行重命名，如果后面存储的值为其他类型可以直接对齐进行更改即可。

3.2顺序表的初始化：

void SeqListInit(SeqList* ps)
{
	assert(ps);//检查地址是否为空
	SeqList* tmp = (SeqList*)malloc(sizeof(SeqList) * INIT_CAPICITY);
	if (tmp == NULL)
	{
		perror("SeqListInit::malloc");
		return;
	}
	ps->a = tmp;
	ps->capicity = INIT_CAPICITY;
	ps->size = 0;
}

首先，需要用malloc函数为顺序表开辟一定的空间，给我们程序员输入数据使用，把开辟空间的地址传给ps->a,并对我们创建的ps->capacity、ps->size进行初始化。

3.3顺序表的头插

void Checkcapacity(SeqList* ps)
{
	assert(ps);
	if (ps->size == ps->capicity)
	{
		SeqList* tmp = (SeqList*)realloc(ps->a, sizeof(SeqList) * INIT_CAPICITY * 2);
		if (tmp == NULL)
		{
			perror("Checkcapacity::realloc");
			return;
		}
		printf("增容成功\n");
		ps->a = tmp;
		ps->capicity = INIT_CAPICITY * 2;
	}
}
void SeqListPushBack(SeqList* ps, SLDataType x)
{
	assert(ps);
	Checkcapacity(ps);//检查空间是否足够
	ps->a[ps->size++] = x;
}

解释： 在构造SeqListPushBack函数时，对顺序表开辟的空间，进行检查空间是否满了；如果满了，则需要重新调整顺序空间大小，等会我们构造顺序表头插、任意插函数也需要判断顺序表的空间是否已满，所以我们直接构造一个Checkcapacity函数进行检查，同时也方便后面函数的重复利用。

顺序表的打印

void SeqListPrint(SeqList* ps)
{
	assert(ps);
	//暴力检查
	assert(ps->size > 0);
	///温柔检查
	//if (ps->size <= 0)
	//{
	//	return;
	//}
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

调试代码运行的结果：
在这里插入图片描述

3.4顺序表的尾删

void SeqListPoshBack(SeqList* ps)
{
	//暴力检查
	assert(ps->size>0);
	///温柔检查
	//if (ps->size <= 0)
	//{
	//	return;
	//}
	ps->size--;
}

解释： 在尾删函数SeqListPoshBack中，需要对顺序表有效数据的个数进行判断，如果有效数据个数为零，则不能进行删除，所以需要进行判断：①可以暴力检查用assert进行断言，直接返回发生错误的行数；②可以用if语句进行判断，如果有效数据个数为零，return直接返回，什么都没有发生，后面在其他函数中使用这些语句的原理是一样的。删除操作：①ps->a[ps->size-1]=0;ps->size--;②ps->size--，即把有数数据个数减一，不让其打印出来就可以了（也可以最后一个的有效数据的值改为0）。

代码调试的结果为：
在这里插入图片描述

3.5顺序表头插

}
void SeqListPushFront(SeqList* ps, SLDataType x)
{
	assert(ps);
	Checkcapacity(ps);//检查空间是否足够
	int end=ps->size;
	for (; end>0; end--)
	{
		ps->a[end] = ps->a[end - 1];
	}
	ps->a[0] = x;
	ps->size++;
}

解释： 需要把原来位置的数据往后挪动，为了保证原来的数据完整，所以应该从最后面的数据开始挪动，直至把顺序表的头位置的原数据移动到下一个位置为止，并把预留出来的位置放入数据x。

顺序表的头删

void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	int i = 0;
	for (i = 0; i < ps->size - 1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}

解释： 头删函数 SeqListPopFront需要把顺序表头位置的数据删除掉，其他位置的数据的位置也发生相应的改动，从头位置开始把下一个数据覆盖到头位置，直至最后一个位置的数据往前覆盖完成为止（注意for循环的判断条件），然后ps->size--，有效数据个数减一即可。

代码运行的结果为：
在这里插入图片描述

顺序表的任意插

void SeqListInsert(SeqList* ps, size_t pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	Checkcapacity(ps);//检查空间是否足够
	int end = ps->size;
	for (; end > pos; end--)
	{
		ps->a[end] = ps->a[end - 1];
	}
	ps->a[pos] = x;
	ps->size++;
}

解释： 在顺序表任意插函数 SeqListInsert中，要判断插入的位置，是否在允许的范围内；为保证原数据完整，数据应从顺序表尾位置开始，把数据往后挪动一位，直到把pos位置的数据往后一位移动为止，最后把数据x放到预留的pos位置，ps->size++。

3.6顺序表的任意删

void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	int i = pos;
	for (; i < ps->size-1; i++)
	{
		ps->a[i] = ps->a[i+1];
	}
	ps->size--;
}

解释： 在顺序表的任意删 SeqListErase中，从pos位置开始（包括pos）,把下一个位置的数据移动到当前位置，直至最后一个位置的数据挪动完成为止，然后ps->size--，和顺序表头删的原理一样。
代码调试的结果为：
在这里插入图片描述

3.7顺序表的查找

int SeqListFind(SeqList* ps, SLDataType x)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

代码运行的结果为：
在这里插入图片描述

3.8顺序表的销毁

void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	ps->capicity = ps->size = 0;
}

3.90 由顺序表任意插函数改造的顺序表尾插

void SeqListPushBack(SeqList* ps, SLDataType x)
{
	//版本一
	//assert(ps);
	//Checkcapacity(ps);//检查空间是否足够
	//ps->a[ps->size++] = x;
	//版本二
	SeqListInsert(ps, ps->size, x);
}

代码运行的结果为：
在这里插入图片描述

3.91由顺序表任意插函数改造的顺序表尾删

void SeqListPoshBack(SeqList* ps)
{
	//版本一
	暴力检查
	//assert(ps->size>0);
	/温柔检查
	if (ps->size <= 0)
	{
		return;
	}
	//ps->size--;
	//版本二
	SeqListErase(ps, ps->size - 1);
}

代码运行的结果为：
在这里插入图片描述

3.92由顺序表任意插函数改造的顺序表头插

void SeqListPushFront(SeqList* ps, SLDataType x)
{
	//版本二
	//assert(ps);
	//Checkcapacity(ps);//检查空间是否足够
	//int end=ps->size;
	//for (; end>0; end--)
	//{
	//	ps->a[end] = ps->a[end - 1];
	//}
	//ps->a[0] = x;
	//ps->size++;
	//版本二
	SeqListInsert(ps, 0,x);
}

代码运行的结果为：
在这里插入图片描述

3.93由顺序表任意插函数改造的顺序表头删

void SeqListPopFront(SeqList* ps)
{
	//版本一
	//assert(ps);
	//assert(ps->size > 0);
	//int i = 0;
	//for (i = 0; i < ps->size - 1; i++)
	//{
	//	ps->a[i] = ps->a[i + 1];
	//}
	//ps->size--;
	//版本二
	SeqListErase(ps, 0);
}

代码运行的结果为：
在这里插入图片描述

4.0顺序表源码及测试

4.1Seqlist.h

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

#define INIT_CAPICITY 3
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a;//指向动态开辟的数组
	size_t size;//有效数据的个数
	size_t capicity;//容量的大小
}SeqList;
//顺序表的初始化
void SeqListInit(SeqList* ps);

//顺序表的销毁
void SeqListDestroy(SeqList* ps);

//检查空间，判断是否需要增容
void Checkcapacity(SeqList* ps);

//顺序表的打印
void SeqListPrint(SeqList* ps);

//顺序表的尾插
void SeqListPushBack(SeqList* ps,SLDataType x);

//顺序表的尾删
void SeqListPoshBack(SeqList* ps);

//顺序表的头插
void SeqListPushFront(SeqList* ps, SLDataType x);

//顺序表的头删
void SeqListPopFront(SeqList* ps);

//在顺序表的pos位置插入x
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x);

//删除顺序表pos位置的值
void SeqListErase(SeqList* ps, size_t pos);

//顺序表的查找
int SeqListFind(SeqList* ps, SLDataType x);

4.2Seqlist.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Seqlist.h"
void SeqListInit(SeqList* ps)
{
	assert(ps);//检查地址是否为空
	SeqList* tmp = (SeqList*)malloc(sizeof(SeqList) * INIT_CAPICITY);
	if (tmp == NULL)
	{
		perror("SeqListInit::malloc");
		return;
	}
	ps->a = tmp;
	ps->capicity = INIT_CAPICITY;
	ps->size = 0;
}
void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	ps->capicity = ps->size = 0;
}
void Checkcapacity(SeqList* ps)
{
	assert(ps);
	if (ps->size == ps->capicity)
	{
		SeqList* tmp = (SeqList*)realloc(ps->a, sizeof(SeqList) * INIT_CAPICITY * 2);
		if (tmp == NULL)
		{
			perror("Checkcapacity::realloc");
			return;
		}
		printf("增容成功\n");
		ps->a = tmp;
		ps->capicity = INIT_CAPICITY * 2;
	}
}
void SeqListPushBack(SeqList* ps, SLDataType x)
{
	//版本一
	//assert(ps);
	//Checkcapacity(ps);//检查空间是否足够
	//ps->a[ps->size++] = x;
	//版本二
	SeqListInsert(ps, ps->size, x);
}
void SeqListPrint(SeqList* ps)
{
	assert(ps);
	//暴力检查
	assert(ps->size > 0);
	///温柔检查
	//if (ps->size <= 0)
	//{
	//	return;
	//}
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
void SeqListPoshBack(SeqList* ps)
{
	//版本一
	暴力检查
	//assert(ps->size>0);
	/温柔检查
	if (ps->size <= 0)
	{
		return;
	}
	//ps->size--;
	//版本二
	SeqListErase(ps, ps->size - 1);
}
void SeqListPushFront(SeqList* ps, SLDataType x)
{
	//版本二
	//assert(ps);
	//Checkcapacity(ps);//检查空间是否足够
	//int end=ps->size;
	//for (; end>0; end--)
	//{
	//	ps->a[end] = ps->a[end - 1];
	//}
	//ps->a[0] = x;
	//ps->size++;
	//版本二
	SeqListInsert(ps, 0,x);
}
void SeqListPopFront(SeqList* ps)
{
	//版本一
	//assert(ps);
	//assert(ps->size > 0);
	//int i = 0;
	//for (i = 0; i < ps->size - 1; i++)
	//{
	//	ps->a[i] = ps->a[i + 1];
	//}
	//ps->size--;
	//版本二
	SeqListErase(ps, 0);
}
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	Checkcapacity(ps);//检查空间是否足够
	int end = ps->size;
	for (; end > pos; end--)
	{
		ps->a[end] = ps->a[end - 1];
	}
	ps->a[pos] = x;
	ps->size++;
}
void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	int i = pos;
	for (; i < ps->size-1; i++)
	{
		ps->a[i] = ps->a[i+1];
	}
	ps->size--;
}
int SeqListFind(SeqList* ps, SLDataType x)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

4.3test.c

#include"Seqlist.h"

//#define N 7
//typedef int SLDataType;
//typedef struct SeqList
//{
//	SLDataType array[N];
//	size_t size;
//}SqeList;
//顺序表的动态存储
void TestSeqlist1()
{
	//定义结构体变量
	SeqList s;
	//初始化顺序表
	SeqListInit(&s);
	顺序表尾插
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPrint(&s);
	顺序表尾删
	SeqListPoshBack(&s);
	SeqListPoshBack(&s);
	顺序表打印及销毁
	SeqListPrint(&s);
	SeqListDestroy(&s);
	
}
void TestSeqlist2()
{
	SeqList s;
	SeqListInit(&s);
	//顺序表头插
	SeqListPushFront(&s, 1);
	SeqListPushFront(&s, 2);
	SeqListPushFront(&s, 3);
	SeqListPushFront(&s, 4);
	SeqListPushFront(&s, 5);
	SeqListPrint(&s);
	//顺序表头删
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	//顺序表打印及销毁
	SeqListPrint(&s);
	SeqListDestroy(&s);
}
void TestSeqlist3()
{
	SeqList s;
	SeqListInit(&s);
	//头插
	SeqListPushFront(&s, 1);
	SeqListPushFront(&s, 2);
	SeqListPushFront(&s, 3);
	SeqListPushFront(&s, 4);
	SeqListPushFront(&s, 5);
	SeqListPrint(&s);
	//任意插
	SeqListInsert(&s, 2, 6);
	SeqListInsert(&s, 2, 7);
	SeqListPrint(&s);
	//任意删
	SeqListErase(&s, 2);
	SeqListErase(&s, 2);
	SeqListPrint(&s);
	//顺序表查找
	int ret=SeqListFind(&s, 1);
	if (ret == -1)
	{
		printf("找不到\n");
	}
	else
	{
		printf("该数字在第%d位\n",ret);
	}
	//顺序表销毁
	SeqListDestroy(&s);
}
int main()
{
	//TestSeqlist1();
	TestSeqlist2();
	//TestSeqlist3();
	return 0;
}

5.0数组相关面试题

练习一：
在这里插入图片描述

int removeElement(int* nums, int numsSize, int val)
{
    int src=0;
    int dst=0;
    while(src<numsSize)
    {
        if(nums[src]!=val)
        {
            nums[dst++]=nums[src++];
        }
        else
        {
            src++;
        }
    }
    return dst;
}

图形理解：
在这里插入图片描述
练习二：
在这里插入图片描述

int removeDuplicates(int* nums, int numsSize)
{
	int src = 1;
	int dst = 0;
	while(src < numsSize)
	{
		if (nums[src] == nums[dst])
		{
			src++;
		}
		else
		{
			nums[++dst] = nums[src++];
		}
	}
	return dst + 1;
}

图形理解：
在这里插入图片描述
在这里插入图片描述

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) 
{
	int end1 = m - 1;
	int end2 = n - 1;
	int dst = m + n - 1;
	while (end1 >= 0 && end2 >= 0)
	{
		if (nums1[end1] > nums2[end2])
		{
			nums1[dst--] = nums1[end1--];
		}
		else
		{
			nums1[dst--] = nums2[end2--];
		}
	}
	while (end2 >= 0)
	{
		nums1[dst--] = nums2[end2--];
	}
}

图形理解：
在这里插入图片描述

1.原地删除数组中所有的元素val,要求时间复杂度是O(N)，空间复杂度为O（1）。OJ链接
2.删除数组的重复项。OJ链接
3.合并两个有序的数组。 OJ链接
以上是数组题链接，大家感兴趣可以试试。

总结

本章我们一起学习了链表中顺序表的相关概念、模拟实现了顺序表以及完成了相关的数组题加以巩固，希望对大家认识顺序表结构有些许帮助！最后感谢大家的阅读，如有不对欢迎纠正!🎠🎠🎠

吾与C
关注
  • 7
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
数据结构线性表——顺序表
m0_56611833的博客
11-05 105
文章目录线性表概念顺序表概念顺序表初始化顺序表打印顺序表销毁顺序表增容顺序表尾插顺序表尾删顺序表头插顺序表头删顺序表元素查找顺序表指定位置插入（中间位置插入）顺序表指定位置删除（中间位置删除）复用SeqLsitInsert实现头插尾插复用SeqLsitErase实现头删尾删总结 线性表概念 定义：线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表在逻辑上是线性结构。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 常见的线性表：顺序表、链
【数据结构】线性表之顺序表
没有感情的代码机器的博客
07-09 202
线性表是一种最常见、最简单，也是一种最基本的数据结构，它是学习其他数据结构的基础。线性表有两种存储结构：顺序表和链表。下面我主要介绍顺序表。 所谓顺序表，就是顺序存储的线性表。顺序存储是用一组地址连续的存储单元一次存放线性表中各个数据元素的存储结构。顺序表基本使用数组来实现。 顺序表的特点： 在线性表中逻辑上相邻的数据元素，在物理存储位置上也是相邻的 存储密度高，但需要预先分配“足够应用”的存储...
数据结构-顺序表详解（含完整代码）
qq_65641647的博客
09-10 6659
数据结构：顺序表详解，里面含有完整代码，对算法的分析，简单明了，一看就会哦。
队列的应用、栈的应用
微信公众号: 后端码匠
12-06 1073
实验一：队列的应用、栈的应用 一． 实验目的 1、掌握队列的特点(先进先出 FIFO)及基本操作，如入队、出队等。 2、利用循环队列的特点解决实际问题，提高编程能力。 3、掌握栈的特点(先进后出 FILO)及基本操作，如入栈、出栈等。 4、利用栈的特点解决实际问题，提高编程能力。 二． 实验内容 1、编写一个程序实现循环队列的各种基本运算，并在此基础上设计一个主程序，完成如下功能： (1)初始化循环队列； (2)给定一个元素，将此元素插入此队列中； (3)将队头一个元素出队。 2、编程实现顺序栈的各种基本运
Data Structure 顺序表练习题（两道）
weixin_44491160的博客
02-09 722
数据结构 课堂实验二 实验报告
【数据结构入门】顺序表（SeqList）详解（初始化、增、删、查、改）
热门推荐
codewinter的博客
08-18 7万+
文章目录（1）线性表（2）顺序表1）什么是顺序表2）顺序表的定义2）顺序表的接口实现1、初始化顺序表2、销毁（释放）顺序表3、检查顺序表容量是否满了，好进行增容3、顺序表尾插4、顺序表尾删5、顺序表头插6、顺序表头删7、打印顺序表8、在顺序表中查找指定值9、在顺序表指定下标位置插入数据10、在顺序表中删除指定下标位置的数据11、查看顺序表中有效数据个数12、修改指定下标位置的数据 （1）线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结
数据结构-顺序结构的线性表
01-06
数据结构-顺序表
数据结构C语言-顺序表PPT课件.ppt
12-27
数据结构C语言顺序表知识点 根据提供的PPT课件，以下是相关的知识点： 1. 线性表的逻辑结构 * 线性表是由n（n≥0）个类型相同的数据元素组成的有限序列。 * 线性表的逻辑结构可以用以下形式表示：L=(a1, a2,...,...
数据结构学习--线性表及其应用--顺序表
06-25
通过这样的实验，学习者能够更好地理解顺序表的特性和基本操作，为后续学习更复杂的数据结构如树、图等打下坚实的基础。同时，对顺序存储结构的熟悉也有助于提升对数组、指针等基础知识的运用能力。在实际编程中，...
数据结构线性表--顺序表
11-17
使用软件为dev c++，使用c语言，用计算机类书籍《数据结构》中介绍的线性表中的顺序存储结构，建立了一个学生年龄表，可以实现基本的 插入 查找 删除 遍历，各个功能函数写有注释，方便阅读。
DS-数据结构线性表完美版资料.ppt
12-01
DS-数据结构线性表完美版资料.ppt 线性表是一种常用的数据结构，属于线性结构的范畴。线性表是具有相同数数据类型的n（n≥0）个数数据元素的有有限序列，通常记为：（a1, a2, …, ai-1, ai, ai+1, …, an）。其中，...
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1066
可以参考以下视频。
数据结构day3
qq_55245263的博客
07-18 286
顺序表实现学生管理系统
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 714
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
数据结构---二叉树
最新发布
weixin_47808575的博客
07-22 44
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构第35节 性能优化 算法的选择
hummhumm的专栏
07-18 734
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
【数据结构】堆的实现以及建堆算法和堆排序
2301_81670477的博客
07-19 972
哈喽，各位小伙伴大家好！上期给大家讲了树，二叉树以及堆。今天带着大家实现堆这个数据结构，以及堆排序。话不多说，咱们进入正题！向大厂冲锋！
数据结构之细说链表
m0_73634434的博客
07-17 1081
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1102
24暑假刷题day15打卡 二叉树进阶
线性表与顺序表详解-数据结构教程
"该资源是关于数据结构学习的，特别是针对顺序表的讲解。它涵盖了线性表的基本概念、特点、应用以及相关的操作，并探讨了线性表与数组的区别，同时还介绍了线性表的抽象数据类型（ADT）及其相关操作的定义。" 在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值