数据结构之顺序表的增删查改等操作详解

最新推荐文章于 2024-04-26 23:46:11 发布
最新推荐文章于 2024-04-26 23:46:11 发布
阅读量2.1k 收藏 10
点赞数 8
分类专栏： 数据结构 文章标签： 顺序表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/attemptendeavor/article/details/119352469
版权

顺序表的增删查改

文章目录

顺序表

一段物理地址连续的存储单元依次存储数据元素的线性结构，其实就是数组，要求存储的数据是依次连续存储

顺序表的顺序存储示意图如下：

image-20210802091020155

静态顺序表：使用定长数组存储元素

固定大小的定义，给小了可能不够用，给大可能浪费

动态顺序表：使用动态开辟的数组存储

动态适应我们需求的大小，比较灵活

所

以我们主要针对动态顺序表进行讲解顺序表的增删查改等操作实现

首先我们创建三个文件，分别是：

image-20210802091637636

SeqList.h对相关头文件的包含，以及实现顺序表的结构和函数的声明

SeqList.c对实现顺序表增删查改等操作的函数进行定义

test.c文件进行顺序表相关函数和顺序表功能的测试

我们实现顺序表，首先需要对顺序表结构进行定义

//动态顺序表结构
typedef struct SeqList
{
    int* a;//定义一个指针指向动态开辟的内存，即存储顺序表数据的空间
    int size;//当前顺序表的数据个数
    int capacity;//顺序表的容量
};

在动态顺序表结构中，我们定义了一个指针指向动态开辟的内存，即存储顺序表数据的空间，定义size记录当前顺序表的数据个数，定义capacity记录当前顺序表的容量，但是我们想一下，我们顺序表的存储数据一定是整形吗？万一我想改变顺序表的数据类型呢？这样定义的话，我们想要改变顺序表的数据类型时，就会很麻烦，所有涉及到的地方都需要修改，所以我们这样定义：

typedef int SQDataType
//动态顺序表结构
typedef struct SeqList
{
    SQDataType* a;//定义一个指针指向动态开辟的内存，即存储顺序表数据的空间
    int size;//当前顺序表的数据个数
    int capacity;//顺序表的容量
}SLT;

这样定义我们在想要修改顺序表存储的数据类型时，就直接在typedef(类型重定义)这里修改就可以了，这样就方便了很多。

接下来我们在test.c中创建一个结构体变量(注意包含SeqList.h头文件)，开始定义顺序表的增删查改等操作。

然后我们来写顺序表的初始化接口的实现：

在定义函数之前，我们考虑这么一件事情

注意：

InitSeqList(s);
InitSeqList(&s);

我们在传结构体变量时是传值呢还是传址呢？

答案是传地址，因为函数传参的时候，参数是需要压栈的。如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降。

顺序表的初始化

void SeqListInit(SLT* psl)
{
    assert(psl);//我们断言一下，因为创建结构体变量的地址不能为NULL
    psl->a=NULL;
    psl->size=psl->capacity=0;
}

因为创建结构体变量的地址不能为NULL，所以我们在里面断言一下，将指针a置为空以及size和capacity置为0。

有初始化顺序表那就有销毁顺序表，下面我们看顺序表的销毁

顺序表的销毁

void SeqListDestory(SLT* psl)
{
    assert(psl);
    if(psl->a)
    {
       	free(psl->a); 
    	psl->a=NULL;  
    }   
}

当指向动态开辟的内存的指针不为NULL时，说明有顺序表的数据，我们将这段动态开辟的空间释放掉，并把它置为NULL。

然后我们再写一个打印顺序表数据的函数：

打印顺序表数据

void SeqListPrint(SLT* psl)
{
    assert(psl);
    int i=0;
    for(i=0;i<psl->size;i++)
    {
        printf("%d ",psl->a[i]);
    }
    printf("\n");
}

打印的函数十分简单，就是相当于数组的遍历而已

写完上面的这些函数，我们就要进入我们顺序表的增删查改等操作的正题了。

顺序表尾插数据

首先是尾插数据函数，那么我们如何尾插一个元素呢？有人会说，我们不是有一个记录数据个数的变量size嘛，那么比如当前元素个数是size，那么我们要尾插的位置的下标应该就是size，仔细想一想对不对呢？是对的。但是我们在尾插前需要考虑的是，我们现在都没有空间，怎么存放数据呀，就算有了空间，你怎么知道当前这块空间有没有满呢？这里就需要用到我们的capacity变量了，故我们在尾插前一定要先检查是不是需要增容。

由于后面的一些操作也会用到考虑是不是需要增容，所以我们将判断是不是需要增容封装成一个函数：

void SeqListCheckCapacity(SLT* psl)
{
    assert(psl);
    if(psl->size==psl->capacity)//当当前元素个数等于我们的当前容量时我们要增容
    {
        //增容
        int newcapacity = psl->capacity==0?4:psl->capacity*2;
        psl->a=(SQDataType*)realloc(psl->a,newcapacity*sizeof(SQDataType));
        if(psl->a==NULL)
        {
            perror("psl->a");
            return;
        }
        psl->capacity=newcapacity;
    }
}

当当前元素个数等于我们的当前容量时我们要增容，我们在增容时，如果capacity是0时我们先开辟存储4个数据的内存，不是0时，我们就进行二倍的增容，如果开辟失败了，我们加一个判断pal->a是不是NULL，是NULL则打印错误返回，最后将capacity更新。

这时我们就可以写尾插的函数了：

void SeqListPushBack(SLT* psl,SQDataType x)
{
    assert(psl);
    //检查增容
    SeqListCheckCapacity(psl);
    psl->a[psl->size]=x;
    psl->size++;
}

首先检查增容，然后进行插入，我们要尾插的位置的下标就是size，插入然后将size++，就实现了尾插的操作。

我们进行测试发现，没有任何问题，完成了插入。

image-20210802103115735

下面我们进行下一个操作：头插。

顺序表头插数据

同样地，在头插之前我们需要检查是否需要增容

void SeqListPushFront(SLT* psl,SQDataType x)
{
    assert(psl);
    //检查增容
    SeqListCheckCapacity(psl);
    int end=psl->size-1;
    while(end>=0)
    {
        psl->a[end+1]=psl->a[end];
        end--;
    }
    psl->a[0]=x;
    psl->size++;
}

image-20210802104411992

在头插时，我们需要将后面的元素依次向后移动一个单元，然后在第一个位置插入，最后size++。

注意：

在移动元素时，我们需要从后往前开始移动，从前往后会将后面元素覆盖。

下面我们再进行下一个操作：尾删

void SeqListPopBack(SLT* psl)
{
    assert(psl);
    if(psl->size>=)
    {
    	psl->size--;
    }
}

尾删非常简单，我们直接将size–，就相当于删除了最后一个元素。

尾删之后我们再来看看头删：

顺序表头删数据

void SeqListPopFront(SLT* psl)
{
    assert(psl);
   	int begin=0;
    while(begin<psl->size-1)
    {
        psl->a[begin]=psl->a[begin+1];
        begin++;
    }
    psl->size--;
}

image-20210802105903503

头删我们只需要将第一个元素后面的元素从前往后依次向前移，就将第一个元素删除，然后size–即可。

注意：

在移动元素时，我们需要从前往后开始移动，从后往前会将前面元素覆盖。

之后我们再来看看如何找到一个元素x

int SeqListFind(SLT* psl, SQDataType x)
{
    assert(psl);
    int i=0;
    for(i=0;i<psl->size;i++)
    {
        if(psl->a[i]==x)
        {
            return i;//找到，返回下标
        }
    }
    return -1;//找不到
}

找到一个元素x也十分简单，就是遍历数组似的遍历一遍，判断是不是等于x，是的话返回下标，循环遍历完，说明没有找到，那么返回-1(找不到)。

那么我们能不能在一个指定位置进行插入元素呢？

答案是可以的，接下来我们来看在指定位置插入一个元素：

顺序表指定位置插入元素

void SeqListInsert(SLT* psl,size_t pos,SQDataType x)
{
    assert(psl);
    assert(pos<=psl->size-1&&pos>=0)
    size_t end=psl->size-1;
    while(end>=pos)
    {
        psl->a[end+1]=psl->a[end];
        end--;
    }
    psl->a[pos]=x;
   	psl->size++;
}

注意：size_t等价于unsigned int，有些人写出上面代码时，应该是觉得没什么问题，万无一失，感觉肯定是对的，但是不然，上面代码有隐含的错误点，是一个难点。

image-20210802121921434

代码崩了为什么呢？

这里的问题就出现在了无符号整形上，我们想一想，在size等于0时，此时end是-1，按理说while循环不会进去了，但是我们调试发现，他还是可以进去循环，为什么呢？就是因为end是无符号整形，这里会发生提升，end等于-1时，在内存中存储是：11111111111111111111111111111111，但end是无符号的，计算机会将他认为无符号的看待，会将32个全1翻译成4,294,967,295，故循环会进去。在pos等于0时，这个情况也会发生，因为要出循环，end就会减到-1，pos等于0时，end会减到-1，end是无符号整形，有符号整形和无符号整形进行运算时，会发生提升，-1会被提升为很大的数，此时循环也进去了，就会出现问题。

为了解决这个问题我们怎么做呢？

将end和pos都换成int类型，可以解决这个问题，但是由于C++库里面这个顺序表插入元素函数pos就用的是size_t类型，所以我们这里也用size_t类型，那么我们还要哪种改法呢？

改法一：

避免end等于-1，改变end的初始值以及进入循环条件

void SeqListInsert(SLT* psl,size_t pos,SQDataType x)
{
    assert(psl);
    assert(pos<=psl->size-1&&pos>=0)
    size_t end=psl->size;
    while(end > pos)
    {
        psl->a[end]=psl->a[end-1];
        end--;
    }
    psl->a[pos]=x;
   	psl->size++;
}

改法二：

将end改为int类型，因为无符号数遇到有符号数会转化为有符号数，所以将pos强制类型转换为有符号数

void SeqListInsert(SLT* psl,size_t pos,SQDataType x)
{
    assert(psl);
    assert(pos<=psl->size-1&&pos>=0);
    int end=psl->size-1;
    while(end>=(int)pos)
    {
        psl->a[end+1]=psl->a[end];
        end--;
    }
    psl->a[pos]=x;
   	psl->size++;
}

经过测试，发现可以正常运行了：

image-20210802121506888

总结：要避免负数给到无符号，或者避免有符号数变成负数以后，被提升或者强转为有符号。

明白了上面这个点，我们来看下一个函数实现，指定位置元素删除

指定位置元素删除

void SeqListErase(SLT* psl, size_t pos)
{
    assert(psl);
    assert(psl->size>0);
    assert(pos<=psl->size-1&&pos>=0);
    int begin=pos;
    while(begin<psl->size-1)
    {
        psl->a[begin]=psl->a[begin+1];
        begin++;
    }
    psl->size--;
}

和上面讲的头删原理差不多，唯一区别就是断言pos的取值范围，还有就是开始移动的位置不一样，这里的移动位置是参数传递的，位置是指定的。

我们测试可以发现可以正常运行：

image-20210802122055325

最后我们再讲解两个简单的操作，返回数据的个数和将一个位置的数据改为x

返回顺序表总数据的个数

//返回数据的个数
size_t SeqListSize(SLT* psl)
{
	assert(psl);
	return psl->size;
}

很多人好奇，这么简单的操作为什么要写成函数呢？我们写成函数是有道理的，如果我们直接在外面用s.size去访问size多简单呀，虽然可以这样访问，但是数据结构约定，我们进行数据访问以及修改都进行函数的方式进行，这样是更规范的行为

修改数据

//将一个位置的数据改为x
void SeqListAt(SLT* psl, size_t pos, SQDataType x)
{
	assert(psl);
	assert(pos < psl->size);

	psl->a[pos] = x;
}

如果我们直接去修改，不用函数，则这样修改：例如s.a[3]=8;

这样编译器不会报错对你进行检查，我们举个例子：image-20210802123728767

我们这里只有两个元素，而s.a[3]=8，直接将第4个元素修改了，这里明明越界了，编译器没有报错，实际上我们没有真越界，因为我们刚开始是有4个元素的空间的，只是修改了size之外的空间。越界不一定报错，越界的检查是一种抽查。越界写是如果修改到标志位才会检查出来.而我们调用函数时，直接会检查出来错误，不会有那么多的麻烦。

以上就是我们约定：我们进行数据访问以及修改都进行函数的方式进行的原因

三个文件的源代码：

SeqList.h(头文件的包含以及顺序表结构以及函数的声明)

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

typedef int SQDataType;

//顺序表结构
typedef struct SeqList
{
	SQDataType *a;
	int size;//数据个数
	int capacity;//容量
}SLT;


//顺序表的初始化
void InitSeqList(SLT* psl);

//顺序表的销毁
void DestorySeqList(SLT* psl);

//顺序表的增删查改


void SeqListPushBack(SLT* psl, SQDataType x);//O(1)

void SeqListPushFront(SLT* psl, SQDataType x);//需要挪动数据O(N)

void SeqListPopBack(SLT* psl);//O(1)

void SeqListPopFront(SLT* psl);

//打印顺序表
void PrintSeqList(SLT* psl);

int SeqListFind(SLT* psl, SQDataType x);

//void SeqListInsert(SLT* psl,int pos, SQDataType x);

void SeqListInsert(SLT* psl,size_t pos, SQDataType x);
//
void SeqListErase(SLT* psl,size_t pos);
//
size_t SeqListSize(SLT* psl);
//
void SeqListAt(SLT* psl,size_t pos, SQDataType x);

SeqList.c(顺序表操作函数的定义)

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"
//初始化顺序表
void InitSeqList(SLT* psl)
{
	assert(psl);

	psl->a = NULL;
	psl->size = psl->capacity = 0;
}
//销毁顺序表
void DestorySeqList(SLT* psl)
{
	assert(psl);
	if (psl->a)
	{
		free(psl->a);
		psl->a = NULL;
	}
	psl->capacity = psl->size = 0;
}


//检查增容
void SeqListCheckCapacity(SLT* psl)
{
	assert(psl);
	if(psl->size == psl ->capacity)
	{
		//增容
		int newcapacity = psl->capacity == 0 ? 4 : psl->capacity *2 ;
		psl->a =(SQDataType*)realloc(psl->a,newcapacity*sizeof(SQDataType));
		if (psl->a == NULL)
		{
			perror("SeqListCheckCapacity");
			return;
		}
		psl->capacity = newcapacity;
	}
}
//尾插头插，尾删头删
//尾插
void SeqListPushBack(SLT* psl, SQDataType x)
{
	assert(psl);
	//检查增容
	SeqListCheckCapacity(psl);
	psl->a[psl->size] = x;
	psl->size++;
}

//头插
void SeqListPushFront(SLT* psl, SQDataType x)
{
	assert(psl);
	SeqListCheckCapacity(psl);
	int end = psl->size - 1;//最后一个元素下标
	while (end>=0)
	{
		psl->a[end + 1] = psl->a[end];
		end--;
	}
	psl->a[0] = x;
	psl->size++;
}

//尾删
void SeqListPopBack(SLT* psl)
{
	assert(psl);
	assert(psl->size > 0);
	if (psl->size>0)
	{
		psl->size--;
	}
}

//头删
void SeqListPopFront(SLT* psl)
{
	assert(psl);
	assert(psl->size > 0);
	int begin = 0;
	while (begin<psl->size-1)
	{
		psl->a[begin] = psl->a[begin + 1];
		begin++;
	}
	psl->size--;
}

//打印数据
void PrintSeqList(SLT* psl)
{
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

//找到一个元素x
int SeqListFind(SLT* psl, SQDataType x)
{
	assert(psl);
	int i = 0;
	for (i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			printf("找到了，下标为：%d\n", i);
			return i;
		}
	}
	printf("找不到\n");
	return -1;
}
//
//void SeqListInsert(SLT* psl, size_t pos, SQDataType x)
//{
//	assert(psl);
//	assert(pos >= 0 && pos <= psl->size);
//	size_t end = psl->size - 1;//size==0时end=-1，-1>=0,本来循环进不去，但是这里end会提升，所以进去了，就出问题了
//	while (end >= pos)//pos等于0时，end会减到-1，end是无符号整形，-1会被算术转换为很大的数，此时循环也进去了，就会出现问题
//	{
//		psl->a[end + 1] = psl->a[end];
//		end--;
//	}
//	psl->a[pos] = x;
//	psl->size++;
//}

//上面这个不能插入在顺序表的头怎么解决呢？
//这里将pos和end类型改为int类型可以解决
//void SeqListInsert(SLT* psl, int pos, SQDataType x)
//{
//	assert(psl);
//	assert(pos <= psl->size && pos >= 0);
//	int end = psl->size - 1;
//	while (end >= pos)
//	{
//		psl->a[end + 1] = psl->a[end];
//		end--;
//	}
//	psl->a[pos] = x;
//	psl->size++;
//}

//但是我们c++中库里面这个pos是size_t类型,不改变类型我们如何解决问题呢？
//怎么让pos类型不改变，就为size_t,也让头插可以复用



//解决方案1：
void SeqListInsert(SLT* psl, size_t pos, SQDataType x)
{
	assert(psl);
	assert(pos <= psl->size && pos >= 0);//有效数字范围内
	SeqListCheckCapacity(psl);
	size_t end = psl->size;//将end改为psl->size，end就不会变成-1
	while (end > pos)//只有pos==0或者size==0才会出问题导致end会等于-1，提升就会出问题，
	{
		psl->a[end] = psl->a[end-1];
		end--;
	}
	psl->a[pos] = x;
	psl->size++;
}

//解决方案2
//void SeqListInsert(SLT* psl, size_t pos, SQDataType x)
//{
//	assert(psl);
//	assert(pos <= psl->size && pos >= 0);//有效数字范围内
//	SeqListCheckCapacity(psl);
//	int end = psl->size - 1;
//	while (end >=(int) pos)
//	{
//		psl->a[end + 1] = psl->a[end];
//		end--;
//	}
//	psl->a[pos] = x;
//	psl->size++;
//}

//避免负数给到无符号，或者避免有符号数变成负数以后，被提升或者强转成有符号

//删除某个位置的元素
void SeqListErase(SLT* psl, size_t pos)
{
	assert(psl);
	assert(pos <= psl->size&&pos>=0);

	size_t begin = pos + 1;
	while (begin < psl->size)
	{
		psl->a[begin - 1] = psl->a[begin];
		begin++;
	}
	psl->size--;
		
}

//返回数据的个数
size_t SeqListSize(SLT* psl)
{
	assert(psl);
	return psl->size;
}

//将一个位置的数据改为x
void SeqListAt(SLT* psl, size_t pos, SQDataType x)
{
	assert(psl);
	assert(pos < psl->size);

	psl->a[pos] = x;
}

test.c(顺序表操作的测试)

#include"SeqList.h"
void TestSeqList1()
{

	SLT s;
	//顺序表的初始化
	InitSeqList(&s);//值传递
	//SeqListPushFront(&s, 5);

	/*SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);*/


	SeqListInsert(&s, 0, 6);
	SeqListInsert(&s, 1, 7);
	PrintSeqList(&s);

	//s.a[3] = 8;
	//SeqListErase(&s, 1);
	//PrintSeqList(&s);
	
	//SeqListPopBack(&s);
	//SeqListPopFront(&s);

	//PrintSeqList(&s);
	SeqListFind(&s, 3);



	//PrintSeqList(&s);

	

	//SeqListAt(&s, 2, 9);
	//PrintSeqList(&s);

	//DestorySeqList(&s);
}

欢迎大家前来讨论学习，如果觉得文章不错，点赞评论+收藏哦！！！

小赵小赵福星高照～
关注
  • 8
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
知名公司数据结构笔试题
04-20
数据结构在计算机科学中占有...以上是题目中涉及到的数据结构和算法的知识点详解，涵盖了链表、二叉树、排序、哈希表、数组、查找和排序算法的性能分析等核心概念。理解和熟练掌握这些知识点对于解决实际问题至关重要。
链表实验报告1
08-03
《链表实验报告1》是关于数据结构课程中链表操作的一个实验报告，主要目标是实现一个可适用于各种数据类型的顺序表。实验内容包括链表的基本操作，如插入、删除、查找、显示以及文件的读写。以下是实验涉及的知识点...
【数据结构】顺序表（Seqlist)详解-增删查改
weixin_62357106的博客
01-09 1650
【数据结构】顺序表的实现及增删查改的功能
动态顺序表的增删查改
cx的学习经历
04-23 179
全网最细数据结构之顺序表
【数据结构】顺序表增删查改（超详细）
最新发布
qq_74897518的博客
04-26 1425
顺序表
关于顺序表的基本操作（c语言）
qq_71984179的博客
05-28 889
我将对顺序表进行简单地介绍。由于顺序表的动态存储比静态存储使用更广泛，默认顺序表用动态存储，介绍了顺序表的基本操作，包括初始化、销毁、查找（1.元素2.元素位置）、插入、删除、扩容、判空、输出、返回表长等等，希望让读者对顺序表有一个大致的了解。作者也是考研人，打算跟着考研内容更新代码，希望能和各位考研人一起进步！
顺序表的增删查改（数据结构）
Marksky的博客
05-10 1631
顺序表的增删查改
顺序表的十个基本操作（全）
热门推荐
兔子王
10-02 1万+
有关顺序表的十个基本操作，包括 1、初始化顺序表 2、插入 3、删除 4、查找 5、修改 6、逆置 7、排序 8、按序插入 9、按序合并 10、最小值
5.4_1_树的存储结构1
08-03
这种存储方式便于增删查改操作，但存储空间可能因额外的链表指针而增加。 3. **孩子兄弟表示法**： 这种方法将树转化为二叉树形式，每个节点有两个指针，一个指向其第一个孩子，另一个指向其下一个兄弟节点。这样...
PHP留言板模块源码详解
03-26
PHP通过SQL查询语句与数据库进行交互，实现数据的增删查改操作。 模块结构通常包括以下几个部分： 1. **前端界面**：这是用户直接看到和交互的部分，通常由HTML和CSS构建。HTML定义了页面的结构，CSS则负责样式和...
航空订票系统程序（订票，查询，退票等功能）
01-13
在航空订票系统中，链表用于存储机票信息，如航班号、出发地、目的地、起飞时间、价格等，便于高效地进行增删查改操作。 二、订票功能 订票功能是系统的基础，用户输入相关信息，系统会在链表中查找可用座位，并...
顺序表的增删改查，顺序表
10-10
本程序的顺序表是利用数组实现的，能对数组元素进行增删改查的基本操作
顺序表（增删查改的详细操作）---Java语言
wxx200008的博客
03-31 1935
顺序表其实很简单！！！
顺序表的基本操作（初始化，增，删，查，改等等）
weixin_74795859的博客
05-07 981
千万不要写成ps->a[ps->sz-1]=0;但这个代码存在一定的问题，因为一直尾删ps->sz--如果一直--下去，它会出现越界，会出现ps->sz=-1的位置存放有效数据，相当于越界，当一直尾删到ps->sz==0的位置再减减ps->sz==-1，然后再进行尾插的时候就会出现越界，还有断言pos，因为在我们插入数据的时候，可能会超过size本身的容量就插入，比如有4个空间，别人在空间以外20的位置插入了30，就会发生越界行为，所以我们要断言一下0
C语言实现顺序表增删查改操作
春天的熊的博客
04-10 7936
C语言实现顺序表增删查改操作线性表是最常用且最简单的一种数据结构。线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。结构如下图图片来自百度 为了描述顺序表，我们声明一个结构，如下： #define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量 #define LIST_INCREMENT 10 //线性表存储空间的分配增量typedef int Elem
顺序表的创建插入和修改
LH2HA3的博客
01-27 811
在数据结构中顺序表属于顺序结构，和链表并列。对顺序表的操作一般有，创建顺序表、遍历顺序表、插入元素在顺序表中、删除某元素以及查找某元素在顺序表中的位置。当然链表也有这些操作，但是相对链表我认为顺序表这些基本操作更容易实现，但是牺牲了程序的时间和空间。  以下本人以一个完整的程序来说明实现顺序表中的一些操作（主要是插入和删除），程序写得相对简单没有考虑程序的健壮性。#include #includ
顺序表及其初始化、头插、头删、尾插、尾删、在指定位置插入和删除元素、查找、扩容等操作
weixin_46153828的博客
02-24 1202
首先记录一下线性表的概念： 线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串。 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 1. 静态顺
顺序表中的删除和插入
castle_kao的博客
12-06 8193
顺序表中的运算无非四种，增删改查： 增：即向顺序表中插入数据，大部分情况下都是向一个有序表中插入，要是无序的话就先排序。 删：删除顺序表中的一个或多个元素，通过数据覆盖来消除原来数据。 改：找到数据，修改数据。本质上还是查找。 查：用查找算法查找数据。
数据结构C语言实现顺序表——增删查改操作实现详解
weixin_58401910的博客
09-21 3137
一段物理地址连续的存储单元依次存储数据元素的线性结构，其实就是数组，要求存储的数据是依次连续存储。
顺序表增删查改的时间自由度
04-04
增操作：在顺序表的末尾进行插入操作的时间复杂度为O(1)，在其他位置进行插入操作的时间复杂度为O(n)，因为需要将插入位置之后的数据全部向后移动一位。 删操作：在顺序表的末尾进行删除操作的时间复杂度为O(1)，在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小赵小赵福星高照～

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值