顺序表

那么从今天开始，我将逐步开展对于数据结构的学习。

话不多说，我们先来看看第一种数据结构--顺序表。

顺序表的数据模型可以理解为一个数组，以线形方式进行存储，我们直接来看一下如何实现：

#include<iostream>
#include<stdexcept>

// 宏定义以适配多种类型的数据，便利修改数据类型
#define eleType double

using namespace std;

// 顺序表结构体
struct SequentialList {
    eleType* elements;
    int size;
    int capacity;
};

// 初始化
void initializeList(SequentialList* list, int capacity) {
    list->elements = new eleType[capacity]();
    list->size = 0;
    list->capacity = capacity;
}

void destoryList(SequentialList* list) {
    delete[] list->elements;
}

bool isEmpty(SequentialList* list) {
    return list->size == 0;
}

int size(SequentialList* list) {
    return list->size;
}

// 插入操作 -- 内含自动扩容操作
void insert(SequentialList* list, int index, eleType element) {
    if(index < 0 || index > list->size) {
        throw std::invalid_argument("Invalid index");
    }

    // 扩容
    if(list->size == list->capacity) {
        int newCapacity = list->capacity * 2;
        eleType* newElements = new eleType[newCapacity]();
        for(int i = 0; i < newCapacity / 2; i++) {
            newElements[i] = list->elements[i];
        }
        delete[] list->elements;
        list->elements = newElements;
        list->capacity = newCapacity;
    }
    list->size++;

    if(list->size <= list->capacity) {
        for(int i = list->size - 1; i > index; i--) {
            list->elements[i] = list->elements[i - 1];
        }
        list->elements[index] = element;
    }
}

// 覆盖以删除
void deleteElement(SequentialList* list, int index) {
    if(index < 0 || index >= list->size) {
        throw std::invalid_argument("Invalid index");
    }
    for(int i = index; i < list->size - 1; i++) {
        list->elements[i] = list->elements[i + 1];
    }
    list->size--;
}

int findElement(SequentialList* list, eleType element) {
    for(int i = 0; i < list->size; i++) {
        if(list->elements[i] == element) {
            return i;
        }
    }
    return -1;
}

eleType getElement(SequentialList* list, int index) {
    if(index < 0 || index >= list->size) {
        throw invalid_argument("Invalid index");
    }
    return list->elements[index];
}

void updateElement(SequentialList* list, int index, eleType value) {
    if(index < 0 || index >= list->size) {
        throw invalid_argument("Invalid index");
    }
    list->elements[index] = value;
}

int main(void) {
    cout << "..." << endl;
    return 0;
}

这就是顺序表模版，重点看看扩容部分，那么是不是有种熟悉的感觉？

对于头文件：#include<vector>，实现了动态内存的管理，本质上也是用了这种思想，只不过它采用了更为高效的数据结构。

那么，顺序表我们就先学到这，接下来我们将学习单向链表。