数组

重新整理一下数组的实现！

1、数组的定义
数组定义需要的成员变量：

T *data; //数据
int size; //个数
int capacity; //容量

2、主要操作
1）数组的构造函数需要注意数据需要使用new来开辟一定的空间大小，默认是10；
2）在进行添加和删除操作时，需要维护size；
3）一般操作包含：添加、查询、修改、包含、搜索、删除；
4）下面的实现中使用了泛型；
5）添加了动态扩容和缩容操作。

3、完整代码：

//数组
template<class T>
class Array {
private:
    T *data; //存储数据
    int size; //元素个数
    int capacity; //数组容量

    void resize(int newCapacity){
        T *newData=new T[newCapacity];
        for (int i=0;i<size;i++){
            newData[i]=data[i];
        }
        data=newData;
        capacity=newCapacity;
    }

public:
    class Range {
    };
    //构造函数
    Array(int capacity){
        data=new T[capacity];
        size=0;
        this->capacity=capacity;
    }
    //无参构造函数
    Array(){
        data=new T[10];//默认容量是10
        size=0;
        this->capacity=10;
    }

    //传入一个数组进行构造
    Array(T arr[], int n) {
        data = new T[n];
        size = n;
        for (int i = 0; i < n; ++i) {
            data[i] = arr[i];//元素拷贝
        }
        capacity = n;
    }

    //获取数组中的元素个数
    int getSize(){
        return size;
    }
    //获取数组的容量
    int getCapacity(){
        return capacity;
    }
    //返回数组是否为空
    bool isEmpty(){
        return size==0;
    }
    //向所有元素后添加一个新的元素
    void addLast(T e){
        add(size,e);
    }
    void addFirst(T e){
        add(0,e);
    }
    //在第index个位置插入一个新元素e
    void add(int index,T e){
        assert(index>=0&&index<=size);
        //如果存储空间已经满了，就动态扩容
        if(size==capacity){
            resize(2*capacity);//扩容函数
        }
        //遍历数组，从尾部开始，依次向后移动一个位置，
        //直到到达插入位置index
        for(int i=size-1;i>=index;--i){
            data[i+1]=data[i];
        }
        data[index]=e;
        size++;
    }
    //获取index索引位置的元素
    T get(int index){
        assert(index>=0&&index<size);
        return data[index];
    }

    T getFirst(int index){
        return get(0);
    }

    T getLast(int index){
        return get(size-1);
    }

    //修改index位置的元素为e
    void set(int index,T e){
        assert(index>=0&&index<size);
        data[index]=e;
    }
    //查找数组中是否含有元素e
    bool contains(T e){
        for(int i=0;i<size;i++){
            if(data[i]==e)
                return true;
        }
        return false;
    }
    //查找数组中元素e所在的索引，如果不存在元素e，则返回-1
    int find(T e){
        for(int i=0;i<size;i++){
            if(data[i]==e)
                return i;
        }
        return -1;
    }
    //从数组中删除index位置的元素，返回删除的元素
    T remove(int index){
        assert(index>=0&&index<size);
        T ret =data[index];
        for(int i=index+1;i<size;i++){
            data[i-1]=data[i];
        }
        size--;
//        data[size]= nullptr;

        if(size==capacity/4&&capacity/2!=0){//这里的capacity/2!=0 是用于防止下面resize时capacity为1的情况
            resize(capacity/2);
        }
        return ret;
    }
    int removeFirst(){
        remove(0);
    }
    int removeLast(){
        remove(size-1);
    }
    //删除元素e
    void removeElement(T e){
        int index_e=find(e);
        if(index_e!=-1)
            remove(index_e);
    }

    void swap(int i, int j) {
        if (i < 0 || i >= size || j < 0 || j >= size) {
            throw Range();
        }
        T t = data[i];
        data[i] = data[j];
        data[j] = t;
    }

    void print(){
        std::cout << "Array: size = " << size << ", capacity = " << getCapacity() << std::endl;
        toPrint();
        std::cout << std::endl;
    }
    void toPrint(){
        std::cout << "[";
        for (int i = 0; i < size; ++i) {
            std::cout << data[i];
            if (i != size - 1) {
                std::cout << ", ";
            }
        }
        std::cout << "]";
    }

};