数据结构_顺序表

已于 2022-08-07 18:07:57 修改
阅读量454 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 算法 c语言
于 2022-08-07 15:47:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43853178/article/details/126198446
版权

从这篇博客开始，我将整理数据结构中几个经典的结构，顺序表、链表、栈、队列、二叉树等。每个结构的相关内容写一篇博客，最后再用一篇博客总结这几个结构的异同点，并且记录一些自己实现这些结构时候的要点。首先从顺序表开始。

目录

一些概念

线性表

定义： 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…

结构： 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

特点： 线性结构的特点是除了第一个和最后一个数据元素外，每个数据元素只有一个前驱数据元素和最后一个后继数据元素。线性表是一种可以在任意位置进行插入和删除数据元素操作的，由n个相同类型数据元素组成的线性结构。

顺序表

顺序表的介绍

线性表有两种存储结构：顺序存储结构和链式存储结构。在C语言中实现顺序表的方法是使用数组。数组把线性表的数据元素存储在一块连续地址空间的内存单元中，这样线性表在逻辑上相邻的数据元素在物理存储地址上也是相邻的。
顺序表有静态的和动态的。静态的就是指在创建顺序表的时候就把数组的大小设置好，后面无法再增加；动态的就是调用函数实现内存的动态申请。本篇博客中提到的顺序表是动态的。

顺序表的实现

结构体的定义

typedef int SLDataType;

typedef struct SeqList
{
	SLDataType * a;    // 指针
	int size;          // 顺序里面元素个数
	int capacity;      // 顺序表容量
}SeqList;

首先，为了后期方便，我们使用typedef定义顺序表内的数据类型，具体的原因就是：我们后面会对顺序表进行增、删、改、查，在进行操作的时候要用到数据的类型，如果我们在前面定义了SLDataType的话，后面写数据类型直接用SLDataType就行，假如我们要在顺序表中插入char类型的数据，那么只需要在头文件中将SLDataType的定义修改成char就行，否则需要挨个函数修改数据类型。
接下来是顺序表结构体的定义：a是一个指针，指向顺序表中数据存储的位置的地址起点；size是用来记录顺序表中实际上存储的元素个数；capacity是顺序表能够存储的元素个数，一旦capacity等于size，就需要扩容。

接口函数的实现
（1）顺序表初始化

void SeqListInit(SeqList* pq)
{
	assert(pq);

	pq->a = NULL;
	pq->size = pq->capacity = 0;
}

这里函数参数要使用SeqList*类型，相当于传入了一个结构体变量的地址，有了地址我们就能找到这个结构体变量然后修改它的的成员变量（a，size，capacity），如果只传入结构体的话，其实只传递了结构体变量的一份拷贝，不能真正修改成员变量，也就是说不能成功初始化。

（2）顺序表的销毁

void SeqListDestroy(SeqList* pq)
{
	assert(pq);

	free(pq->a);
	pq->a = NULL;
	pq->capacity = pq->size = 0;

}

（3）顺序表的打印

void SeqListPrint(SeqList* pq)
{
	assert(pq);

	for (int i = 0; i < pq->size; i++)
	{
		printf("%d ", pq->a[i]);
	}
	printf("\n");

}

（4）扩容函数
在往顺序表中插入元素的时候会有两种情况：

  • a.有可能我们往一个空表中插入
  • b.也有可能顺序表已经满了。

因此我们需要判断是否对顺序表扩容。可以预见，不管是尾插还是头插都需要判断是否要扩容，所以我们直接写一个判断扩容的函数，方便后面调用。

void CapacityCheck(SeqList* pq)
{
	assert(pq);

	// 判断是否存满
	if (pq->size == pq->capacity)
	{
		// 还需要判断一下是否是空的，因为后面是要在capacity的基础上扩容（capacity的2倍，如果capacity=0，那么会出问题）
		int newcapacity = pq->capacity = 0 ? 4 : pq->capacity * 2;

		SLDataType* tmp = (SLDataType*)realloc(pq->a, sizeof(SLDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			// 有可能当前内存不够扩容，因此在另一块内存上开辟，所以起始地址会变换
			pq->a = tmp;
			pq->capacity = newcapacity;
		}
	}
}

我们扩容的时候选择的是realloc函数，因为顺序表是存在一块连续的内存上，可能当前内存不足以扩容到我们想要的大小，所以需要重新找一块内存。

（5）从尾部插入一个元素

void SeqListPushBack(SeqList* pq, SLDataType x)
{
	assert(pq);

	// 首先要检查顺序表容量是否充足，如果容量不充足需要扩容
	CapacityCheck(pq);

	// 尾插
	pq->a[pq->size] = x;
	pq->size++;
}

（6）从头部插入一个元素

void SeqListPushFront(SeqList* pq, SLDataType x)
{
	assert(pq);

	// 首先检查顺序表容量是否充足，如果容量不充足需要扩容
	CapacityCheck(pq);

	// 头插
	for (int i = pq->size - 1; i >= 0; i--)
	{
		pq->a[i + 1] = pq->a[i];
	}

	pq->a[0] = x;
	pq->size++;
}

头插的时候需要将顺序表中的元素，从最后一个开始往后挪动，把第一个位置空下来然后将元素插入进去。
（7）尾删和头删

void SeqListPopBack(SeqList* pq)
{
	assert(pq);
	assert(pq->size > 0); // 顺序表中没有数据就不能尾删
	
	pq->size--;
}

void SeqListPopFront(SeqList* pq)
{
	assert(pq);
	assert(pq->size > 0); // 顺序表中没有数据就不能头删

	for (int i = 0; i < pq->size - 1; i++)
	{
		pq->a[i] = pq->a[i + 1];
	}

	pq->size--;
	
}

尾删的时候，我们只需要将最后一个元素的位置当作空就行；头删的时候，需要将第二个元素到最后一个元素往前挪动。
（8）查找元素

int SeqListFind(SeqList* pq, SLDataType x)
{
	assert(pq);

	for (int i = 0; i < pq->size; i++)
	{
		if (pq->a[i] == x)
			return i;
	}

	return -1;
}

（9）在任意位置插入元素

void SeqListInsert(SeqList* pq, int pos, SLDataType x)
{
	assert(pq);
	assert(pos >= 0 && pos <= pq->size); // 需要确保要插入的位置在[0,pq->size]范围内，pq->size位置插入相当于尾插

	for (int i = pq->size - 1; i >= pos; i--)
	{
		pq->a[i + 1] = pq->a[i];
	}

	pq->a[pos] = x;
	pq->size++;
}

插入时，需要确保要插入的位置在[0,pq->size]范围内，在pq->size位置插入相当于尾插。
（10）删除任意位置的元素

void SeqListErase(SeqList* pq, int pos)
{
	assert(pq);
	assert(pos >= 0 && pos <= pq->size - 1); // 需要保证要删除的元素位置是已有元素的位置

	for (int i = pos; i < pq->size - 1; i++)
	{
		pq->a[i] = pq->a[i + 1];
	}
	
	pq->size--;

}

删除时，需要保证要删除的元素位置是已有元素的位置（[0,pq->size-1]）。
（11）修改任意位置元素

void SeqListModify(SeqList* pq, int pos, SLDataType x)
{
	assert(pq);
	assert(pos >= 0 && pos <= pq->size - 1); // 需要保证要修改的元素位置是已有元素的位置

	pq->a[pos] = x;
}

完整代码及测试程序

一共三个程序：

  1. SeqList.h：头文件、结构体、函数声明
  2. SeqList.c：接口函数的实现
  3. Test_SeqList.c：对顺序表进行操作
#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

typedef int SLDataType;

typedef struct SeqList
{
	SLDataType * a;
	int size;          // 顺序里面元素个数
	int capacity;      // 顺序表容量
}SeqList;

// 内存中管理数据的结构增删查改的接口

// 初始、销毁、打印顺序表
void SeqListInit(SeqList* pq); // 初始化一个空的顺序表
void SeqListDestroy(SeqList* pq);
void SeqListPrint(SeqList* pq);

// 头插尾插，头删尾删
void SeqListPushBack(SeqList* pq, SLDataType x);
void SeqListPushFront(SeqList* pq, SLDataType x);
void SeqListPopBack(SeqList* pq);
void SeqListPopFront(SeqList* pq);

// 查找
int SeqListFind(SeqList* pq, SLDataType x);
// 插入
void SeqListInsert(SeqList* pq, int pos, SLDataType x);
// 删除
void SeqListErase(SeqList* pq, int pos);
// 修改
void SeqListModify(SeqList* pq, int pos, SLDataType x);

#include "SeqList.h"

void SeqListInit(SeqList* pq)
{
	assert(pq);

	pq->a = NULL;
	pq->size = pq->capacity = 0;
}

void SeqListDestroy(SeqList* pq)
{
	assert(pq);

	free(pq->a);
	pq->a = NULL;
	pq->capacity = pq->size = 0;

}

void SeqListPrint(SeqList* pq)
{
	assert(pq);

	for (int i = 0; i < pq->size; i++)
	{
		printf("%d ", pq->a[i]);
	}
	printf("\n");

}

void CapacityCheck(SeqList* pq)
{
	assert(pq);

	// 判断是否存满
	if (pq->size == pq->capacity)
	{
		// 还需要判断一下是否是空的，因为后面是要在capacity的基础上扩容（capacity的2倍，如果capacity=0，那么会出问题）
		int newcapacity = pq->capacity = 0 ? 4 : pq->capacity * 2;

		SLDataType* tmp = (SLDataType*)realloc(pq->a, sizeof(SLDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			pq->a = tmp;
			pq->capacity = newcapacity;
		}
	}
}

void SeqListPushBack(SeqList* pq, SLDataType x)
{
	assert(pq);

	// 首先要检查顺序表容量是否充足，如果容量不充足需要扩容
	CapacityCheck(pq);

	// 尾插
	pq->a[pq->size] = x;
	pq->size++;
}

void SeqListPushFront(SeqList* pq, SLDataType x)
{
	assert(pq);

	// 首先检查顺序表容量是否充足，如果容量不充足需要扩容
	CapacityCheck(pq);

	// 头插
	for (int i = pq->size - 1; i >= 0; i--)
	{
		pq->a[i + 1] = pq->a[i];
	}

	pq->a[0] = x;
	pq->size++;
}

void SeqListPopBack(SeqList* pq)
{
	assert(pq);
	assert(pq->size > 0); // 顺序表中没有数据就不能尾删
	
	pq->size--;
}

void SeqListPopFront(SeqList* pq)
{
	assert(pq);
	assert(pq->size > 0);

	for (int i = 0; i < pq->size - 1; i++)
	{
		pq->a[i] = pq->a[i + 1];
	}

	pq->size--;
	
}

int SeqListFind(SeqList* pq, SLDataType x)
{
	assert(pq);

	for (int i = 0; i < pq->size; i++)
	{
		if (pq->a[i] == x)
			return i;
	}

	return -1;
}

void SeqListInsert(SeqList* pq, int pos, SLDataType x)
{
	assert(pq);
	assert(pos >= 0 && pos <= pq->size); // 需要确保要插入的位置在[0,pq->size]范围内，pq->size位置插入相当于尾插

	for (int i = pq->size - 1; i >= pos; i--)
	{
		pq->a[i + 1] = pq->a[i];
	}

	pq->a[pos] = x;
	pq->size++;
}

void SeqListErase(SeqList* pq, int pos)
{
	assert(pq);
	assert(pos >= 0 && pos <= pq->size - 1); // 需要保证要删除的元素位置是已有元素的位置

	for (int i = pos; i < pq->size - 1; i++)
	{
		pq->a[i] = pq->a[i + 1];
	}
	
	pq->size--;

}

void SeqListModify(SeqList* pq, int pos, SLDataType x)
{
	assert(pq);
	assert(pos >= 0 && pos <= pq->size - 1); // 需要保证要修改的元素位置是已有元素的位置

	pq->a[pos] = x;
}


#include "SeqList.h"

void Test()
{
	SeqList s;

	SeqListInit(&s);
	printf("初始化成功！\n");


	SeqListPushFront(&s, 1);
	SeqListPushFront(&s, 0);

	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	
	printf("\n头、尾插测试！依次头插1 0 尾插2 3\n");
	SeqListPrint(&s);

	SeqListPopBack(&s);
	SeqListPopFront(&s);

	printf("\n头、尾删测试！头删1次，尾删1次\n");
	SeqListPrint(&s);

	int pos = SeqListFind(&s, 2);
	printf("\n查找 %d 的位置为 %d\n", 2, pos);

	SeqListInsert(&s, 0, 0);
	SeqListInsert(&s, 3, 3);
	SeqListInsert(&s, s.size, 4);

	printf("\n0位置插入0, 3位置插入3,尾插4\n");
	SeqListPrint(&s);

	SeqListErase(&s, 0);
	SeqListErase(&s, s.size-1);
	SeqListErase(&s, 2);

	printf("\n头删，尾删, 删除2位置\n");
	SeqListPrint(&s);

	SeqListModify(&s, 0, 5);
	printf("\n0位置修改成5\n");
	SeqListPrint(&s);

}

int main()
{
	Test();

	return 0;
}
从头开始的小白
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——顺序表（静态）
z_freedom的博客
03-13 1446
本文是对顺序表的理解 （这只是在下的粗浅理解，不足的地方还请谅解，欢迎留言提出，后期理解深入后会加以改进） 首先了解一下什么是顺序表： 顺序表：用一段地址连续的存储单元依次存储数据元素的线性结构   而地址连续的空间，一般情况下采用数组，但数组有静态数组和动态数组， 所以顺 序表分为：静态顺序表和动态顺序表 静态顺序表： 定义一个结构体，里面包括该静态顺序表的大小，也就是容量，以
【数据结构】顺序表
无意呢的博客
01-17 5755
顺序表示一种最为简单的线性结构，可以分为两种，一种是静态顺序表，一种是动态顺序表 1）静态顺序表 所谓静态顺序表是指一旦定义了该表，其大小始终固定不变，函数调用时，静态顺序表在函数栈上开辟空间，我们熟悉的数组就是一种静态顺序表 e.g #definde MAXSIZE 100 ElemType Sqlist[MAXSIZE]; int len; 2）动态顺序表 所谓动态顺序表...
数据结构：静态顺序表
LSFAN0213的博客
07-28 1144
什么是顺序表？ 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 （源于百度百科） ...
数据结构之静态顺序表
skrskr66的博客
11-11 684
title: 数据结构之静态顺序表 date: 2018-11-09 14:21:51 tags: C-数据结构 静态顺序表属于数据结构开始的一种基本结构 首先我们要知道数据结构的概念 数据结构 数据的组织关系 算法 为了达到特定的目的的一系列过程。在这个过程中又分为两种角度 1） 逻辑角度：线性结构，树形结构，图形结构 2） 存储角度：顺序存储，链式存储 在线性结构中顺序存储的方式，在本...
顺序表静态结构结构
To be a better man
08-10 816
//顺序映像的C语言描述 #define LIST_SIZE 100 //存储 //线性表静态分配顺序存储结构 typedef struct{ ElemType elem[LIST_SIZE]; int length; //当前长度 }Sqlist; /* 在线性表的静态分配存储结构中,线性表中的最多元素个数为LIST_SIZE, 元素数量不能随意增加,这是以数组方式描述线性表的缺点 ...
数据结构_顺序表的查找实验报告.pdf
最新发布
05-14
数据结构顺序表的查找实验报告 本实验报告的目的是应用顺序表来实现对数据的查找。顺序表是一种基本的数据结构，它可以用于存储和管理大量的数据。在本实验中，我们将使用 C 语言来实现顺序表的查找功能。 一、...
shujujiegou.rar_c 数据结构_数据结构_栈_链表 实现_顺序表
09-22
在这个"shujujiegou.rar_c 数据结构_数据结构_栈_链表 实现_顺序表"压缩包中，包含了C语言实现的数据结构相关的源代码，主要关注的是顺序表、链表和栈这三种基本数据结构。下面我们将逐一探讨这些数据结构及其基本...
数据结构_顺序表相关函数.cpp
09-20
数据结构_顺序表相关函数.cpp
数据结构上机_顺序表基本操作_数据结构基础_
09-29
在本课题中，我们将深入探讨"数据结构上机_顺序表基本操作_数据结构基础_"这一主题，这涉及到一系列在顺序表上的基本操作，包括初始化、输出、插入、删除、计算长度、逆置、排序以及合并有序顺序表等。 顺序表是一...
顺序表_顺序表_数据结构_
09-29
顺序表是一种基本且重要的数据结构，它在计算机科学和编程领域有着广泛的应用。顺序表的特点是元素在内存中按照线性的顺序存储，就像一个数组，每个元素都有一个对应的索引位置。这种数据结构的实现简单，操作直观，...
静态顺序表和动态顺序表
weixin_34406086的博客
04-10 97
实现一个静态顺序表，首先，要定义一个保存数据的数组，保存在结构体中，用size来存储数组中的元素个数，typedefstructSeqList { DataTypearray[MAX_SIZE]; size_tsize; }SeqList;首先来实现一下静态顺序表的初始化函数，可以借用系统的memset函数来实现，开辟一块空间全部初始化为0，没有存入数据所以size也...
动静态顺序表
weixin_62981548的博客
05-13 595
大家都知道要学好编程，数据结构是十分重要的一门课，而线性表是一种在实际中广泛使用的数据结构，那么线性表是什么呢，线性表是n个具有相同特性（数据类型）的数据元素的有限序列，常见的线性表有：顺序表、链表、栈、队列、字符串…但不要误会的是线性表在逻辑上是线性结构，也就是一条连续的直线，但在物理结构上不一定是连续的，所以线性表在物理上存储时，通常以数组和链式结构形式存储，下面我们就来学习一下线性表中的顺序表吧。
顺序表的静态和动态实现
Maple的博客
03-11 693
静态顺序表：所谓静态顺序表就是把空间的大小给定结构体的定义：typedef struct SeqList { DataType array[MaxSize]; int size; }SeqList; 基本操作的实现：void InitSeqList(SeqList* pSeq) { assert(pSeq); memset(pSeq->array, 0, MaxSiz
数据结构之静态顺序表和动态顺序表
Sock的博客
12-02 1323
@Sock对静态顺序表和动态顺序表的总结 简单概括他们的异同点 相同点:内存空间连续, 数据顺序存储 不同点:它们所占内存空间的位置不同, 静态定义一个顺序表, 顺序表所占的内存空间开辟在内存的静态区, 即所谓的函数栈上, 随着函数调用的结束, 这块内存区域会被系统自动回收; 而动态生成一个顺序表, 顺序表所占的内存空间开辟在内存的动态区, 即所谓的堆内存上, 这块区域不会随着函数调用的结束被...
静态顺序表和动态顺序表 对比
jhcconan614的博客
12-30 1655
静态顺序表的缺陷：静态顺序表显然就是里面的内存是一定的，不能改变的，所以定义的时候可以定义一个宏，然后定义一个数组，这样就可以在数组中存储信息，而且，还可以随时改变数组的大小。typedef int DataType; #define MaxSize 10typedef struct SeqList { DataType array[MaxSize]; size_t size;
2.2顺序表的静态和动态实现
FuckerGod的博客
07-05 202
顺序表的静态和动态实现
数据结构-顺序表的静态存储
tzy134679的博客
11-04 600
线性表是具有相同数据类型(每个数据元素所占空间一样大)的n个数据元素的有限序列（有次序），其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，则其一般表示为L=（ a1 , a2 ,...., ai ,...., an ） 常见的线性结构有：线性表，栈，队列，双队列，数组，串。 下面我们来实现一下静态顺序表的创建、初始化、尾插法 //创建一个SeqList头文件 #pragma once #define MAX_SIZE 100 #include <stdio.h> .
顺序表（理解）
qq_41041036的博客
01-26 284
线性表分为顺序表和链表，顺序表又分为动态表和静态表。 动态表就是空间大小可以被更改的表，静态表则为空间大小不可以变化的表。 静态顺序表怎么定义？ #pragma once typedef struct seqList { //大小确定,一般不要太大，因为静态空间是开在栈空间上的，栈空间相比较而言比较小 int _array[100]; int _size; }seqList; 静态空间空间一般不会很大，因为静态空间是开辟在栈空间上的，栈空间相对而言比较小，而且固定空间的话可能会造成一个非常大的空间
数据结构与算法——顺序表
weixin_46016019的博客
01-04 1831
本文详细介绍顺序表，内附代码讲解和图解，以及顺序表的源码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值