558-数据结构(数组)

数据结构和算法介绍

线性表-数组理论讲解

int arr[10];//中括号里的一定要用常量或者常量表达式，写开辟数组的长度

长度是10个，下标是0-9


现在，数组的0号位-6号位有放置元素，也就是说，数组的长度是10个，里面有效元素的个数是7个。
数组的特点是 内存是连续的。

数组的查找或者搜索：时间复杂度是O(n)

数组的下标访问（随机访问）：

因为数组的每个元素的内存是连续的，所以我们地址可以在内存连续的方向上进行偏移，所以可以支持下标访问，不管访问哪个下标，时间复杂度都是O(1)

数组的末尾位置进行插入和删除花费的时间少（时间复杂度是O(1))，因为不涉及元素的移动
比如说有一个cur=7，记录数组中有效元素的个数，如果把它看作下标，刚好是数组末尾元素的后继位置的下标，我们要去删除一个末尾元素的话，把cur–一下，从7变成6就可以了，前面的元素也不用移动。

我们可以通过指针p的++访问当前元素的下一个元素，我们可以通过指针–访问当前元素的上一个元素，因为内存地址是连续的。

什么是线性表？
就是每一个元素都有一个前驱元素和一个后继元素
数组就满足这样1个特征

数组的优点： 如果下标访问多，就使用数组。

数组的缺点是：


比如说，我要在31元素这个位置插入元素80
31这个元素及它后面的所有元素都要依次向后挪动1个位置，才能把80插到31这个元素的位置。
从后往前，依次向后挪动1个位置。

在数组的非末尾位置插入1个元素，时间复杂度是O(n）
因为在非末尾位置插入元素，当前插入位置的元素的后边的元素越多，要进行数据移动所花费的时间就越多，就是线性时间，成正比。
在数组的非末尾位置删除元素，和上面同理。
比如说，现在要删除80这个元素，相当于要把80后面的所有元素依次前移1个位置。删除元素的位置的后面的元素的数据量越多，向前移动一个一个数据的总耗费时间就越多，和数据规模成正比的关系，所以时间复杂度是O(n）



如果是在无序的数组中搜索，要找某一个元素，只能for循环从0号位置开始，一个一个比对下去，数据量越大，算法所耗费的时间就越多，时间复杂度是O(n）
如果是在有序的数组（从小到大排序），要找某一个元素，我们就不用线性搜索，我们做二分搜索。时间复杂度是O(logn）

C++的vector容器底层的数据结构就是数组。

数组是可以扩容的。要使数组可以扩容，我们就得把数组定义在堆内存上。

数组的代码实现

对于C/C++的程序，程序运行后叫进程，进程在内存上的布局：
可用内存主要分为3个部分：

.data数据段存储的是全局变量的地方，是系统分配，系统释放的，其生命周期是整个程序的生命周期。
heap堆上的内存是我们自己可用通过C的malloc，free或者C++的new和delete来去自己开辟，自己手动释放。
stack栈上的内存，随着函数进来，分配内存，函数出右括号，释放内存，是系统来控制的。
所以，我们要想数组可以扩容，只能把数组定义在heap堆上了。

定义一个指针，指向堆上开辟的数组内存

在析构的时候没有必要去判断指针是否为空，即使指针不为空，也有可能是野指针，delete有效指针，是我们开发者自己去保证的，delete或者free空指针是可以的，相当于是一个空操作而已，不做任何操作。

扩容是在原有的基础上再定义一个新的内存，新的内存大小是原来的2倍。

1、开辟新的内存
2、把原来的数组上的数据一个一个拷贝到新的内存数组上

3、把原来的堆内存释放掉

vector在gcc下是2倍扩容，在VS2017以是1.5倍扩容

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <string.h>
using namespace std;

//数组实现
class Array
{
public:
    Array(int size = 10) : mCur(0), mCap(size)//构造函数，用户没有传参数，就用初始化值10 
    {
        mpArr = new int[mCap]();//把每一个位置初始化为int的0值 
    }
    ~Array()//析构函数 
    {
        delete[]mpArr;
        mpArr = nullptr;//放在野指针的出现 
    }

public:
    //末尾增加元素
    void push_back(int val)
    {
        if (mCur == mCap)//mcur指向最后一个有效元素的后继位置 
        {
            expand(2 * mCap);//O(n)
        }
        mpArr[mCur++] = val;//O(1) 
    }
    //末尾删除元素
    void pop_back()
    {
        if (mCur == 0)
        {
            return;
        }
        mCur--;//O(1)
    }
    //按位置增加元素
    void insert(int pos, int val)
    {
        if (pos < 0 || pos > mCur)
        {
            return;//throw "pos invalid!";
        }

        if (mCur == mCap)
        {
            expand(2 * mCap);
        }

        //移动元素  O(n)
        for (int i = mCur - 1; i >= pos; i--)//从后向前，进行依次向后移1个位置 
        {
            mpArr[i + 1] = mpArr[i];
        }

        mpArr[pos] = val;
        mCur++;
    }
    //按位置删除元素 
    void erase(int pos)
    {
        if (pos < 0 || pos >= mCur)
        {
            return;
        }

        //O(n)
        for (int i = pos + 1; i < mCur; i++)//从前向后，依次向前移动1个位置 
        {
            mpArr[i - 1] = mpArr[i];
        }

        mCur--;
    }
    //元素查询
    int find(int val)
    {
        for (int i = 0; i < mCur; i++)//O(n)
        {
            if (mpArr[i] == val)
            {
                return i;
            }
        }
        return -1;
    }
    //打印数据
    void show()const
    {
        for (int i = 0; i < mCur; i++)
        {
            cout << mpArr[i] << " ";
        }
        cout << endl;
    }
private:
    //内部数组扩容接口
    void expand(int size)
    {
        int* p = new int[size];
        memcpy(p, mpArr, sizeof(int) * mCap);//旧内存数据拷贝到新内存上 
        delete[]mpArr;
        mpArr = p;
        mCap = size;
    }
private:
    int* mpArr;//指向可扩容的数组内存，指针指向堆上开辟的数组内存 
    int mCap;//数组的容量
    int mCur;//数组有效元素个数
};

int main()
{
    Array arr;

    srand(time(0));//系统时间种一个随机数种子 
    for (int i = 0; i < 10; i++)
    {
        arr.push_back(rand() % 100);
    }

    arr.show();
    arr.pop_back();
    arr.show();

    arr.insert(0, 100);
    arr.show();

    arr.insert(10, 200);
    arr.show();

    int pos = arr.find(100);
    if (pos != -1)
    {
        arr.erase(pos);
        arr.show();
    }
}