数据结构之线性结构--数组

最新推荐文章于 2024-07-15 11:20:28 发布
最新推荐文章于 2024-07-15 11:20:28 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangmeiqiang/article/details/52313412
版权

一、什么是线性表

 线性表是种由零个或者多个元素组成的有限序列，线性表强调元素是有限的，就像一个班的人数也是有限的，一个线性表中只有一个头和一个尾，中间的元素有一个前驱和一个后记。

二、线性表的顺序储存方式

1、 顺序储存结构中使用一片连续的内存来储存线性表中的所有元素。在C++中使用数组来实现储存。

2、顺序储存结构中的元素的插入方式 ：

3、顺序储存结构中的元素的删除方式 ;

4、顺序储存结构的访问
在顺序储存结构中通常使用数组来储存数据，我们在访问数据的时候只需要指定数据在数组中的位置的下标则可以了。

5、顺序储存结构的优缺点

6、顺序储存结构的代码实现

//H文件
#ifndef _AL_LISTSEQ_INCLUDE
#define _AL_LISTSEQ_INCLUDE

#include <windows.h>

template<typename T> 
class AL_ListSeq
{
public:
    //定义了一些基本的常量

    //默认的储存区域大小
    static const DWORD LISTSEQ_DEFAULTSIZE          = 100;
    //表示最大储存内存
    static const DWORD LISTSEQ_MAXSIZE              = 0xffffffff;
    //表示没有当前内存没有这个元素
    static const DWORD LISTSEQ_POSITION_INVALID     = 0xffffffff;

    //初始化构造函数,为线性表分配内存
    AL_ListSeq(DWORD dwSize = LISTSEQ_DEFAULTSIZE);

    //析构函数，释放数组内存
    ~AL_ListSeq();

   //获取当前已经储存的数据的长度
    DWORD Length() const;

    //根据内容查找元素在表中的位置
    DWORD Find(const T& tData) const;

    //判读查找的元素是否在表中存在
    BOOL IsElement(const T& tData) const;

    //随机插入元素
    BOOL Insert(DWORD dwIndex,const T& tData);

    //在表的开始位置插入元素
    BOOL InsertBegin(const T& tData);

    //在表的元素长度的尾部插入元素
    BOOL InsertEnd(const T& tData);

    //移除并获取表中的任意元素
    BOOL Remove(const T& tData);

    //移除表中的任意元素但不返回移除元素的值
    BOOL RemoveAt(DWORD dwIndex);

    //判读当前表中是否有元素存在
    BOOL IsEmpty() const;

    //获取表中的任意一个元素的值
    BOOL Get(DWORD dwIndex, T& tTypeOut) const;

    //修改表中的任意一个元素的值
    BOOL Set(DWORD dwIndex, const T& tData, T& tTypeOut);

    //将记录表中存储元素的值归零
    VOID Clear();

    //两个表相互赋值
    AL_ListSeq<T>& operator = (const AL_ListSeq<T>& cAL_ListSeq);

private:
    //为线性表分配内存或者扩展内存大小
    VOID GetBuffer();

   //判断当前表中存储元素长度是否大于最大长度
    BOOL IsFull() const;


    AL_ListSeq(const AL_ListSeq<T>& cAL_ListSeq);

private: 

    T*          m_pElements;//用于储存元素的数组
    DWORD       m_dwMaxSize;//数组的最大长度
    DWORD       m_dwSize;//记录当前数组中储存元素的个数
};



//CPP文件
template<typename T> 
AL_ListSeq<T>::AL_ListSeq(DWORD dwSize):
m_pElements(NULL),
m_dwMaxSize(dwSize),
m_dwSize(0x00)
{
    if (0x00 == m_dwMaxSize) {
        //for memory deal
        m_dwMaxSize = 1;
    }
    GetBuffer();
}

template<typename T> 
AL_ListSeq<T>::~AL_ListSeq()
{
    if (NULL != m_pElements) {
        delete[] m_pElements;
        m_pElements = NULL;
    }
}

template<typename T> DWORD 
AL_ListSeq<T>::Length() const
{
    if (TRUE == IsEmpty()) {
        return 0;
    }

    return m_dwSize;
}


template<typename T> DWORD 
AL_ListSeq<T>::Find(const T& tData) const
{
    if (TRUE == IsEmpty()) {
        return LISTSEQ_POSITION_INVALID;
    }

    for(DWORD dwCnt=0x00; dwCnt<Length();dwCnt++) {
        if (m_pElements[dwCnt] == tData ) {
            return dwCnt;
        }
    }
    return LISTSEQ_POSITION_INVALID;
}

template<typename T> BOOL 
AL_ListSeq<T>::IsElement(const T& tData) const
{
    if (TRUE == IsEmpty()) {
        return FALSE;
    }

    if (LISTSEQ_POSITION_INVALID == Find(tData )) {
        return FALSE;
    }

    return TRUE;
}


template<typename T> BOOL 
AL_ListSeq<T>::Insert(DWORD dwIndex, const T& tData)
{
   //判插入的位置是否超出内存长度位置
    if (dwIndex > Length()) {
        return FALSE;
    }
    //判读当前储存元素个数是否与最大内存长度相同
    if (TRUE == IsFull()) {
        //重新分配内存
        GetBuffer();
    }
    //将元素向后移动
    for(DWORD dwCnt=(Length()-1+1); dwCnt>dwIndex; dwCnt--) {
        m_pElements[dwCnt] = m_pElements[dwCnt-1];
    }
    m_pElements[dwIndex] = tData ;

    m_dwSize++;
    return TRUE;
}

template<typename T> BOOL 
AL_ListSeq<T>::InsertBegin(const T& tData)
{
    return Insert(0, tData);
}


template<typename T> BOOL 
AL_ListSeq<T>::InsertEnd(const T& tData)
{
    return Insert(Length(), tData);
}


template<typename T> BOOL 
AL_ListSeq<T>::Remove(const T& tData)
{
    if (TRUE == IsEmpty()) {
        return FALSE;
    }

    BOOL bRemove = FALSE;
    for(DWORD dwCnt=0x00; dwCnt<Length();dwCnt++) {
        if (m_pElements[dwCnt] == tData ) {
            bRemove = RemoveAt(dwCnt);
            if (FALSE == bRemove) {
                return bRemove;
            }
        }
    }
    return bRemove;
}

template<typename T> BOOL 
AL_ListSeq<T>::RemoveAt(DWORD dwIndex)
{
    if (dwIndex > Length()) {
        //can not insert to this position
        return FALSE;
    }

    for(DWORD dwCnt=dwIndex; dwCnt<Length()-1; dwCnt++) {
        m_pElements[dwCnt] = m_pElements[dwCnt+1];
    }
    m_dwSize--;
    return TRUE;
}

template<typename T> BOOL 
AL_ListSeq<T>::IsEmpty() const
{
    return (0x00 == m_dwSize) ? TRUE:FALSE;
}


template<typename T> BOOL
AL_ListSeq<T>::Get(DWORD dwIndex, T& tTypeOut) const
{
    if (TRUE == IsEmpty()) {

        return FALSE;
    }

    if (Length()-1 < dwIndex) {

        return FALSE;
    }

    tTypeOut = m_pElements[dwIndex];
    return TRUE;
}

template<typename T> BOOL 
AL_ListSeq<T>::Set(DWORD dwIndex, const T& tData, T& tTypeOut)
{
    if (Length()-1 < dwIndex) {
        return FALSE;
    }

    tTypeOut = m_pElements[dwIndex];
    m_pElements[dwIndex] = tData ;
    return TRUE;
}

template<typename T> VOID 
AL_ListSeq<T>::Clear()
{
    m_dwSize = 0x00;
}


template<typename T> VOID 
AL_ListSeq<T>::GetBuffer()
{
   //当数组中储存的元素为最大长度并且数组非空时则结束函数调用
    if ( (FALSE == IsFull()) && (NULL != m_pElements) ) {
        return;
    }

    //当还没有为数组分配内存时，则为数组分配一个最大内存
    if (NULL == m_pElements) {
        if(0 < m_dwMaxSize){
            m_pElements = new T[m_dwMaxSize];
        }
        return;
    }


    T* pLastTpye = NULL;

    //设置线性表最大内存的一个长度，是否超过我们设置的常量值。
    pLastTpye = m_pElements;
    if (LISTSEQ_MAXSIZE == m_dwMaxSize) {

        return;
    }
    else if (LISTSEQ_MAXSIZE/2 < m_dwMaxSize) {
        m_dwMaxSize = LISTSEQ_MAXSIZE;
    }
    else {
        m_dwMaxSize *= 2;
    }
    //从新为线性表分配内存长度，并将数据拷贝到新的内存空间中
    if(0 < m_dwMaxSize){

        m_pElements = new T[m_dwMaxSize];
    }
    for (DWORD dwCpy=0x00; dwCpy<Length(); dwCpy++) {
        m_pElements[dwCpy] = pLastTpye[dwCpy];
    }
    delete[] pLastTpye;
    pLastTpye = NULL;
}


template<typename T> BOOL 
AL_ListSeq<T>::IsFull() const
{
    return (m_dwMaxSize <= Length()) ? TRUE:FALSE;
}


template<typename T> AL_ListSeq<T>& 
AL_ListSeq<T>::operator = (const AL_ListSeq<T>& cAL_ListSeq)
{
    Clear();
    T tData;
    for (DWORD dwAssign=0x00; dwAssign<cAL_ListSeq.Length(); dwAssign++) {
        if (TRUE == cAL_ListSeq.Get(dwAssign, tData)) {
            InsertEnd(tData);
        }
    }
    return *this;
}
#endif

测试代码


void ListSeqTest()
{
 //为数组分配一个单位的内存
    AL_ListSeq<DWORD> cListSeq(1);
    BOOL bEmpty = cListSeq.IsEmpty();
    std::cout<<bEmpty<<std::endl;

    //插入元素
    int array[15]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
    for(int i=0;i<15;i++)
           cListSeq.Insert(cListSeq.Length(), array[i]);
       bEmpty = cListSeq.IsEmpty();
       std::cout<<bEmpty<<std::endl;

     //获取当前元素储存长度
       DWORD dwListSeq=cListSeq.Length();
       std::cout<<dwListSeq<<std::endl;
       //查找元素位置
       DWORD dwListSeqlen=cListSeq.Find(5);
       std::cout<<dwListSeqlen<<std::endl;

       //判断当前元素是否在表中存在
       bool bElement=cListSeq.IsElement(6);
       std::cout<<bElement<<std::endl;

       //移除元素
       bool mRemove=cListSeq.Remove(933);
       bool mRemoves=cListSeq.Remove(2);
      std::cout<<mRemove<<"  "<<mRemoves<<std::endl;

      //获取元素
      DWORD S;
      cListSeq.Get(3,S);
      std::cout<<S<<std::endl;

      //修改元素
      DWORD dw;
      cListSeq.Set(2,999,dw);
      cListSeq.Get(2,S);
      std::cout<<S<<std::endl;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    ListSeqTest();
    return a.exec();
}

运行结果：

无_空
关注
专栏目录
C++ 数据结构线性表-数组实现
12-26
C++ 数据结构线性表-数组实现 线性表的数组实现，实现几个核心的功能，语言是C++，如果有更好的想法和意见，欢迎留言~~~ /* Author : Moyiii * 线性表的数组实现，仅作学习之用，当然如果 * 你想拿去用，随你好啦...
线性结构-数组
强我强国
05-09 1256
这两种定义方式是等价的，不过第一种更符合Java的编程规范。上面只是声明了一个引用变量array，其本质还是一个指针，而数组本身并不存在，也就是说在内存中还没有开辟那段连续的存储空间。要使用数组，必须先对数组进行初始化。Java中初始化数组有两种方法：静态初始化和动态初始化。静态初始化：定义数组时显式地指定数组的初始值，系统会根据初始值的个数和类型自动为数组在堆内存中开辟空间。//定义数组和初始化数组同时完成 int [ ] array1 = {
C语言最常见的线性结构---数组
Nwk0000000001的博客
07-11 985
C语言最常见的线性结构—数组 数组详解 数组定义:有序数据的集合,用数组名作为标识 数组性质:数组是由一些列相同数据类型组成的线性集合 数组组成：标识符、类型名、维数。其中，维数指定数组中的元素个数。 数组优缺点: 1）与vector类型相比，数组缺陷在于：数组的长度是固定的，不能知晓数组的长度。同时没有size和push_back操作。如果要更改长度，则要创建更大的新数组，再复制原数组的所有元素。 注:vector是C++中的STL容器的一个容器分支,属于动态数组内容 2）数组是被严格限制
【数据结构】线性结构——数组、链表、栈和队列
最新发布
Filotimo_的博客
07-15 1342
线性结构是指数据元素之间存在一对一的关系，包括数组、链表、栈和队列等。这里介绍了这四种数据结构的优缺点和适用场景。
[数据结构与算法] 线性表之数组详解
淋曦的进击手记
08-13 1161
数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。
线性数据结构：数组 Array
qq_63815371的博客
02-24 665
数组是数据结构还是数据类型？数组只是个名称，它可以描述一组操作，也可以命名这组操作。数组的数据操作，是通过 idx->val 的方式来处理。它不是具体要求内存上要存储着连续的数据才叫数组，而是说，通过连续的索引 idx，也可以线性访问相邻的数据。那么当你定义了数据的存储方式，也就定义了数据结构。所以它也是被归类为数据结构。
数据结构——线性数据结构（数组，链表，栈，队列）
帆的博客
08-22 1125
链表（LinkedList）虽然是一种线性表，但是并不会按线性的顺序存储数据，使用的不是连续的内存空间来存储数据。链表的插入和删除操作的复杂度为 O(1) ，只需要知道目标位置元素的上一个元素即可。但是，在查找一个节点或者访问特定位置的节点的时候复杂度为 O(n)。使用链表结构可以克服数组需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。但链表不会节省空间，相比于数组会占用更多的空间，因为链表中每个节点存放的还有指向其他节点的指针。
CH4-数组18.zip_数据结构
09-21
数组是计算机科学中基础且重要的数据结构之一，它在数据处理和算法实现中扮演着核心角色。本资料“CH4-数组18.zip_数据结构”聚焦于数组的理论与应用，适合大学课程学习和复习。PDF文档“CH4-数组18.pdf”可能包含了...
数据结构和算法----稀疏数组.rar
09-17
在数据结构中，稀疏矩阵是稀疏数组最常见的应用场景，特别是在处理图形算法、线性代数等领域的矩阵运算时。例如，在图形学中，邻接矩阵用于表示图中顶点之间的连接关系，当图稀疏（即边的数量远小于顶点数量的平方）...
数据结构之数组Array实例详解
08-30
数组是一种基础且重要的数据结构，它在计算机科学中扮演着核心角色。数组允许我们在内存中以固定大小和顺序存储相同类型的数据。本篇将深入探讨数据结构中的数组Array，包括其基本概念、操作以及实例详解。 1. **...
数据结构与算法----线性结构（数组）
我睡觉的时候不困
08-31 515
目录 前言 一、数组的基本使用 1、数组的创建 2、数组元素的添加 3、数组的删除 二、面向对象的数组 三、查找算法 1、线性查找 2、二分法查找 前言 概念：指的就是一组相关类型的变量集合，并且这些变量可以按照统一的方式进行操作，它是典型的线性结构。 一、数组的基本使用 1、数组的创建 package demo1 public class TestArray{ public static void main(String[] args){ .
线性结构---数组
qq_41185460的博客
10-21 242
数组的使用 定于数组最常用的两种方法 int[] arr = new int[3]; int[] arr = new int[]{1,2,3}; 我们会发现长度都是不可变的，如何解决这个问题呢？ 如何给长度为3的饱和数组中再添加一个元素呢？？ 仔细想想，我们可以这样做 public static void main(String[] args) { int arr[]...
【数据结构与算法之线性结构】数组
谢谢你们的关注
03-13 89
【数据结构与算法之线性结构】数组
非线性结构-多维数组
君不见皇的博客
05-02 3143
系统了解请参照-数据结构 概念 存储方式 多维数组与前面的线性表、栈、队列都不同，多维数组不是线性结构。其实所谓的线性结构就是前趋和后继数量的问题，如果超过一个前趋或者后继，那就是非线性结构。 多维数组-二维数组A[n][m]-简单矩阵： 这是一个常见的二维数组案例，他的前趋数和后继数与维度有关，可以看到在5这个节点，按行看有一个4前趋，一个6后继，按列看有一个2前趋，有一个8后继。由于一般很少...
线性结构（数组）
小海子的博客
12-28 1377
数组 基本使用 public static void main(String[] args) { // 创建数组 int[] arr = new int[3]; // 获取数组长度 int length = arr.length; System.out.println(&quot;length:&quot;+length);...
线性结构之数组
Asia52的博客
08-13 264
线性结构：指每一个值都有一个key，标识 数组的删除和添加 面向对象的数组 package com.asia.dome; import java.util.Arrays; /** * @author asia * @Title: * @Package * @Description: 面向对象的数组 * @date 2019/8/1322:13 */ public class ...
线性的初始化数组
july_young的博客
05-16 248
int a[3][4]; int num = 0; for (int *p = &amp;a[0][0]; p&lt;&amp;a[0][0]+12;p++) { *p = num; printf("%p\n",p); num++; }
矩阵转置算法与数据结构-数组和广义表
数组是数据结构的基础，它是由相同类型的数据元素组成的有序集合。数组可以是一维的，如简单的线性表，也可以是多维的，如二维数组表示的矩阵。在C/C++等语言中，二维数组可以看作是由行向量或列向量组成的集合。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值