C++数据结构 —— 顺序表

于 2025-03-26 16:30:47 发布
阅读量1.2k 收藏 28
点赞数 50
分类专栏： C++数据结构 文章标签： 数据结构 顺序表 线性表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2401_87692970/article/details/146534183
版权

在这里插入图片描述

在这里插入图片描述

​ 🎁个人主页：工藤新一¹

​ 🔍系列专栏：C++面向对象（类和对象篇）

​ 🌟心中的天空之城，终会照亮我前方的路

​ 🎉欢迎大家点赞👍评论📝收藏⭐文章

文章目录

顺序表

一、线性表

  • 线性表（linear list）是 n 个具有相同特性的数据元素的有限序列，其是一种被广泛使用的数据结构，常见的**线性表：**顺序表、链表、栈、队列、字符串……
    • 逻辑结构上：线性结构，是一条连续的直线（人为 想象出的结构）
    • 物理结构上：在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储

二、顺序表

1.概念与结构

  • 概念：顺序表是用一段用物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。另外，数组是最基础的数据结构，顺序表底层结构就是在数组的基础上进行增删查改

2.顺序表的分类

2.1静态顺序表
  • 在编译阶段，就指定了顺序表的空间大小
    • eg：int arr[10];
    • 静态数组的大小长度是固定的
  • 适用于数据元素固定的情况
C++
    //静态顺序表
    typedef int SLDataType;--->取别名的意义：为了方便后期的对于数组类型的一键修改（Ctrl f）
        
	#define N 7

    typedef struct SeqList--->使用结构体包装数组和整形变量（定义不同类型的变量）
    {
		SLDataType arr[N];--->定长数组
        int size;--->有效数据个数
    }SL;--->SeqList的别名
  • 静态顺序表的缺陷：空间给少了不够用，给多了造成空间上的浪费

在这里插入图片描述

2.2动态顺序表
  • 在堆区动态开辟的数据
    • int arr = new int( );*
    • 动态顺序表底层的数组空间会不断的变化
C++
    //动态顺序表 -- 按需申请
    typedef struct SeqList
    {
        SLDataType* arr;--->维护堆区
        int size;
        int capacity;--->空间容量
    }SL;

在这里插入图片描述

3.动态顺序表的创建

  • .cpp文件中
C++
    #include"Sqlist.h"
	
    //对顺序表进行初始化 - 实现
	void SLInit(SL s) 
	{
		s.arr = NULL;
		s.size = s.capacity = 0;
	}
  • .h文件
C++
    #pragma once
	#include<iostream>

	//定义动态顺序表的结构
	typedef int SLDataType;

	typedef struct SeaList 
	{
		SLDataType* arr;
		int size;//有效元素个数
		int capacity;//空间容量
	}SL;

	//对顺序表进行初始化 - 声明
	void SLInit(SL s);
  • test.cpp
C++
    #include"Sqlist.h"

	void test01(){
	SL s1;
	SLInit(s1);
	}
	int main(){
	test01();
	return 0;
	}
3.1值传递的局限性

当代码运行时，所出现的小问题

在这里插入图片描述

在这里插入图片描述

这里就相当于：
int a;
func(a);--->a未被初始化，就对a进行传值操作

3.2地址传递
  • .cpp
C++
    #include"Sqlist.h"

	void test01(){
		SL s1;

		SLInit(&s1);--->地址传递	
	}

	int main(){test01();return 0;}
  • .h文件
C++
    #pragma once
	#include<iostream>

	typedef int SLDataType;

	typedef struct SeaList 
	{
		SLDataType* arr;
		int size;
		int capacity;
	}SL;

	void SLInit(SL* ps);--->指针接收地址
  • test.cpp文件
C++
	#include"Sqlist.h"
	
	void SLInit(SL* ps)--->指针接收地址
	{
		ps->arr = NULL;
		ps->size = ps->capacity = 0;	
	}

在这里插入图片描述

3.3尾插操作
  • .h文件
C++
    void SLPushBack(SL* ps, SLDataType x);
  • test.cpp文件
C++
	void SLPushBack(SL* ps, SLDataType x)
	{
    //判断空间是否足够 - 拷贝旧数据，释放旧空间
    	if(ps->size == ps->capacity)
        {
            //判断capacity是否未为0，因为 0 乘任何数都是0，会导致扩增失败
            //ps->capacity == 0吗？如果是，newCapacity = 4
			int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
            //强制转换，扩充的对象，增加字节大小
            SLDataType* temp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));
            
            if(temp == NULL) 
            {
				perror("realloc fail!");
                exit(1);
            }
            ps->arr = temp;
            ps->capacity = newCapacity;
        }
    //空间足够的情况下，直接插入
    	ps->arr[ps->size++] = x;
	}
3.3.1调试（Matter）
3.4尾插 + 头插
//将重复的代码封装到单独的函数中，方便以后使用
//判断空间是否足够的函数
void SLCheckCapacity(SL* ps)
{
    //判断空间是否足够 - 拷贝旧数据，释放旧空间
    if (ps->size == ps->capacity)
    {
        //ps->capacity == 0吗？如果是，newCapacity = 4
        int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
        //强制转换，扩充对象，增加字节大小
        SLDataType* temp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));

        if (temp == NULL)
        {
            perror("realloc fail!");
            exit(1);
        }
        ps->arr = temp;
        ps->capacity = newCapacity;
    }
}

//尾插
void SLPushBack(SL* ps, SLDataType x)
{
    assert(ps != NULL);
    //判断空间是否足够
    SLCheckCapacity(ps);
    ps->arr[ps->size++] = x;
}

//头插
void SLPushFront(SL* ps, SLDataType x)
{
    //if (ps == NULL) return;// 温柔

    assert(ps != NULL);//断言：ps不能为NULL
    //判断空间是否足够
    SLCheckCapacity(ps);

    for (int i = ps->size - 1; i >= 0; i--)
    {
        ps->arr[i + 1] = ps->arr[i];
    }
    ps->arr[0] = x;
    ps->size++;
}
3.5头删与尾删
  • .cpp文件
void SLPrint(SL* ps)
{
    for (int i = 0; i < ps->size; i++)
    {
        cout << ps->arr[i] << " ";
    }
    cout << endl;
}

//尾删
void SLPopBack(SL* ps)
{
    //ps != NULL
    //ps->size != 0（表中元素不为0）
    assert(ps && ps->size);
    ps->size--;
}

//头删
void SLPopFront(SL* ps)
{
    assert(ps && ps->size);
    for (int i = 0; i < ps->size - 1; i++)
    {
        ps->arr[i] = ps->arr[i + 1];
    }
    ps->size--;
}
  • test.cpp
void test01()
{
	SL s1;

	SLInit(&s1);

	SLPushBack(&s1, 1);
	SLPushBack(&s1, 2);
	SLPushBack(&s1, 3);
	SLPushBack(&s1, 4);
	SLPushBack(&s1, 5);
	SLPrint(&s1);

	/*
	SLPushFront(&s1, 1);
	SLPushFront(&s1, 2);
	SLPushFront(&s1, 3);
	SLPushFront(&s1, 4);
	SLPushFront(NULL, 1);--->false，断言报错
	*/

	SLPopBack(&s1);
	SLPopBack(&s1);
	SLPrint(&s1);

	SLPopFront(&s1);
	SLPopFront(&s1);
	SLPrint(&s1);
3.6任意位置插入、删除
#include"Sqlist.h"

void SLInit(SL* ps) 
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

void SLPrint(SL* ps)
{
    for (int i = 0; i < ps->size; i++)
    {
        cout << ps->arr[i] << " ";
    }
    cout << endl;
}

//将重复的代码封装到单独的函数中，方便以后使用
//判断空间是否足够的函数
void SLCheckCapacity(SL* ps)
{
    //判断空间是否足够 - 拷贝旧数据，释放旧空间
    if (ps->size == ps->capacity)
    {
        //ps->capacity == 0吗？如果是，newCapacity = 4
        int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
        //强制转换，扩充对象，增加字节大小
        SLDataType* temp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));

        if (temp == NULL)
        {
            perror("realloc fail!");
            exit(1);
        }
        ps->arr = temp;
        ps->capacity = newCapacity;
    }
}

//尾插
void SLPushBack(SL* ps, SLDataType x)
{
    assert(ps != NULL);
    //判断空间是否足够
    SLCheckCapacity(ps);
    ps->arr[ps->size++] = x;
}

//头插
void SLPushFront(SL* ps, SLDataType x)
{
    //if (ps == NULL) return;// 温柔

    assert(ps != NULL);
    //判断空间是否足够
    SLCheckCapacity(ps);

    for (int i = ps->size - 1; i >= 0; i--)
    {
        ps->arr[i + 1] = ps->arr[i];
    }
    ps->arr[0] = x;
    ps->size++;
}

//尾删
void SLPopBack(SL* ps)
{
    //ps != NULL
    //ps->size != 0（表中元素不为0）
    assert(ps && ps->size);
    ps->size--;
}

//头删
void SLPopFront(SL* ps)
{
    assert(ps && ps->size);
    for (int i = 0; i < ps->size - 1; i++)
    {
        ps->arr[i] = ps->arr[i + 1];
    }
    ps->size--;
} 


void SLInsert(SL* ps, int pos, SLDataType x)
{
    assert(ps);
    assert(pos >= 0 && pos <= ps->size);
    SLCheckCapacity(ps);
    for (int i = ps->size - 1; i >= pos; i--)
    {    
        ps->arr[i + 1] = ps->arr[i];
    }
    ps->arr[pos] = x;
    ps->size++;
}

void SLErase(SL* ps, int pos)
{

    for (int i = pos; i < ps->size - 1; i++)
    {
        ps->arr[i] = ps->arr[i + 1];
    }
    ps->size--;
}
3.7代码总实现
  • .h头文件
#pragma once
#include<iostream>
using namespace std;

#include<stdlib.h>//realloc，头文件
#include<cassert>

//定义动态顺序表的结构

typedef int SLDataType;

typedef struct SeqList 
{
	SLDataType* arr;
	int size;//有效元素个数
	int capacity;//空间容量
}SL;

//对顺序表进行初始化
void SLInit(SL* ps);//地址传递，指针接收，ps 相当于 实例化的对象

//输出函数
void SLPrint(SL* ps);

//销毁 - 顺序表的销毁
void SLDestory(SL* ps);

//尾插 - 向顺序表中插入元素 x(插入元素的数据类型，要与数组一致) 
void SLPushBack(SL* ps, SLDataType x);

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

//查数组容量
void SLCheckCapacity(SL* ps);

//尾删
void SLPopBack(SL* ps);

//头删
void SLPopFront(SL* ps);

//在之前插入
void SLInsert(SL* ps, int pos, SLDataType x);

//删除指定位置元素
void SLErase(SL* ps, int pos);

//查找元素
int SLFind(SL* ps, SLDataType x);
  • .cpp文件
#include"Sqlist.h"

void SLInit(SL* ps) 
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

void SLPrint(SL* ps)
{
    for (int i = 0; i < ps->size; i++)
    {
        cout << ps->arr[i] << " ";
    }
    cout << endl;
}

//将重复的代码封装到单独的函数中，方便以后使用
//判断空间是否足够的函数
void SLCheckCapacity(SL* ps)
{
    //判断空间是否足够 - 拷贝旧数据，释放旧空间
    if (ps->size == ps->capacity)
    {
        //ps->capacity == 0吗？如果是，newCapacity = 4
        int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
        //强制转换，扩充对象，增加字节大小
        SLDataType* temp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));

        if (temp == NULL)
        {
            perror("realloc fail!");
            exit(1);
        }
        ps->arr = temp;
        ps->capacity = newCapacity;
    }
}

//尾插
void SLPushBack(SL* ps, SLDataType x)
{
    assert(ps != NULL);
    //判断空间是否足够
    SLCheckCapacity(ps);
    ps->arr[ps->size++] = x;
}

//头插
void SLPushFront(SL* ps, SLDataType x)
{
    //if (ps == NULL) return;// 温柔

    assert(ps != NULL);
    //判断空间是否足够
    SLCheckCapacity(ps);

    for (int i = ps->size - 1; i >= 0; i--)
    {
        ps->arr[i + 1] = ps->arr[i];
    }
    ps->arr[0] = x;
    ps->size++;
}

//尾删
void SLPopBack(SL* ps)
{
    //ps != NULL
    //ps->size != 0（表中元素不为0）
    assert(ps && ps->size);
    ps->size--;
}

//头删
void SLPopFront(SL* ps)
{
    assert(ps && ps->size);
    for (int i = 0; i < ps->size - 1; i++)
    {
        ps->arr[i] = ps->arr[i + 1];
    }
    ps->size--;
} 


void SLInsert(SL* ps, int pos, SLDataType x)
{
    assert(ps);
    assert(pos >= 0 && pos <= ps->size);
    SLCheckCapacity(ps);
    for (int i = ps->size - 1; i >= pos; i--)
    {    
        ps->arr[i + 1] = ps->arr[i];
    }
    ps->arr[pos] = x;
    ps->size++;
}

void SLErase(SL* ps, int pos)
{
    assert(ps);
    assert(pos >= 0 && pos < ps->size);
    for (int i = pos; i < ps->size - 1; i++)
    {
        ps->arr[i] = ps->arr[i + 1];
    }
    ps->size--;
}

int SLFind(SL* ps, SLDataType x)
{
    assert(ps);
    for (int i = 0; i < ps->size; i++)
    {
        if (ps->arr[i] == x) return i;
    }

    //未找到
    return -1;
}

void SLDestory(SL* ps)
{
    assert(ps);
    //如果ps->arr不为空
    if (ps->arr)
        free(ps->arr);

    ps->arr = NULL;//将释放完毕的指针置为空，防止称为野指针
    //恢复初始化
    ps->size = ps->capacity = 0;

}
  • tes.cpp
#include"Sqlist.h"

void test01()
{
	SL s1;

	SLInit(&s1);

	SLPushBack(&s1, 1);
	SLPushBack(&s1, 2);
	SLPushBack(&s1, 3);
	SLPushBack(&s1, 4);
	SLPushBack(&s1, 5);
	SLPrint(&s1);

	/*
	SLPushFront(&s1, 1);
	SLPushFront(&s1, 2);
	SLPushFront(&s1, 3);
	SLPushFront(&s1, 4);
	SLPushFront(NULL, 1);*/


	SLInsert(&s1, 0, 100);
	SLPrint(&s1);

	if (SLFind(&s1, 90) != -1) cout << "找到元素啦" << endl;
	else cout << "未找到！" << endl;
	

	SLDestory(&s1);
}
int main()
{
	test01();
	return 0;
}

在这里插入图片描述

🌟 各位看官好，我是工藤新一¹呀~

🌈 愿各位心中所想，终有所致！

c++ 顺序表
JIAN_ZANG1125的博客
11-15 2127
总结归纳 动态分配对内存有着更大的控制权，但也会花费相应的时间。 顺序表的查找时间复杂度为O(1)，这是单链表所不具备的。 顺序表的插入，要从后往前遍历，因为数据要后移；顺序表的删除，要从前往后遍历，因为数据要前移。 具体操作 #include<iostream> #include<algorithm> #include<string.h> #include<string> #include<numeric> #include<io
顺序表（C/C++）
m0_74830524的博客
01-17 717
本篇将讲解一些关于顺序表的内容，顺序表分为静态顺序表和动态顺序表，其中经常用到的为动态顺序表，所以本篇将以动态顺序表为重点给出一些关于动态顺序表的操作。 因为顺序表的实现逻辑较为简单，对于代码的讲解大多以注释给出。
顺序表(c++)
sin_0119的博客
09-24 2019
数据结构 顺序表
C++之顺序表
weixin_44367041的博客
07-01 903
#include <iostream> using namespace std; template <class T> class arrayList { private: int length; int MaxSize; T* elem; public: arrayList(int LMaxSize);//构造函数 ~arrayList();//析构函数 arrayList<T>& Insert(int k, const T& x);//
顺序表（c++实现）
echo_bright_的博客
01-12 857
线性表是具有相同类型的n(n>=0)个数据元素的有序(中间不能空位置)有限序列，如： X0, X1, … Xn-1   其中Xi为表项，n为长度。线性表具有如下性质：   （1）线性表的首元素X0，只有一个后继。   （2）Xn-1为线性表的最后一个元素，只有一个前驱。   （3）除X0和Xn-1外的其它元素既有前驱又有后继。   （4）支持逐项(下标)访问和顺序存取。
C/C++数据结构——顺序表的实现
JayWake的博客
03-19 687
ListInsert(&L,I,e)：在L中第i个位置之前插入新的数据元素e，L的长度+1。顺序表是线性表的顺序表示与实现，根据线性表抽象数据类型（ADT），完成顺序表的实现。数据关系：R={| ai-1,ai ∈D,i=2,…数据对象：D={ai|ai∈ElemSet,i=1,2,…InitList（&L）：构造一个空的线性表L。2、 SqList.cpp顺序表的实现。1、 SqList.h 顺序表的定义。3、main.cpp主程序，完成演示。
数据结构（C++版）——顺序表
最新发布
2401_83190311的博客
08-16 714
6、LocateElem(L,e)：在线性表中查找与指定值相同的数据元素的位置，找到返回该元素的位置序号，未找到返回FALSE。7、ListInsert(&L,i,e)：在L中第i个位置前插入新的数据元素e，L的长度加1。8、ListDelete(&L,i,&e)：删除L的第i个元素，并用e返回其值，L的长度减1。7、ListInsert(&L,i,e)：在L中第i个位置前插入新的数据元素e，L的长度加1。8、ListDelete(&L,i,&e)：删除L的第i个元素，并用e返回其值，L的长度减1。
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
### 数据结构C++ 线性表——顺序表和单链表基本操作 #### 一、概述 在《数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx》文档中，作者详细介绍了如何在C++中实现顺序表和单链表的基本操作，并...
数据结构（C++版）—— 顺序表Ⅰ
ygx0073的博客
07-26 1900
一、顺序表的定义顺序表——用顺序存储的方式实现线性表顺序存储把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现，是具有相同数据类型的n(n>0)个数据元素的有限序列。二，要实现的代码功能主要操作其他常用操作三，具体代码实现。
C++数据结构——哈希表
2303_78442132的博客
05-24 2233
c++、数据结构、哈希表
顺序表的实现（C++）
11-18
数据结构中的顺序表的实现其中包括初始化、删除、插入。还有额外的翻转、合并。本人用DEVC++亲测可以运行
用C++实现简单的顺序表
12-27
用数组实现的顺序表，具有增加 删除元素的功能，能求长度，清空表，遍历表，具有一定的功能。因为写的也比较简单，所以就只需要一分。 开发环境是VS2017和Windows10，相信大家应该都能运行。
【数据结构】顺序表(C++)
半生瓜のblog
10-04 1625
顺序表顺序表图示代码实现实际应用 顺序表 顺序表是简单的一种线性结构，逻辑上相邻的数据在计算机中内的存储位置也是相邻的，可以快速定位第几个元素，中间允许有空值，插入、删除时需要移动大量元素。 顺序表的三个要素 用elems记录存储位置的基地址。 分配一段连续的存储空间size（可以存放的元素个数）。 用length记录实际的元素个数，即顺序表的长度（现在实际存放的元素个数）。 图示 代码实现 #define MAX_SIZE 100 typedef int ElemsType; typedef
c++_顺序表
Starr
08-16 548
文章目录抽象数据类型时间复杂度线性表顺序表链表 数据：被计算机识别、处理的描述事物的符号集合。 数据项：数据不可分割的最小单位。 数据元素：有一定意义的基本单位，如某个对象。 数据对象：性质相同的数据元素的集合，如数组。 数据结构：相互之间存在一种或多种关系的数据元素集合。 逻辑结构： 集合结构 线性结构 树形结构 图形结构 物理结构： 顺序存储结构 链式存储结构 算法：解决特定问题的...
顺序表（C++实现）
believeme464646的博客
05-30 1992
在f2函数中，我们可以使用lambda表达式或者std::bind将f1函数绑定到函数对象上，并将这个函数对象作为参数传递给for_each算法，从而实现在f2函数中调用f1函数。注意，在lambda表达式或者std::bind中，必须将当前对象的指针通过this传递进去，以确保能够调用类的成员函数。对于全局函数，因为它们不属于类的一部分，也没有成员变量可以被限制为只读，在全局函数中使用 const 关键字是无效的。
顺序表（C++）
Cap07博客
02-21 510
#include //顺序表(C++) using namespace std; #include #define LIST_INIT_SIZE 100 //初始分配空间 #define LISTINCREMENT 10 //分配增量 typedef int ElemType; typedef int Status; typedef struct { ElemType* elem; //存储空间基址，指针
严蔚敏C++实现链表——数据结构详解
标题中提到的“严蔚敏-数据结构--链表实现c++实现”表明本文档与数据结构中的链表概念有关，并且是用C++这种编程语言实现的。严蔚敏是一位在中国计算机教育领域知名的学者，他所编写的关于数据结构的教材和资料，...
评论 32
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值