数据结构--线性表

线性表

线性表是由相同数据类型的 nn 个数据元素a0,a1..an-1 组成的有限序列。一个数据元素可以由若干个数据项组成。若用 LL 命名线性表，则其一般表示如下：
L=(a_0, a_1, …, a_{n-1})
其中， a_0是唯一的“第一个”数据元素，又称为表头元素；a_{n-1}是唯一的“最后一个”数据元素，又称为表尾元素。
线性表按照存储结构，可以分为顺序表和链表两种类型。
其中，顺序表是在计算机内存中以数组形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。

1. 线性表中的元素不一定是顺序排列的。
2. 线性表的表头元素和表尾元素和线性表中其他元素的数据类型相同。
3. 线性表中的元素个数是有限的。
4. 线性表中元素具有逻辑上的顺序性。

---

顺序表

顺序表是线性表的一种顺序存储形式。换句话说，线性表是逻辑结构，表示元素之间一对一的相邻关系；而顺序表是指存储结构，是指用一组地址连续的存储单元，依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。
设顺序表的第一个元素 a_0的存储地址为 Loc(a_0)，每个元素占 d个存储空间，则第 i 个元素的地址为
Loc(a{i-1})=Loc(a_0)+(i-1) * d
顺序表在程序中通常用一维数组实现，一维数组可以是静态分配的，也可以是动态分配的。
在静态分配时，由于数组的大小和空间是固定的，一旦空间占满，就无法再新增数据，否则会导致数据溢出。
而在动态分配时，存储数组的空间在程序执行过程中会动态调整大小，当空间占满时，可以另行开辟更大的存储空间来储存数据。
顺序表最主要的特点是可以进行 随机访问，即可以通过表头元素的地址和元素的编号（下标），在 O(1)的时间复杂度内找到指定的元素。
顺序表的不足之处是插入和删除操作需要移动大量的元素，从而保持逻辑上和物理上的连续性。

1. 存储密度大是顺序表的优点之一。
2. 顺序表占用的存储空间大小与元素的存放顺序无关。
3. 顺序表中不可能出现两个元素逻辑上相邻而在内存中不相邻的情况。
4. 若顺序表中第一个元素的起始地址为 00，每个元素大小为 44，则第 101101 个元素的起始地址为 400400。

---

顺序表的构造

#include <iostream>
#include <cstring>
using namespace std;
class Vector {
private:int size,length;int *data;
public:
    Vector(int input_size) {
        size = input_size;
        length=0;
        data = new int[size];
    }
    ~Vector() {
        delete[]data;
    }
};
int main() {
    Vector a(100);
    return 0;
}

---

顺序表的插入

#include <iostream>
#include <cstring>
using namespace std;
class Vector {
private:
    int size, length;
    int *data;
public:
    Vector(int input_size) {
        size = input_size;
        length = 0;
        data = new int[size];
    }
    ~Vector() {
        delete[] data;
    }
    bool insert(int loc, int value) {

        if(loc<0||loc>length){
            return false;   
        }

        if(length>=size){
          return false;   
        }

        for(int i = length;i>loc;--i){
                data[i]=data[i-1];
        }

        data[loc]=value;

        length ++;

        return true;

    }
};
int main() {
    Vector a(2);
    cout << a.insert(1, 0) << endl;
    cout << a.insert(0, 1) << endl;
    cout << a.insert(2, 1) << endl;
    cout << a.insert(1, 2) << endl;
    cout << a.insert(0, 3) << endl;
    return 0;
}

---

顺序表的扩容

#include <iostream>
#include <cstring>
using namespace std;
class Vector {
private:
    int size, length;
    int *data;
public:
    Vector(int input_size) {
        size = input_size;
        length = 0;
        data = new int[size];

    }
    ~Vector() {
        delete[] data;

    }
    bool insert(int loc, int value) {
        if (loc < 0 || loc > length) {
            return false;
        }
        if (length >= size) {
            //return false;
            expand();
        }
        for (int i = length; i > loc; --i) {
            data[i] = data[i - 1];
        }
        data[loc] = value;
        length++;
        return true;
    }
     void expand(){
           int *old_data = data;
           size = size *2;
           data = new int[size];
           for(int i=0;i<length;i++){
               data[i]= old_data[i];  
           }
         delete[] old_data;
        }
};
int main() {
    Vector a(2);
    cout << a.insert(1, 0) << endl;
    cout << a.insert(0, 1) << endl;
    cout << a.insert(2, 1) << endl;
    cout << a.insert(1, 2) << endl;
    cout << a.insert(0, 3) << endl;
    return 0;
}

---

顺序表的查找

#include <iostream>
#include <cstring>
using namespace std;
class Vector {
private:
    int size, length;
    int *data;
public:
    Vector(int input_size) {
        size = input_size;
        length = 0;
        data = new int[size];
    }
    ~Vector() {
        delete[] data;
    }
    bool insert(int loc, int value) {
        if (loc < 0 || loc > length) {
            return false;
        }
        if (length >= size) {
            return false;
        }
        for (int i = length; i > loc; --i) {
            data[i] = data[i - 1];
        }
        data[loc] = value;
        length++;
        return true;
    }
    int search(int value) {

        for(int i=0;i<length;++i){
            if(data[i]==value){
                 return i;   
            }
        }
               return -1;
    }
};
int main() {
    Vector a(2);
    cout << a.insert(1, 0) << endl;
    cout << a.insert(0, 1) << endl;
    cout << a.insert(2, 1) << endl;
    cout << a.insert(1, 2) << endl;
    cout << a.insert(0, 3) << endl;
    cout << a.search(1) << endl;
    cout << a.search(4) << endl;
    return 0;
}

---

顺序表的删除

#include <iostream>
#include <cstring>
using namespace std;
class Vector {
private:
    int size, length;
    int *data;
public:
    Vector(int input_size) {
        size = input_size;
        length = 0;
        data = new int[size];
    }
    ~Vector() {
        delete[] data;
    }
    bool insert(int loc, int value) {
        if (loc < 0 || loc > length) {
            return false;
        }
        if (length >= size) {
            return false;
        }
        for (int i = length; i > loc; --i) {
            data[i] = data[i - 1];
        }
        data[loc] = value;
        length++;
        return true;
    }
    int search(int value) {
        for (int i = 0; i < length; ++i) {
            if (data[i] == value) {
                return i;
            }
        }
        return -1;
    }
    bool remove(int index) {
        if(index<0||index>=length){
            return false;
        }

        for(int i =index+1;i<length;++i){
            data[i-1]=data[i];
        }

        length = length-1;

        return true;
    }
};
int main() {
    Vector a(2);
    cout << a.insert(0, 1) << endl;
    cout << a.insert(0, 2) << endl;
    cout << a.remove(1) << endl;
    cout << a.search(0) << endl;
    cout << a.search(1) << endl;
    return 0;
}

---

顺序表的遍历

#include <iostream>
#include <cstring>
using namespace std;
class Vector {
private:
    int size, length;
    int *data;
public:
    Vector(int input_size) {
        size = input_size;
        length = 0;
        data = new int[size];
    }
    ~Vector() {
        delete[] data;
    }
    bool insert(int loc, int value) {
        if (loc < 0 || loc > length) {
            return false;
        }
        if (length >= size) {
            return false;
        }
        for (int i = length; i > loc; --i) {
            data[i] = data[i - 1];
        }
        data[loc] = value;
        length++;
        return true;
    }
    int search(int value) {
        for (int i = 0; i < length; ++i) {
            if (data[i] == value) {
                return i;
            }
        }
        return -1;
    }
    bool remove(int index) {
        if (index < 0 || index >= length) {
            return false;
        }
        for (int i = index + 1; i < length; ++i) {
            data[i - 1] = data[i];
        }
        length = length - 1;
        return true;
    }
    void print() {

        for(int i=0;i<length;i++){
            if(i>0){
               cout<<" ";  
            }
            cout<<data[i];
        }
         cout<<endl;
    }
};
int main() {
    Vector a(2);
    cout << a.insert(0, 1) << endl;
    cout << a.insert(0, 2) << endl;
    a.print();
    cout << a.remove(1) << endl;
    a.print();
    cout << a.search(0) << endl;
    cout << a.search(1) << endl;
    return 0;
}