C++ 数据结构 静态顺序表、动态顺序表。

已于 2024-11-01 11:05:17 修改
阅读量819 收藏 20
点赞数 11
分类专栏： C++ 数据结构 文章标签： c++ 数据结构 开发语言
于 2024-11-01 11:04:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_50373827/article/details/143426332
版权

静态顺序表（Static Array List）是一种线性数据结构，通常用数组实现。它具有固定的大小，并在编译时分配内存。以下是静态顺序表的一些基本概念和实现示例。

静态顺序表基本概念

  1. 固定大小：静态顺序表的大小在创建时定义，无法动态扩展。
  2. 数组实现：使用数组存储数据元素，支持随机访问。
  3. 插入和删除操作：需要移动元素以保持顺序，可能会影响性能。
  4. 顺序存储：元素在内存中是连续存储的，支持高效的随机访问。

1. 数据结构示意图

假设我们有一个静态顺序表的初始状态如下（数组最大容量为5）：

Index:  0   1   2   3   4
        +---+---+---+---+---+
Data:   |   |   |   |   |   |
        +---+---+---+---+---+
Length: 0

2. 尾部插入

操作：将元素10插入到表的末尾。

Index:  0   1   2   3   4
        +---+---+---+---+---+
Data:   | 10|   |   |   |   |
        +---+---+---+---+---+
Length: 1

这里因为是一个空表，所以插入之后值就是index是0的位置。

3. 头部插入

操作：将元素5插入到表的头部（索引0）。

Index:  0   1   2   3   4
        +---+---+---+---+---+
Data:   |  5| 10|   |   |   |
        +---+---+---+---+---+
Length: 2

4. 中间插入

操作：将元素7插入到索引1的位置。

过程：

  1. 移动元素10（从索引1到索引2）以为新元素腾出空间。

结果：

Index:  0   1   2   3   4
        +---+---+---+---+---+
Data:   |  5|  7| 10|   |   |
        +---+---+---+---+---+
Length: 3

#include <iostream>
#include <stdexcept> 
#include <string>

const int MAX_SIZE = 5; // 最大容量

template <typename T>
class StaticArrayList {
public:
    StaticArrayList() : m_length(0) {} // 构造函数，初始化长度为0
    ~StaticArrayList() {} // 默认析构函数

    // 插入元素
    bool insert(int index, const T &value) {
        if (index < 0 || index > m_length || m_length >= MAX_SIZE) {
            return false; // 索引越界或已满
        }

        // 移动元素以腾出插入位置
        for (int i = m_length; i > index; --i) {
            m_data[i] = m_data[i - 1];
        }
        m_data[index] = value; // 插入新元素
        m_length++;
        return true;
    }

    // 删除元素
    bool remove(int index) {
        if (index < 0 || index >= m_length) {
            return false; // 索引越界
        }

        // 移动元素以填补删除位置
        for (int i = index; i < m_length - 1; ++i) {
            m_data[i] = m_data[i + 1];
        }
        m_length--;
        return true;
    }

    // 获取元素
    T get(int index) const {
        if (index < 0 || index >= m_length) {
            throw std::out_of_range("Index out of range"); // 异常处理
        }
        return m_data[index]; // 返回元素
    }

    // 获取当前长度
    int size() const {
        return m_length; // 返回当前元素个数
    }

    // 打印所有元素
    void print() const {
        for (int i = 0; i < m_length; ++i) {
            std::cout << m_data[i] << " "; // 输出元素
        }
        std::cout << std::endl; // 换行
    }

private:
    T m_data[MAX_SIZE]; // 存储元素的数组
    int m_length;       // 当前元素个数
};

int main() {
    StaticArrayList<int> list; 

    list.insert(0, 10);
    list.insert(1, 20);
    list.insert(1, 15);
    list.print(); // 输出: 10 15 20

    list.remove(1);
    list.print(); // 输出: 10 20

    try {
        std::cout << "Element at index 0: " << list.get(0) << std::endl; 
    }
    catch (const std::out_of_range &e) {
        std::cerr << e.what() << std::endl; 
    }

    return 0;
}

动态顺序表（Dynamic Array List）是一个可以动态调整大小的线性数据结构，通常使用动态分配的数组来实现。与静态顺序表相比，动态顺序表的大小可以根据需要进行扩展和收缩。以下是动态顺序表的基本概念和实现示例。

动态顺序表基本概念

  1. 动态大小：可以根据元素数量动态调整大小。
  2. 数组实现：使用动态分配的数组存储数据元素，支持随机访问。
  3. 插入和删除：在尾部插入操作比较高效，而在中间插入或删除时需要移动元素。
#include <iostream>
#include <stdexcept> // 用于异常处理

template <typename T>
class DynamicArrayList {
public:
    DynamicArrayList() : m_size(0), m_capacity(2) {
        try {
            m_data = new T[m_capacity]; // 动态分配数组
        }
        catch (const std::bad_alloc &e) {
            std::cerr << "Memory allocation failed: " << e.what() << std::endl;
            throw; // 重新抛出异常以便上层处理
        }
    }

    ~DynamicArrayList() {
        delete[] m_data; // 释放动态分配的数组
    }

    // 插入元素
    void insert(const T &value) {
        if (m_size >= m_capacity) {
            resize(); // 扩展容量
        }
        m_data[m_size++] = value; // 添加新元素
    }

    // 删除元素
    bool remove(int index) {
        if (index < 0 || index >= m_size) {
            return false; // 索引越界
        }
        for (int i = index; i < m_size - 1; ++i) {
            m_data[i] = m_data[i + 1]; // 移动元素
        }
        m_size--;
        return true;
    }

    // 获取元素
    T get(int index) const {
        if (index < 0 || index >= m_size) {
            throw std::out_of_range("Index out of range"); // 异常处理
        }
        return m_data[index]; // 返回元素
    }

    // 获取当前长度
    int size() const {
        return m_size; // 返回当前元素个数
    }

    // 打印所有元素
    void print() const {
        for (int i = 0; i < m_size; ++i) {
            std::cout << m_data[i] << " "; // 输出元素
        }
        std::cout << std::endl; // 换行
    }

private:
    T *m_data;        // 动态分配的数组
    int m_size;       // 当前元素个数
    int m_capacity;   // 当前容量

    // 扩展容量
    void resize() {
        m_capacity *= 2; // 容量翻倍
        T *newData = nullptr;
        try {
            newData = new T[m_capacity]; // 创建新数组
        }
        catch (const std::bad_alloc &e) {
            std::cerr << "Memory allocation failed during resize: " << e.what() << std::endl;
            throw; // 重新抛出异常
        }

        for (int i = 0; i < m_size; ++i) {
            newData[i] = m_data[i]; // 复制元素
        }
        delete[] m_data; // 释放旧数组
        m_data = newData; // 更新指针
    }
};

int main() {
    try {
        DynamicArrayList<int> list; // 创建动态顺序表实例
        list.insert(10);
        list.insert(20);
        list.insert(30);
        list.print(); // 输出: 10 20 30

        list.remove(1);
        list.print(); // 输出: 10 30

        std::cout << "Element at index 0: " << list.get(0) << std::endl; // 输出: 10
    }
    catch (const std::bad_alloc &e) {
        std::cerr << "Failed to allocate memory: " << e.what() << std::endl;
    }
    catch (const std::out_of_range &e) {
        std::cerr << e.what() << std::endl; // 捕获越界异常
    }

    return 0;
}

1. 动态数组的优缺点

  • 优点：

    • 动态调整大小：可以根据需要增加或减少数组的大小，灵活性较高。
    • 随机访问：支持O(1)时间复杂度的随机访问。

  • 缺点：

    • 插入和删除效率：在数组中间插入或删除元素时，需要移动元素，时间复杂度为O(n)。
    • 内存分配：每次扩展容量时，需要分配新内存并复制数据，可能会导致性能下降。

2. 扩展策略

  • 容量翻倍：在数组满时将容量翻倍是一种常见的扩展策略，能有效减少频繁的内存分配操作。
  • 减少容量：可以考虑在删除元素后，如果数组的使用率低于某个阈值（如25%），则缩小数组的容量，以节省内存。

3. 迭代器支持

为了使动态顺序表更加灵活，可以实现迭代器支持，允许用户使用范围for循环遍历元素。这需要定义一个迭代器类，并在动态数组类中实现相关方法。

4. 拷贝构造和赋值运算符

  • 拷贝构造函数：在类中添加拷贝构造函数，以支持深拷贝。
  • 赋值运算符重载：实现赋值运算符重载以支持正确的赋值操作，避免浅拷贝引起的问题。

5. 线程安全

在多线程环境中，如果多个线程同时访问动态数组，可能会导致数据不一致或崩溃。可以通过加锁机制或使用原子操作来实现线程安全。

6. 性能优化

  • 预分配内存：如果预知元素数量，可以在初始化时分配足够的内存，避免频繁扩展。
  • 内存池：使用内存池技术，减少频繁的动态内存分配操作，提高性能。

代码（包含拷贝构造和赋值运算符）

下面是改进后的动态顺序表示例，添加了拷贝构造函数和赋值运算符重载：

#include <iostream>
#include <stdexcept>

template <typename T>
class DynamicArrayList {
public:
    DynamicArrayList() : m_size(0), m_capacity(2) {
        m_data = new T[m_capacity];
    }

    ~DynamicArrayList() {
        delete[] m_data;
    }

    // 拷贝构造函数
    DynamicArrayList(const DynamicArrayList& other) {
        m_size = other.m_size;
        m_capacity = other.m_capacity;
        m_data = new T[m_capacity];
        for (int i = 0; i < m_size; ++i) {
            m_data[i] = other.m_data[i];
        }
    }

    // 赋值运算符重载
    DynamicArrayList& operator=(const DynamicArrayList& other) {
        if (this != &other) {
            delete[] m_data; // 释放旧内存
            m_size = other.m_size;
            m_capacity = other.m_capacity;
            m_data = new T[m_capacity]; // 分配新内存
            for (int i = 0; i < m_size; ++i) {
                m_data[i] = other.m_data[i];
            }
        }
        return *this;
    }

    // 插入、删除、获取等方法保持不变...

private:
    T* m_data;
    int m_size;
    int m_capacity;

    void resize() {
        // resize 实现...
    }
};

int main() {
    // 示例操作...
    return 0;
}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值