【数据结构】顺序表详解

最新推荐文章于 2024-07-30 16:20:55 发布
最新推荐文章于 2024-07-30 16:20:55 发布
阅读量3.1k 收藏 58
点赞数 69
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyqzjw/article/details/132615363
版权

当我们写完通讯录后，顺序表肯定难不倒你，跟着小张一起来学习顺序表吧！

线性表

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

在这里插入图片描述

顺序表

概念及结构

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

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

接口实现

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

typedef struct pro
{
	int* p;// 指向动态开辟的数组
	int size;// 有效数据个数
	int capcity;// 容量空间的大小

}pro;
void  SeqListInit(pro* ps );//初始化顺序表
void CheckCapacity(pro* ps);//判断是否空间不够，进行扩容
void  SeqListPushBack(pro* ps,int x);//尾插
void  SeqListPushFront(pro* ps, int x);//头插
void SeqListPopBack(pro* ps);//尾删
void  SeqListPopFront(pro* ps);//头删
void  SeqListPrint(pro* ps);//打印顺序表
void SeqListInsert(pro* ps, int pos, int x);//随意插
void SeqListErase(pro* ps, int pos);//随意删
void SeqListFind(pro* ps, int pos);//查找
void SeqListmodify(pro* ps, int x,int y);//修改
void SeqListDestory(pro* ps);//销毁

结构体定义和创建一个结构体变量

typedef struct pro
{
	int* p;// 指向动态开辟的数组
	int size;// 有效数据个数
	int capcity;// 容量空间的大小

}pro;
int main()
{
	pro info;//定义一个结构体变量
}

初始化顺序表

void  SeqListInit(pro* ps )//初始化顺序表
{
	ps->p = NULL;
	ps->size = 0;
	ps->capcity = 0;
	
}

初始化顺序表，有效数据个数为0，容量空间大小为0，还未给数据动态开辟空间，指向动态开辟空间的指针指向空地址

扩容顺序表

void CheckCapacity(pro* ps)//判断是否空间不够，进行扩容
{
	if (ps->size == ps->capcity)
	{
		int newcapcity = ps->capcity == 0 ? 4 : (ps->capcity) * 2;
		int* tmp = (int*)realloc(ps->p, sizeof(int) * newcapcity);
		if (tmp == NULL)
		{
			perror("realloc fail!!");

        }
		ps->p = tmp;
		ps->capcity = newcapcity;

   }


}

什么时候需要扩容顺序表呢？？当顺序表刚被初始化，你要进行插入数据时，发现容量空间已经满了，此时必须要扩容空间，当你要插入第一个数据时，在此之前，顺序表没有任何数据，容量空间为0，然后要插入数据的话，也必须扩容。
条件判断如果有效数据个数等于容量大小时，分两种情况，第一种，刚开始的时候，有效数据个数和容量大小都为0的时候，第二种，当要插入数据时，发现此时的有效数据个数和容量大小相等时，且不等于0.对空间进行扩容， newcapcity变量是新的容量大小，当需要扩容的时候，直接新容量为原来的2倍，刚开始，他的容量是0，采用三目运算符，如果容量是0的话，就给四个空间大小，如果不是就开原来容量的2倍。将realloc来的空间的地址存放在tmp指针里面，如果realloc失败就返回空指针，打印错误信息，realloc成功的话就将tmp中存放扩容的地址交给指针p,然后容量大小更新为newcapcity。

尾插

void  SeqListPushBack(pro* ps,int x)//尾插
{
	CheckCapacity(ps);
    ps->p[ps->size] = x;
	ps->size++;}

每次插入都要判断是否需要扩容
在这里插入图片描述
然后有效数据+1.

头插

void  SeqListPushFront(pro* ps, int x)//头插
{
	CheckCapacity(ps);
	int end = ps->size - 1;
	while (end>=0)
	{
		ps->p[end + 1] = ps->p[end];
		end--;


    }

	ps->p[0] = x;
	ps->size++;



}

头插一个数据，必须将后面的数据向后面移动，移动的过程中可能超过容量大小，所以在插入时都需要进行扩容判断
在这里插入图片描述
如果按这个顺序移动数据当1挪到2的位置的时候，2这个数据就会被覆盖，所以我们必须从后往前面挪
在这里插入图片描述
在这里插入图片描述当数据挪到后面之后，然后在第一个位置填入x,第一个位置也就是下标为0的位置。
在这里插入图片描述

在下标为0的地方填入 插入的数据x,然后ps->size+1;

尾删

void SeqListPopBack(pro* ps)//尾删
{
	assert(ps);
	assert(ps->size > 0);
	ps->size--;

}

尾巴要删除一个数据的话，我们需要将删除的数据改为0吗？如果要删除的数据本来就是0呢？所以我们只需要将ps->size–;因为打印的时候只打印到下标为ps->size-1的位置，打印出来看起来就像 我们删除了这个数据，注意这里用断言是因为在删除的时候ps->size–,当ps->size<0的时候，在添加数据时
ps->p[-1]=x;这个是不合理的，在ps->size<0时，直接报错，第一个断言是为了防止空指针。

头删

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

}

这里的断言和上面是一个道理，然后相比尾删向后挪动数据，头删是往前挪数据，吸取尾删的教训，我们可以直到移动的顺序是
在这里插入图片描述
定义一个变量begin=1,首先是要将数据2移动到数据1的位置，对应的操作是
ps->p[begin - 1] = ps->p[begin];然后begin++,依次将数据3挪到数据2的位置，数据4挪到数据3的位置。循环最后一次是将数据5挪到数据4的位置，也就是begin=4,ps->size=5.则循环判断条件为beginsize,循环结束后将
ps->size–;

顺序表的打印

void  SeqListPrint(pro* ps)//打印顺序表
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->p[i]);



	}

}

循环遍历顺序表，将每个数据打印出来

随意插

void SeqListInsert(pro* ps, int pos, int x)//随意插
{
	CheckCapacity(ps);
	assert(pos>=0&&pos<=ps->size);
	int end = ps->size - 1;
	while (end>=pos)
	{
		ps->p[end + 1] = ps->p[end];
		end--;

    }
	ps->p[pos] = x;
	ps->size++;
}

断言是为了检查插入的位置是否合理
在这里插入图片描述
当有5个数据时，pos的可能取值如图所示，推广到一般
就是pos>=0&&pos<=ps->size,如果我们想在pos=2的位置插入一个x,我们应该怎么做呢？
1.插入一个x,我们需要将3，4，5向后移动，必须先移动5，定义一个变量end,
在这里插入图片描述
end变量的初值给ps->size-1，也就是4，要想将数据5向后挪动，对应的操作是ps->p[end + 1] = ps->p[end];然后end–;循环分别将4，3向后挪动，循环结束后，将数据x插入到pos=2的位置，对应操作为ps->p[pos] = x;然后有效数据大小ps->size++；

随意删

void SeqListErase(pro* ps, int pos)//随意删
{
	int begin = pos;

	assert(pos >= 0 && pos <= ps->size);
	while (begin<ps->size-1)
	{


		ps->p[begin] = ps->p[begin+1];
		begin++;

    }
	ps->size--;
}

断言判断删除的数据的位置是否合理，和随意插的那里一样
在这里插入图片描述
如果我们要删除数3，然后数据3后面的数据向前挪动，第一步就是将数据4移动到数据3的位置，定义一个变量begin=pos=2;对应的操作为
ps->p[begin] = ps->p[begin+1];，然后begin++;将数据5移动到最开始数据4的地方。最后一次循环是将数据5移动到数据4的地方，也就是begin最后等于3，ps->size=5，则循环判断条件是begin< ps->size-1,循环结束将ps->size–;

顺序表的查找

void SeqListFind(pro* ps, int pos)//查找
{
	assert(pos >= 0 && pos < ps->size);



	printf("你查找的下标是%d,对应的数据是%d", pos, ps->p[pos]);
}

断言保证查找位置的合理性，因为函数传参pos 刚好是要查找数据的下标，直接打印出来

顺序表的修改

void SeqListmodify(pro* ps, int x,int y)//修改
{
	for (int i = 0; i < ps->size; i++)
	{
		if (x == ps->p[i])
		{
			ps->p[i] = y;
		}


  }

}

x为修改前的值，y是修改之后的值，循环遍历顺序表，将顺序表中所有的x都修改成y

顺序表的销毁

void SeqListDestory(pro* ps)//销毁
{
	ps->capcity = 0;
	ps->size = 0;
	free(ps->p);
	ps->p = NULL;





}

销毁一个顺序表，将顺序表的容量置为0，顺序表的有效数据个数置为0，将p指针所指向的动态开辟的内存空间释放了，由于释放了动态开辟的内存空间，所有p指向的空间未初始化，p成为野指针，为了防止野指针，将p置为空指针。

整体代码

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct pro
{
	int* p;// 指向动态开辟的数组
	int size;// 有效数据个数
	int capcity;// 容量空间的大小

}pro;
void  SeqListInit(pro* ps )//初始化顺序表
{
	ps->p = NULL;
	ps->size = 0;
	ps->capcity = 0;
	
}
void CheckCapacity(pro* ps)//判断是否空间不够，进行扩容
{
	if (ps->size == ps->capcity)
	{
		int newcapcity = ps->capcity == 0 ? 4 : (ps->capcity) * 2;
		int* tmp = (int*)realloc(ps->p, sizeof(int) * newcapcity);
		if (tmp == NULL)
		{
			perror("realloc fail!!");



		}
		ps->p = tmp;
		ps->capcity = newcapcity;






	}


}
void  SeqListPushBack(pro* ps,int x)//尾插
{
	CheckCapacity(ps);
    ps->p[ps->size] = x;
	ps->size++;



}
void  SeqListPushFront(pro* ps, int x)//头插
{
	CheckCapacity(ps);
	int end = ps->size - 1;
	while (end>=0)
	{
		ps->p[end + 1] = ps->p[end];
		end--;


    }

	ps->p[0] = x;
	ps->size++;



}
void SeqListPopBack(pro* ps)//尾删
{
	assert(ps);
	assert(ps->size > 0);
	ps->size--;

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

}
void  SeqListPrint(pro* ps)//打印顺序表
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->p[i]);



	}

}
void SeqListInsert(pro* ps, int pos, int x)//随意插
{
	CheckCapacity(ps);
	assert(pos>=0&&pos<=ps->size);
	int end = ps->size - 1;
	while (end>=pos)
	{
		ps->p[end + 1] = ps->p[end];
		end--;

    }
	ps->p[pos] = x;
	ps->size++;
}
void SeqListErase(pro* ps, int pos)//随意删
{
	int begin = pos;

	assert(pos >= 0 && pos <= ps->size);
	while (begin<ps->size-1)
	{


		ps->p[begin] = ps->p[begin+1];
		begin++;

    }
	ps->size--;








}
void SeqListFind(pro* ps, int pos)//查找
{
	assert(pos >= 0 && pos < ps->size);



	printf("你查找的下标是%d,对应的数据是%d", pos, ps->p[pos]);
}
void SeqListmodify(pro* ps, int x,int y)//修改
{
	for (int i = 0; i < ps->size; i++)
	{
		if (x == ps->p[i])
		{
			ps->p[i] = y;
		}





	}






}
void SeqListDestory(pro* ps)//销毁
{
	ps->capcity = 0;
	ps->size = 0;
	free(ps->p);
	ps->p = NULL;





}
int main()
{
	pro info;
	SeqListInit(&info);
	printf("尾插:");
	SeqListPushBack(&info, 1);
	SeqListPushBack(&info, 2);
	SeqListPushBack(&info, 3);
	SeqListPushBack(&info, 4);
	SeqListPrint(&info);
	printf("\n");
	printf("头插:");
	SeqListPushFront(&info, 7);
	SeqListPushFront(&info, 6);
	SeqListPushFront(&info, 5);
	SeqListPushFront(&info, 5);
	SeqListPrint(&info);
	printf("\n");
	printf("尾删:");
	SeqListPopBack(&info);
	SeqListPrint(&info);
	printf("\n");
	printf("头删:");
	SeqListPopFront(&info);
	SeqListPrint(&info);
	printf("\n");
	printf("随意插:");
	SeqListInsert(&info, 1, 1);
	SeqListPrint(&info);
	printf("\n");
	printf("随意删:");
	SeqListErase(&info,1,1);
	SeqListPrint(&info);
	printf("\n");
	printf("查找:");
	SeqListFind(&info, 3);
	printf("\n");
	printf("修改:");
	SeqListmodify(&info, 1, 2);
	SeqListPrint(&info);
	printf("\n");
	printf("销毁:");
	SeqListDestory(&info);
    SeqListPrint(&info);
}
#小多子
关注
专栏目录
数据结构-顺序表
m0_74408955的博客
04-01 397
顺序表可以分为：静态顺序表与动态顺序表此顺序表采用的是动态定义的方法，我们需要将初始化中自己创建在堆上的动态空间传给指针变量a、用a访问空间存储所需数据，而size就代表我们所存储数据的个数，capacity表示顺序表的动态空间大小；最上面的宏定义表示初始化容量设定，typedef定义的类型表示所存数据类型。
【数据结构】顺序表与链表基础知识的超详细详解
小刘好好学习的博客
05-29 889
线性表、顺序表、链表的基础知识与编码实现
顺序表
小宝儿的学习之路
03-26 313
目录： 顺序表 链表 顺序表的线性存储示意图 顺序表 顺序表特点 线性表的逻辑顺序与物理顺序一致，数据元素之间的关系是以元素在计算机内“物理位置相邻”来体现 对顺序表中的所有表项，即可以进行顺序的访问，也可以随机的访问 也就是说既可以从表的第一个表项开始逐个访问表项也可以按照表项的序号（下标）直接的访问 无需为表示结点间的逻辑关系而增加额外的存储空间，存储利用率提高 可以方便的存储表中的任...
数据结构——顺序表详解
最新发布
2301_80681378的博客
07-30 770
数据结构
数据结构之顺序表
m0_51723227的博客
07-30 1886
前言 讲完算法效率,就正式开始我们的数据结构了,而今天博主讲解的内容是顺序表 顺序表 何为顺序表?即一个数组,在逻辑结构和物理结构上,它都是连续的,这里有个概念:逻辑与物理结构. 逻辑结构: 人为所想出来的,实际并不存在. 物理结构: 实际存在,可以观察得到的 怎么理解这两个概念呢?举个例子,假设有 甲乙丙丁戊 五个人. 如果挨着顺序站成一排,五个人依次报数,会报1 2 3 4 5. 逻辑上来讲,他们五个人是连续的,因为依次报数1 2 3 4 5 物理上来讲,他们五个人是连续的,因
java顺序表有哪些_Java——顺序表
weixin_39854951的博客
02-28 315
顺序表顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。顺序表API设计类名SequenceList构造方法SequenceList(int capacity)：创建容量为capacity的Se...
顺序表详解
Yzl17841857589的博客
03-27 797
检查完后就可以开始移动了，和头插差不多，我们创建一个变量 end 记录最后一个的下标（psl->size-1），并通过它来指向要移动的数据。移动完后，x 的位置就腾出来了，再把 x 插入进去，最后再 size++，就完成了。思路：首先创建一个 end 变量用来指向要移动的数据，因为指向的是数据的下标，所以是 size 要减 1。这里有可能会出现如果内存中一个元素都没有了，size有可能减到-1的位置上，这便是越界了，但size是我们用来统计元素数量的，不可能小于0的，所以这里我们需要断言一下。
C#数据结构之顺序表(SeqList)实例详解
09-03
顺序表是一种常见的线性数据结构，它在计算机科学中扮演着重要角色。在C#中，顺序表通常通过数组来实现，因为数组在内存中是连续分配的，这使得我们可以快速地访问任意位置的元素，实现所谓的“随机存取”。 顺序表...
C++数据结构顺序表删除操作
08-26
根据给定的信息，本文将详细解释C++中顺序表数据结构的删除操作。顺序表是一种基本的数据结构，它通过连续的内存空间来存储元素。在本篇内容中，我们将探讨如何实现顺序表中的删除功能，并深入理解其背后的逻辑与...
详解（数据结构C语言版）顺序表
10-02
顺序表演示程序
数据结构 ---- 顺序表
goodness_for_me的博客
03-19 394
经过一年的奋斗，作为软件工程的考生，依然参加完了考研初试，在准备复试的这段时间里，我很想把自己这段时间所学的知识整理出来，方便分享与记录，这一个篇章，我将专门介绍数据结构数据结构是计算机科学中的一个重要概念，指的是组织和存储数据的方式。简单来说，它是一种数据的组织方式，可以帮助程序员更高效地存储和处理数据。不同的数据结构适用于不同的应用场景，例如栈、队列、链表、树、图等。数据结构的设计旨在优化时间和空间复杂度，使得程序的执行效率更高。线性结构和非线性结构。
【数据结构】顺序表
m0_56138343的博客
07-27 189
顺序表是非常简单的一种数据结构，其是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储在数组上完成数据的增删查改。顺序表的结构就是连续存储，牵一发动全身，尤其是插入元素的时候，动一个元素就要将其相邻元素移位，这个过程不难，根据代码阅读一遍基本就可以掌握了，下期见，salute！
数据结构--顺序表
weixin_47230102的博客
04-06 388
数据结构--顺序表1. 什么是顺序表? 1. 什么是顺序表? 顺序表是数据结构中, 耿广义的概念 数组是 Java 语法中, 更具体的概念 数组是实现顺序表的一种典型方式 Java 实现顺序表的时候, 有一个专门的类 ArrayList (针对普通的数组进行封装) List: 线性表 ArrayList: 顺序表 Collection: 元素集合 一个线性表要提供的典型操作(增删改查), 就可以直接参考 List 接口里面的方法 ...
数据结构1--顺序表
weixin_43807876的博客
03-26 225
1.数据结构（DS）是什么？ 数据结构是数据之间的组织架构，数据结构的表现形式：顺序表seqlist、链表list、树tree、图graph、排序sort、搜索search;最终目标是为搜索服务，快速准确的查找想要的数据。 2.如何衡量一个算法的好坏？ 时间复杂度和空间复杂度、 3.数据结构的分类 （1）顺序结构（线性结构也叫线性表） 顺序表 链表 队列 栈 （2）非线性结构（关联结构） 树、图 （3）排序 （4）搜索 4.线性结构特点：除了第一个元素和最后一个元素之外，其与元素必须.
顺序表（数据结构）
Josvin
03-22 618
顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 1、静态顺序表：使用定长数组存储。 2、动态顺序表：使用动态开辟的数组存储。 注意事项： 1、静态顺序表适用于确定知道需要存多少数据的场景. 2、静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用 import java.util.Arra...
【数据结构】详解顺序表
weixin_60371270的博客
10-05 3039
本文主要讲述了线性表之顺序表的概念和分类以及接口实现。
顺序表的详解
m0_57330725的博客
11-22 4206
线性表是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串.... 即顺序表为线性表的一种， 顺序表是一种物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数据上完成数据的增删查改。 顺序表一般分为 1.静态顺序表：使用定长数组存储元素 #defined N 7 typedef int SLDataType typedef struct SeqList { SLDataType* dat
评论 50
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

#小多子

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

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

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

打赏作者

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

抵扣说明：

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

余额充值