顺序表（一篇带你掌握顺序表）

已于 2023-03-17 22:49:15 修改
阅读量1k 收藏 3
点赞数
文章标签： 数据结构 算法 c语言
于 2023-03-04 21:01:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62692838/article/details/129327063
版权

目录

一、顺序表是什么

1.1 概念

1.2 分类

1.3 结构

二、顺序表的基本操作

2.1 前绪准备

2.2 初始化

2.3  扩容

2.5 尾插

 2.6 打印

2.7 尾删

2.8 头插

 2.9 头删

 2.10 在pos位置插入

 2.11 删除pos位置的数据

 2.12 查找

三、完整代码

3.1 Test.c文件

3.2 SeqList.h文件

3.3 SeqList.c文件

四、与顺序表相关的例题

4.1 移除元素

4.1.1 题目描述

4.1.2 题目分析

4.2 删除有序数组中的重复项

4.2.1 题目描述

4.2.2 题目分析

4.3 合并两个有序数组

4.3.1 题目描述

4.3.2 题目分析

五、顺序表的缺陷

 

一、顺序表是什么

1.1 概念

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

1.2 分类

     顺序表可以分为静态顺序表和动态顺序表。

  1. 静态顺序表：使用定长数组存储元素。
  2. 动态顺序表：使用动态开辟的数组存储。

相对来说动态顺序表的优势大，静态顺序表，不太实用，局限性大。

1.3 结构

     顺序表需要对存储的数据进行管理，存储的数据本质上是使用数组存储，要对数据进行管理就需要知道顺序表中存储元素的个数，其次如果创建的是动态的顺序表，那么还需要记录下它的容量，对于动态顺序表，我们单用某一种类型的变量无法将他准确的描述出来，它包含顺序表有效元素个数，顺序表的容量以及顺序表开辟的空间的地址三个主要元素，无法使用某种单一的类型来表示，所以我们需要定义一个结构体类型。     

typedef struct SeqList
{
    SLDataType* a;   //开辟的空间的起始地址
    int size;     //有效数据的个数
    int capacity;   //空间容量
}SL;

一个简单的顺序表可以由下图来表示：

fe14a59db3874dba9d23338fd21f0799.png
     

二、顺序表的基本操作

     在此处，我们分装成SeqList.h、SeqList.c以及Test.c这三个文件来实现顺序表的完整操作，在SeqList.h中定义顺序表需要的函数，SeqList.c中实现顺序表的操作，Test.c中实现主函数，完成一系列的操作，在本文章的第二部分，主要是对顺序表的每个操作进行讲解，整体实现在第三部分。

顺序表主要有以下操作：

void SeqInit(SL* s);    //初始化
void SeqDestory(SL* s);           //销毁
void SLPushBack(SL* s, SLDataType x);       //尾插
void SLPrint(SL* s);        //打印
void SLPopBack(SL* s);     //尾删
void SLCheckCapacity(SL* s);      //扩容
void SLPushFront(SL* s, SLDataType x);        //头插
void SLPopFront(SL* s);      //头删
void SLInsert(SL* s,int pos, SLDataType x);           //从pos位置插入
void SLErase(SL* s, int pos);        //删除pos位置的元素
int SLFind(SL* s, SLDataType x);             //找某个数在顺序表中的位置

2.1 前绪准备

     我们是创建的动态顺序表，即动态开辟空间，空间不够再进行扩容操作，为了我们写的顺序表有更广泛地使用，定义 INIT_CAPACITY 来表示容量大小，以便我们后续对容量进行改变。我们在此顺序表设置的起始开辟的容量为4（在本文章展示的顺序表存储的是int类型数据，这里指的是开辟4个int类型的空间，即16字节的空间）。

#define INIT_CAPACITY 4

     顺序表中可以存储不同类型的元素，为了使我们写的顺序表具有广泛性，在这里我们使类型重定义，用SLDataType代表某种类型。在本文章中我们存储的是int类型的数据。

typedef int SLDataType;

2.2 初始化

     对于一个顺序表，我们主要关注顺序表有效元素个数，顺序表的容量以及顺序表开辟的空间的地址三个主要元素，对他进行初始化，即对这三个要素进行初始化。

     对于顺序表的初始化函数，我们需要注意传参的时候需要传的是地址，我们在此函数中，需要改变结构体的内容，就要传结构体的指针，很多同学在这里会出现以下错误，我们通过图来解释：
 

4b53aaf971c649b7881bdad3961c7c26.png

05c651a0d1fb464f9c9dd7e794639e50.png

void SeqInit(SL* ps)
{
	assert(ps);     //断言，ps为空时，顺序表不存在，再进行下面操作没有意义
	ps->a = (SLDataType*)malloc(INIT_CAPACITY * sizeof(SLDataType));     //动态开辟空间
	if (ps->a == NULL)         //判断开辟空间是否成功
	{
		perror("malloc fail");
		return;
	}
	ps->size = 0;
	ps->capacity = INIT_CAPACITY;
}

     上面开辟空间时，我们使用了malloc函数，对此函数不了解的可以参照下图：

60bb5a803392457ab21fbb0977b5e44a.png

2.3  扩容

     在对顺序表进行插入的时候，有可能存在将开辟的空间用完的情况即空间中存储的数据有效个数与容量相等，这个时候我们就需要进行扩容，一般是将容量扩充到当前的二倍。

     我们需要注意：

  • realloc的第二个参数传的是扩容后的总字节数。
  • realloc分为原地扩容和异地扩容，如果是原地扩容那么realloc调用后返回的地址与原空间的地址相同，如果是异地扩容，那么realloc将返回新的地址，所以在这里我们需要将tmp的值赋给ps->a。
void SLCheckCapacity(SL* ps)             //扩容
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		SLDataType * tmp = (SLDataType*)realloc(ps->a, ps->capacity * sizeof(SLDataType)*2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
}

     上述函数中在扩容的时候我们使用的是realloc函数，对他使用不熟练的同学可以看下图：
15b30046f14f41898245189ddb4eac6a.png

2.5 尾插

      对于顺序表的尾插，我们主要需要注意以下两个问题：

  • 需要考虑是否扩容，这里直接复用上面的扩容函数

     尾插的原理：

4dab796ac4024b48937d60c5bd5c7809.png

 

void SLPushBack(SL* ps, SLDataType x)       //尾插
{
	assert(ps);
	SLCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}

 2.6 打印

     我们对顺序表进行增删查改等操作后需要打印来观察顺序表是否进行了增删查改操作。

void SLPrint(SL* ps)        //打印
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

2.7 尾删

     对于顺序表的尾删，我们需要知道顺序表主要是通过size来看空间中的有效数据个数，对于尾删，只需要使size--即可。

     尾删有个前提条件就是空间中存在数据，如果空间中没有数据，那么删除就会出问题，在这里我们使用assert（断言），assert后面括号中的内容为假就会直接报错，为真操作忽略。

adc30b5e0f8746438840681726ca6215.png     

尾删的代码如下：

void SLPopBack(SL* ps)    //尾删
{
	assert(ps);
	assert(ps->size > 0);
	ps->size--;

}

     注意：对于动态开辟的空间在释放时只能整块整块的释放，不能在中间随意位置进行释放。

2.8 头插

     顺序表的底层存储是数组，且是连续的地址进行存储，如果要在头部插入一个数据，那么就要移动后面的数据。

09b53f656c7a4f5c8ed8ee8fb59da56f.png

void SLPushFront(SL* ps, SLDataType x)        //头插
{
	assert(ps);
	SLCheckCapacity(ps);

	int end = ps->size-1;
	while (end >= 0)
	{
		ps->a[end+1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

 2.9 头删

     顺序表的头删与头插正好相反，他需要从前向后挪动数据，具体情况如下：
 

35d53f9ed1534ca5af9f0285c450f349.png

void SLPopFront(SL* ps)      //头删
{
	assert(ps);
	assert(ps->size > 0);

	int begin = 0;
	while (begin < ps->size - 1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}

 2.10 在pos位置插入

     在pos位置插入，我们首先要对pos位置是否合法进行判断，避免出现越界等问题，其次此函数也可以在头插，尾插函数中进行复用。

5144ccd637ed4aceb8fbdb1d72be299c.png

void SLInsert(SL* ps, int pos, SLDataType x)         //从pos位置插入
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size;
	while (end > pos)
	{
		ps->a[end] = ps->a[end - 1];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

 2.11 删除pos位置的数据

     删除pos位置的数据，首先也要判断pos位置是否合法，其次删除pos位置，要将pos位置之后的数据依次往前挪动。

1e84f422d780419eb3f8b483fdd06568.png

void SLErase(SL* ps, int pos)        //删除pos位置的元素
{
	assert(ps);
	assert(pos>=0&&pos<ps->size);
	int begin = pos;
	while (begin < ps->size - 1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}

 2.12 查找

     我们有时候会在顺序表中找某一个值，就用到了查找函数。

int SLFind(SL* ps, SLDataType x)             //找某个数在顺序表中的位置
{
	assert(ps);
	int search = 0;
	while (search < ps->size)
	{
		if (x == ps->a[search])
		{
			return search;
		}
	}
	return -1;
}

     在此函数中，如果找到，返回下标，没有找到，就返回-1.

三、完整代码

     注意由于顺序表的操作多，在每写完一个操作后，我们最好测试一下，所以在Test.c中有多个测试函数。

3.1 Test.c文件

#include "SeqList.h"

void TestSeqList1()
{
	SL s;
	SeqInit(&s);    //初始化

	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushBack(&s, 5);

	SLPrint(&s);

    SeqDestory(&s);           //销毁

}

void TestSeqList2()
{
	SL s;
	SeqInit(&s);    //初始化

	SLPushBack(&s, 1);

	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushBack(&s, 5);

	SLPrint(&s);

	SLPopBack(&s);
	SLPrint(&s);

	SLPopBack(&s); 
	SLPrint(&s);

	SLPopBack(&s);
	SLPopBack(&s);
	SLPopBack(&s);
	SLPrint(&s);

	SeqDestory(&s);           //销毁

}

void TestSeqList3()
{
	SL s;
	SeqInit(&s);    //初始化

	SLPushFront(&s, 1);
	SLPushFront(&s, 2);
	SLPushFront(&s, 3);
	SLPushFront(&s, 4);
	SLPushFront(&s, 5);
	SLInsert(&s, 2, 10);

	SLPrint(&s);

	SLErase(&s,2);
	SLPrint(&s);

	SLPopFront(&s);
	SLPrint(&s);

	SLPopFront(&s);
	SLPrint(&s);

	SLPopFront(&s);
	SLPopFront(&s);

	SLPopFront(&s);
	SLPrint(&s);


	SeqDestory(&s);           //销毁

}


int main() 
{
	TestSeqList3();
	return 0;
	
}

3.2 SeqList.h文件

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int SLDataType;
#define N 10
#define INIT_CAPACITY 4


静态顺序表
//typedef struct SeqList
//{
//	SLDataType a[N];
//	int size;
//};

//动态顺序表
typedef struct SeqList
{
	SLDataType* a;   //开辟的空间的起始地址
	int size;     //有效数据的个数
	int capacity;   //空间容量
}SL;

void SeqInit(SL* s);    //初始化
void SeqDestory(SL* s);           //销毁
void SLPushBack(SL* s, SLDataType x);       //尾插
void SLPrint(SL* s);        //打印
void SLPopBack(SL* s);     //尾删
void SLCheckCapacity(SL* s);      //扩容
void SLPushFront(SL* s, SLDataType x);        //头插
void SLPopFront(SL* s);      //头删
void SLInsert(SL* s,int pos, SLDataType x);           //从pos位置插入
void SLErase(SL* s, int pos);        //删除pos位置的元素
int SLFind(SL* s, SLDataType x);             //找某个数在顺序表中的位置

3.3 SeqList.c文件

#include "SeqList.h"
void SeqInit(SL * ps)
{
	assert(ps);
	ps->a = (SLDataType*)malloc(INIT_CAPACITY * sizeof(SLDataType));
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->size = 0;
	ps->capacity = INIT_CAPACITY;
}

void SeqDestory(SL* ps)          //销毁
{
	free(ps->a);
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

void SLPushBack(SL* ps, SLDataType x)       //尾插
{
	assert(ps);
	SLCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}


void SLCheckCapacity(SL* ps)             //扩容
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		SLDataType * tmp = (SLDataType*)realloc(ps->a, ps->capacity * sizeof(SLDataType)*2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
}

void SLPrint(SL* ps)        //打印
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

void SLPopBack(SL* ps)    //尾删
{
	assert(ps);
	assert(ps->size > 0);
	ps->size--;

}

void SLPushFront(SL* ps, SLDataType x)        //头插
{
	assert(ps);
	SLCheckCapacity(ps);

	int end = ps->size-1;
	while (end >= 0)
	{
		ps->a[end+1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

void SLPopFront(SL* ps)      //头删
{
	assert(ps);
	assert(ps->size > 0);

	int begin = 0;
	while (begin < ps->size - 1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}

void SLInsert(SL* ps, int pos, SLDataType x)         //从pos位置插入
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size;
	while (end > pos)
	{
		ps->a[end] = ps->a[end - 1];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

void SLErase(SL* ps, int pos)        //删除pos位置的元素
{
	assert(ps);
	assert(pos>=0&&pos<ps->size);
	int begin = pos;
	while (begin < ps->size - 1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}

int SLFind(SL* ps, SLDataType x)             //找某个数在顺序表中的位置
{
	assert(ps);
	int search = 0;
	while (search < ps->size)
	{
		if (x == ps->a[search])
		{
			return search;
		}
	}
	return -1;
}

四、与顺序表相关的例题

4.1 移除元素

4.1.1 题目描述

题目链接：https://leetcode.cn/problems/remove-element/

     给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

     不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

     元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

4.1.2 题目分析

思路一：

     以空间换时间，本方法主要是在创建一个数组arr，用一个指针遍历原数组，将原数组中不等于val的值依次存放在arr数组中，然后将arr数组中的内容拷贝到原数组中。

     注意此方法的时间复杂度是：O(n)，我们要对原数组遍历一遍，需要有一个循环，基本语句的执行次数是n次，此方法的空间复杂度是：O(n)，由于在力扣环境中不支持C99中的变长数组，所以我们这里创建的数组个数按照题目中nums数组的最大个数来看，但是它的量级依然属于n。

9b6d90c7031a441d90d820deea9404c1.png

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

思路二：

     双指针，定义两个指针，src和dst，都从下标为0开始，如果src处的值不等于val，把它赋值到dst处，然后dst和src都加1，如果src处的值等于val，只对src加1，依次往后遍历，直到src=numsSize结束。

     此方法的时间复杂度为：O(n)，其中 n 为序列的长度。我们只需要遍历该序列至多两次。空间复杂度是：O(1)，我们只需要常数的空间保存若干变量。

0b29012c4b9149dcb416339eb9bf5b05.png

a712f8e910a24cc58ec4eeab348e7b48.png

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

4.2 删除有序数组中的重复项

4.2.1 题目描述

题目链接：26. 删除有序数组中的重复项 - 力扣（LeetCode）

     给你一个升序排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次 ，返回删除后数组的新长度。元素的 相对顺序应该保持一致 。  

4.2.2 题目分析

思路：

     双指针，如果src和dst下标对应的值相同那么dst加1，如果src和dst下标对应的值不相同src加1，然后那dst下标对应的值赋给src下标对应的值。

b98cc93798f44e92aadab6352cfc238b.png

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

4.3 合并两个有序数组

4.3.1 题目描述

题目链接：88. 合并两个有序数组 - 力扣（LeetCode）

     给你两个按非递减顺序排列的整数数组nums1和nums2，另有两个整数m和n ，分别表示 nums1和nums2中的元素数目。

     请你合并nums2到nums1中，使合并后的数组同样按非递减顺序排列。

4.3.2 题目分析

思路：

     我们要将两个数组合并，如果都从前面即下标为0处开始比较，会涉及较多的移动数据问题，所以我们倒着比，用三个指针，其中dst是合并好数组的最后一个下标，end2是nums2数组的最后一个下标，end1是nums1数组的最后一个下标，如果nums[end2]大于nums[end1]则移动到nums1[dst]位置上。

     

04414d742e1d4c47a1cc8cceb3217f1f.png

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] = nums2[end2];
			end2--;
			dst--;
		}
		else
		{
			nums1[dst] = nums1[end1];
			end1--;
			dst--;
		}
	}
	while (end2 >= 0)
	{
		nums1[dst--] = nums2[end2--];
	}
}

五、顺序表的缺陷

顺序表有许多的问题：

  1. 中间/头部的插入删除，时间复杂度为：O(N)
  2. 增容需要申请新空间，拷贝数据，释放旧空间，会有不小的消耗。
  3. 增容一般呈2倍的增长，势必会有一定的空间浪费。

 

李有鱼
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构中顺序表的相关查找算法
qq_15718789的博客
10-08 8291
今天给大家带来的是相关数据结构的查找算法，相信读过前几篇相关数据结构构建的读者应该能体会到两种常用数据结构的相关基础知识。 查找算法的基础就需要数据结构的支撑，很显然，我们需要掌握的是顺序表和动态链表的查找方法，下面我会一一解答。 这一篇我们就细谈第一种.顺序表的查找算法，很简单，就是对数组下标的运算，由此衍生出来的查找算法有三种： 分别是 简单顺序查找，有序表的二分查找以及索引顺序表的查找
新概念C语言.李一波(带详细书签).pdf
02-10
由于学生对语言已具有了初步的了解并掌握了最基本的语法和程序设计思想，能设计较简单的程序，所以在提高篇的学习中，不论对灵活语法的学习和掌握，还是对程序设计思想的掌握都更加容易，从而可以较容易达到教学目标...
数据结构实验一 顺序表的应用
m0_63708766的博客
06-09 329
1. 利用教材中定义顺序表类型存储病人病历信息(病历号,姓名，症状)；2.设计顺序表定位查找算法，写成一个函数，完成的功能为:在线性表L中查找数据元素x，如果存在则返回线性表中和x值相等的第1个数据元素的序号；如果不存在，则返回-1。请在主函数中测试查找是否存在姓名为x的病人，并根据返回的序号打印出病人信息。用顺序表实现病历信息的管理与查询功能。2、掌握顺序表的插入、删除算法的思想和实现，并能灵活运用。1、掌握建立顺序表的基本方法。数据结构实验一 顺序表的应用。
数据结构手把手教学——顺序表
Sanjay_Wu的博客
12-01 2168
文章不空谈理论，完全采用手把手教学，并有综合示例练习题，看完这篇，你绝对能掌握数据结构顺序表。
C语言实现顺序表的创建及基本操作
热门推荐
weixin_43954729的博客
03-21 2万+
今天主要是分享一下我在学习数据结构的顺序表时实现的一些基本操作，以及学习过程当中遇到的一些问题。我觉得学习这一部分内容的时候，除了要掌握基本操作方法的编写，还要学会对方法进行**实例化**。由于课本上这一部分的内容比较少，我也是查阅了CSDN上的许多文章才明白的。
三分钟学会数据结构顺序表
暴躁小吕的博客
10-19 1784
本篇博客涉及顺序表的定义，顺序表的静态实现和动态实现，还有顺序表增删改查等基本操作的实现，让你三分钟掌握数据结构——顺序表
顺序表、链表刷题指南（力扣OJ）
2202_75605090的博客
08-03 6313
无论是面试准备还是日常编码实践，解决与顺序表和链表相关的算法问题都是不可避免的挑战，本篇文章旨在帮助你巩固和提升这两个重要数据结构的理解和应用能力。刷题不仅是为了应对面试和编码实践，更是为了培养自己的问题解决能力和学习能力。无论是顺序表还是链表，它们都是构建更复杂数据结构的基石，掌握它们对你的编程之路至关重要。
【数据结构】顺序表和单链表(C语言版)
weixin_62007227的博客
02-24 1326
一篇文章让你搞懂单链表的基本操作[通过图画轻松掌握] 前言 提示：本篇记录自学《大话数据结构》的链表章节 主要是代码的理解，不会出现很多概念定义 一、顺序存储之顺序表 定义 顺序表也叫(顺序存储结构) ，是一种用一段地址连续的存储单元依次存储线性表的数据元素。 顺序表的示意图 二、线性表的顺序存储结构 #define Max_sz 20 /代表数组最大容量 ty.
【数据结构与算法】顺序表和链表
比昨天强一点就好的博客
03-16 4045
线性表(linear list)是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。从以上就很容易看出，在缓存利用率方面，顺序表由于内存是连续的，而链表是一个个单个的节点连起来的，顺序表的命中率绝对要比链表高不少！
C语言数据结构篇——顺序表的理解，创建，插入和删除
Demo不是emo的博客
01-16 1万+
作为一名才接触c语言半年的大一学生，在自学数据结构时是非常痛苦的，单是第一章顺序表的创建与操作就令我苦不堪言，在经过两天的钻研后，基本才算理顺了顺序表，所以我就想写下这篇人生中第一篇博客记录我对c语言数据结构中顺序表的理解。（初学者一名，有什么不对的地方大家可以提出来一起讨论，万分感谢） 数据结构主要研究的就是数据在计算机中的存储和处理方法，而线性表就是最简单而且最常用的一种数据结构，线性表的三大特点，有头结点，尾结点，其他的每个结点都有前驱节点和后驱结点，线性表的顺序存储就称为顺序表。 简单的说，顺序
动态内存分配及动态顺序表的实现
k666499436的博客
05-05 2307
动态内存如何开辟，以及利用动态内存实现动态顺序表
三年级语文下册第七单元22我们奇妙的世界写作背景素材新人教版20200511227
09-09
本文是三年级语文下册第七单元的第一篇课文，作者是彼得·西摩。这是一篇短小精美、条理清晰、语言生动的散文，通过具体描写天空中的缤纷色彩、奇妙形状和大地上丰富的财富，表达了作者对大自然、对美妙世界的热爱。...
LeetCode:以算法训练营的主题为主，labuladong的算法小抄为框架，逐渐提炼结题框架，训练算法思维，关注边界细节，熟练数据结构
04-03
一片，体积，栈链表树与递归哈希表双指针思想篇（30天）这些思想是投资回报率极高的，强烈推荐每一个小的专题花一定的时间掌握。二分滑动窗口搜索（BFS，DFS，回溯）动态规划提高篇（31天）这部分收益没那么明显，...
部编版语文七年级下册期中考试卷及答案解析.pdf
10-22
5. 顺序排列最恰当的一项是（3分） 这道题考查了学生对语言的逻辑思维和语言组织能力，能够正确地表达思想是语言学习的重要目标。 6. 文学常识表述不正确的一项是（3分） 这道题考查了学生对文学常识的掌握程度，...
施工的资料整理.doc
04-25
第一篇 验收规范及竣工验收表格的填写 第一章 检验批质量验收记录表 一、表的名称及编号 检验批验收表为GB50300—2001附录D．0．1。 检验批由监理工程师或建设单位项目技术负责人组织项目专业质量检查员等进行验收...
英语四六级：如何在短期内利用答题小技巧提分100+(2).docx
03-27
仔细阅读一篇不要要控制在15分钟内，总共两篇，要提高该部分的准确率。这样长篇阅读和仔细阅读大概会花40分钟。  3. 翻译部分考试大纲建议时间是30分钟，实际上基础差的同学反而用不了这么多时间。建议此类同学可以...
实验一 顺序表的基本操作
最新发布
09-22
顺序表是一种线性表的存储结构，它的基本操作包括： 1. 初始化：init(sqlist &L)，构造一个空的顺序表。 2. 判断是否为空表：empty(sqlist L)，判断顺序表L是否为空表。 3. 求线性表长度：length(sqlist L)，求顺序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值