基础数据结构之顺序表

最新推荐文章于 2024-05-28 16:13:50 发布
最新推荐文章于 2024-05-28 16:13:50 发布
阅读量200 收藏 1
点赞数
分类专栏： 基础数据结构 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55703811/article/details/127273800
版权

文章目录

一、 数据结构的基本概念

1.以下基本概念截图来自大话数据结构

在这里插入图片描述
在这里插入图片描述

数据项是数据不可分割的最小数据单位
在这里插入图片描述

2.关于逻辑结构和物理结构

逻辑结构：数据与数据关系的抽象关系，与物理地址无关
物理结构（存储结构）：数据与数据之间，它在存储器中的存放方式
逻辑结构的分类：集合、线性、树形结构、图形结构、
物理结构的分类：顺序存储结构、链式存储结构

3.时间复杂度、空间复杂度

时间复杂度：算法中基本操作执行次数和问题规模n之间的关系,一般记为O(f(n))

例题：

//在计算时间复杂度的时候，记住 只要最高项，不要系数
//1    O(n)
for(int i=1; i<=n; i++)
{
	tmp += arr[i];
}

//2.  O(n^2)
for(int i=1; i<=n; i++)
{
	for(int j=1; j<=n; j++)
	{
		arr[i][j] = 1;//基本操作语句
	}
}

//3  O(1)
{
	++x;
	s=0;
}

//4  O(n)
for(int i=1; i<=n; i++) 
{
	++x;
	s+=x;
}

//5  O(n^2)
for(int i=2; i<=n; i++)
{
	for(int j=2; j<=i-1; ++j)
	{
		++x;
		arr[i][j] = x;//基本执行语句
	}
}

空间复杂度：算法中需要额外辅助空间和问题规模n之间的关系，一般记为O(f(n))
例题：（递归）

//递归中开辟的空间不会随着函数调用而消失
//递归里面的空间复杂度 O（n）
int Fun(int n)  //调用了n次函数，开辟了n次空间
{
	if(n<=1)
		return n;
	else
		return Fun(n-1)+1;
}

4.关于线性表的概念

线性表：有且只有一个开始结点，有且只有一个结束结点，并且除了开始结点外，其余结点都有直接前驱，并且除了结束结点外，其余结点都有直接后继，表示为：{a1,a2,a3,…an-1,an}
简而言之，逻辑关系是一对一的，例如：线性表，栈和队列，字符串，数组…

线性表按照其存储方式有两种
顺序表：数据结点间，物理相邻，逻辑也相邻
链表：数据结点间，逻辑相邻，物理不一定相邻

二、顺序表

将逻辑上相邻的数据元素，存储在物理上也相邻的存储单元中

1.用代码的方式实现顺序表

.h头文件定义结构体以及函数

#pragma once

#define LISTINCREMENT 100  //初始大小
#define LIST_INIT_SIZE 10   //不需要

//可扩容顺序表结构体设计

typedef int ELEM_TYPE;
typedef struct Sqlist {

	ELEM_TYPE* elem; //存储空间基址（用来接受malloc返回在堆上申请的连续空间块开辟地址）
	int length;  //当前有效长度
	int listsize ;  //当前总空间大小（以格子数为单位）

}Sqlist,*PSqlist;

//关于数据结构的操作，无外乎就是增删改查

//初始化
void Init_Sqlist(struct Sqlist* sq);

//头插
bool Insert_head(struct Sqlist* sq, ELEM_TYPE val);

//尾插
bool Insert_tail(struct Sqlist* sq, ELEM_TYPE val);

//换位置插
bool Insert_pos(struct Sqlist* sq, int pos, ELEM_TYPE val);

//头删
bool Del_head(struct Sqlist* sq);

//尾删
bool Del_tail(struct Sqlist* sq);

//按位置删
bool Del_pos(struct Sqlist* sq, int pos);

//按值删（找出这个值在顺序表中第一次出现的位置，然后删除）
bool Del_val(struct Sqlist* sq, ELEM_TYPE val);

//判空
bool Isempty(struct Sqlist* sq);

//判满
bool Isfull(struct Sqlist* sq);

//扩容函数
void Inc(struct Sqlist* sq);

//查找（找这个值在顺序表中，第一次出现的位置）
int Search(struct Sqlist* sq, ELEM_TYPE val);

//清空
void Clear(struct Sqlist* sq);

//销毁（将数据空间都释放掉）
void Destory(struct Sqlist* sq);

//打印
void Show(struct Sqlist* sq);

.cpp文件里面实现函数

#include<stdio.h>
#include"Sqlist.h"
#include<stdlib.h>
#include <cassert>

//初始化
void Init_Sqlist(struct Sqlist* sq) {
	sq->elem = (ELEM_TYPE*)malloc(LISTINCREMENT * sizeof(int));
	assert(sq->elem != NULL);
	sq->length = 0;
	sq->listsize = LISTINCREMENT;
}

//头插
bool Insert_head(struct Sqlist* sq, ELEM_TYPE val) {
	assert(sq != NULL);
	if (Isfull(sq)) {
		Inc(sq);
	 }
	else {
		for (int i = sq->length - 1; i >=0; i--) {
			sq->elem[i + 1] = sq->elem[i];
		}
		sq->elem[0] = val;
		sq->length++;
	}
	return true;
}

//尾插
bool Insert_tail(struct Sqlist* sq, ELEM_TYPE val){
	if (Isfull(sq)) {
		Inc(sq);
	}
	else {
		sq->elem[sq->length] = val;
		sq->length++;
	}
	return true;

}

//按位置插
bool Insert_pos(struct Sqlist* sq, int pos, ELEM_TYPE val) {
	if (Isfull(sq)) {
		Inc(sq);
	}
	else {
		for (int i = sq->length - 1; i >= pos; i--) {
			sq->elem[i+1] = sq->elem[i];
		}
		sq->elem[pos] = val;
		sq->length++;
	}
	return true;
}

//头删
bool Del_head(struct Sqlist* sq) {
	assert(sq != NULL);
	if (Isempty(sq)) {
		return false;
	}
	else {
		for (int i = 0; i < sq->length - 1; i++) {
			sq->elem[i] = sq->elem[i + 1];
		}
		sq->length--;
	}
	return true;
}

//尾删
bool Del_tail(struct Sqlist* sq) {
	
	//1.安全性处理（判断sq指针不指向空）
	assert(sq != NULL);
	
	//2.判空（判断sq指向的是否是一个空的顺序表）
	assert(sq->elem != NULL);
	
	//3.删除
	if (Isempty(sq)) {
		return false;
	}
	else {
		sq->length--;
	}
	return true;
}

//按位置删
bool Del_pos(struct Sqlist* sq, int pos) {

	//1.安全性处理（判断sq指针不指向空）
	assert(sq != NULL);

	//2.判空（判断sq指向的是否是一个空的顺序表）
	assert(sq->elem != NULL);

	//3.pos的合法性,pos默认为0时，为头删
	assert(pos >= 0 && pos < sq->length);

	if (Isempty(sq)) {
		return false;
	}
	else {
		for (int i = pos; i < sq->length - 1; i++) {
			sq->elem[i] = sq->elem[i + 1];
		}
		sq->length--;
	}
	return true;
}

//按值删（找出这个值在顺序表中第一次出现的位置，然后删除）
bool Del_val(struct Sqlist* sq, ELEM_TYPE val) {
	
	assert(sq != NULL);

	//直接调用其它函数
	int temp = Search(sq, val);
	if (temp == -1) {
		return false;
	}
	else {
		return Del_pos(sq, temp);
	}

}

//判空
bool Isempty(struct Sqlist* sq) {
	assert(sq != NULL);
	if (sq->length == 0) {
		return true;
	}
	return false;
}

//判满
bool Isfull(struct Sqlist* sq) {
	assert(sq != NULL);
	if (sq->length == sq->listsize) {
		return true;
	}
	return false;
}

//扩容函数  按2倍扩容
void Inc(struct Sqlist* sq) {

	sq->elem=(ELEM_TYPE*)realloc(sq->elem,(sq->listsize * sizeof(int))*2);
	assert(sq->elem != NULL);
	sq->listsize *= 2;
}

//查找（找这个值在顺序表中，第一次出现的位置）
int Search(struct Sqlist* sq, ELEM_TYPE val) {
	for (int i = 0; i < sq->length - 1; i++) {
		if (sq->elem[i] == val) {
			return i;
		}
	}
	return -1;
}

//清空
void Clear(struct Sqlist* sq) {
	assert(sq != NULL);
	sq->length = 0;
}

//销毁（将数据空间都释放掉）
void Destory(struct Sqlist* sq) {
	free(sq->elem);
	sq->length = sq->listsize = 0;
}

//打印
void Show(struct Sqlist* sq) {
	for (int i = 0; i < sq->length; i++) {
		printf("%d", sq->elem[i]);
	}
	printf("\n");
}

.cpp在main函数里面测试代码

#include<stdio.h>
#include"Sqlist.h"
#include<stdlib.h>
#include <cassert>

int main() {
	struct Sqlist head;
	Init_Sqlist(&head);

	for (int i = 0; i < 100; i++) {
		Insert_pos(&head, i, i + 1);
	}
	Show(&head);

	return 0;
}

2.总结

顺序表的特点：

  1. 顺序表的操作需要挪动元素，插入的话，需要向后挪动，删除的话，需要向前覆盖，时间复杂度为O(n)，效率不高
    但是，如果在尾部操作，则不需要挪动元素，效率极高，为O(1)
  2. 顺序表的使用场景：
    适合的场景：
    2.1支持直接访问
    2.2插入和删除操作，主要集中在尾部
    不适合的场景：
    在头部中间位置，插入和删除较多，频繁的扩容，扩容代价高
淡蓝色的经典
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构-顺序表.zip
11-03
压缩包中共有两个文件，一个是顺序表的执行代码cpp文件，一个是顺序表的word文件，顺序表的word文件中写有代码所拥有的功能以及各功能的...不过数据结构就是要会C语言基础才开始学的，祝愿看了我资源的各位前程似锦呀！
C语言 数据结构 顺序表的操作.doc
04-08
（1）根据下列程序环境的设置，完成顺序表的初始化函数List ListInit(int size)的编写。typedef int ListItem; /* 表元素类型 int */ （2）在第（1）题的基础上，void ListInsert(int k,ListItem x,List L)，实现在...
【数据结构】顺序表
East-sunrise的博客
08-15 4189
顺序表带你走进数据结构世界🎈
数据结构之顺序表（C语言）
weixin_50803498的博客
10-14 2214
线性表、顺序表、线性表存储结构、顺序表初始化、顺序表数据插入、顺序表数据删除、按位插入、按位删除、顺序表的使用场景、适合场景、不适合场景
数据结构初阶——顺序表
m0_64607843的博客
04-29 1万+
博客写到这里，关于C语言的相关内容就告一段落了，从这篇开始，跟我一起进入一个全新的领域吧。把顺序表的代码放到了结尾。击鼓进军数据结构！！！
数据结构 - 顺序表
qq_43629857的博客
05-30 5367
数据结构 - 顺序表基本实现思想
数据结构——顺序表的基本操作
qq_43346784的博客
06-16 6253
顺序表（详细）
数据结构——顺序表的合并
qq_45966201的博客
02-02 1万+
数据结构——顺序表的合并 具体要求：写一个函数，其函数的功能是将非递增顺序表LA和LB合并到非递增顺序表LC中 数据结构—顺序表的操作之合并顺序表 一、顺序表的结构 首先要定义的是顺序表的结构体，只有先定义了顺序表的结构体类型，才可以继续进行下一步操作 #define maxsize 100 typedef struct { int elem[maxsize];//线性表元素 int last;//线性表长度 }SeqList; 二、顺序表的操作 1.生成顺序表 在有了顺序表的结构之后，
数据结构：顺序表的基本操作
热门推荐
Keep Fighting All The Time
05-03 10万+
线性表的顺序存储 顺序表的线性存储示意图 C语言定义线性表的顺序存储结构 线性表的顺序存储        线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中，即：通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。采用顺序存储结构存储的线性表通常简称为顺序表。        顺序存
Java——数据结构之顺序表
rain67的博客
04-26 5913
Java——数据结构之顺序表   在之前的学习中，我们主要了解了很多 Java 的 基本语法，但是 在之后的 Java学习中，了解 基础 数据结构的知识 非常重要，数据结构的思想 可以帮助我们更加清晰 明白的了解 Java 的解题思路等等。   今天我们就来开始学习 实现一个 Java 基础的 顺序表。 1.顺序表的简单了解   顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。   顺序表一般可以分为：   静态顺序表：使用
数据结构-顺序表
2302_79539362的博客
11-27 2362
数据结构-顺序表
数据结构之顺序表的增删查改
2301_79551553的博客
01-21 2465
假如我们每次扩2个或3个，那很容易就会不够，扩容很频繁，导致性能消耗，如果一次扩1000个，2000个又很容易空间浪费，但如果我们以倍数扩容，随着空间越来越大每次增加的空间也会越来越大，这样扩容就不会很频繁，浪费空间也不会很多，我们通常是采用2倍扩容或1.5倍扩容，至于为什么是这俩数字就涉及到数学原理了，我能力有限，无法作答。ok，至此，我们知道了什么是顺序表，顺序表的增删查改四种功能我们也都实现了，可以说是迈出了相当大的一步，下一次我们将会在此基础上实现通讯录，但是在物理结构上并不⼀定是连续的，
数据结构上机_顺序表基本操作_数据结构基础_
09-29
实现顺序表的初始化，输出顺序表中各元素的值，在顺序表中插入数据元素，删除数据元素，求顺序表的长度，顺序表的逆置，顺序表的按值从小到大排序，合并有序的两个顺序表等操作。
数据结构学习--线性表及其应用--顺序表
06-25
在众多数据结构当中，线性表是最简单、也是最...本实验相对比较简单，通过本实验，对顺序表基本操作及 其组合应用的演练，加深对线性表顺序存储方法及其基本操作的理解，为以后进一步学习更 复杂的数据结构打下基础。
数据结构 顺序表操作
06-20
1、建立含有若干个元素的顺序表； 2、对已建立的顺序表实现插入、删除、查找、逆置等操作。
浙江大学数据结构MOOC-课后习题-第十讲-排序4 统计工龄
最新发布
chan1ee的博客
05-28 222
题目汇总。
二叉树顺序结构实现【堆的实现】【详细图解】
LiU11e的博客
05-28 677
二叉树（堆）顺序结构的实现，并带有堆排序拓展
二叉树的链式结构（二叉树）与顺序结构（堆）---数据结构
Zjxbxv11的博客
05-28 457
下面是树的示意图：注意：在树形结构中，子树之间不能有交集，否则就不是树形结构！！！例如下面的这几棵树就不是树形结构：1->结点的度：一个结点所含的子树的个数称为该结点的度； 如上图：A的有6颗子树，故A的度为6。2->叶结点或终端结点：度为0的结点称为叶结点； 如上图：B、C、H、I、P、Q、....等结点都为叶结点。3->非终端结点或分支结点：度不为0的结点； 如上图：A、D、E、F、G...等结点为分支结点。4->双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的
希尔排序法
qq_24946843的博客
05-28 221
gap=2，从a[2]开始，a[2]和a[0]进行插入排序，a[3]和a[1]插入排序，a[4]和a[2]、a[0]插入排序......上面gap=2，即5，14，18，27，68为一组；13，20，36，39，51为一组。可以发现左边都是较小的数据，右边都是较大的数据，更方便把分成的每一个组进行插入排序。为什么 要采取上面分组的方法呢（gap），换一种方法也可以吗？
南京邮电大学数据结构顺序表的实现
11-22
南京邮电大学数据结构课程中，顺序表是一个非常基础的数据结构，其实现主要包括以下几个方面： 1. 顺序表的定义：顺序表是一种线性表，其特点是元素在物理空间上连续存储，逻辑上也是连续的。顺序表的定义可以使用数组来实现。 2. 顺序表的基本操作：包括初始化、插入、删除、查找、修改等操作。其中，插入和删除操作需要考虑到元素的移动问题。 3. 顺序表的组合应用：顺序表可以用来实现其他数据结构，例如栈、队列等。 下面是一个简单的Python代码示例，演示了如何实现顺序表的基本操作： ```python class SeqList: def __init__(self, maxsize=None): self.maxsize = maxsize self.array = [None] * self.maxsize self.length = 0 def __len__(self): return self.length def __getitem__(self, index): if index < self.length: return self.array[index] else: raise IndexError('Index out of range') def __setitem__(self, index, value): if index < self.length: self.array[index] = value else: raise IndexError('Index out of range') def insert(self, index, value): if self.length >= self.maxsize: raise Exception('SeqList is full') if index < 0 or index > self.length: raise IndexError('Index out of range') for i in range(self.length, index, -1): self.array[i] = self.array[i-1] self.array[index] = value self.length += 1 def delete(self, index): if index < 0 or index >= self.length: raise IndexError('Index out of range') for i in range(index, self.length-1): self.array[i] = self.array[i+1] self.length -= 1 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

淡蓝色的经典

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

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

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

打赏作者

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

抵扣说明：

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

余额充值