实现动态顺序表

静态顺序表和动态顺序表之间的区别就是静态顺序表的存储大小一旦设定好之后便不能修改；显然动态顺序表采用的是动态分配内存，容量是可以增加的，当然动态顺序表要比静态顺序表多增加一个监测容量的参数，每当当前容量存满的时候就要触发扩容机制，实现动态开辟内存。由于两者差别不是很大，这里我就只实现动态顺序表，静态的基本一样，只是少了扩容机制。（这里我设置的初始容量为3，便于我们观察扩容机制）

现将动态顺序表的实现整理如下，要是哪里有错误，欢迎指正。

#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <string.h>

#define INIT_CAPACITY (3)
//实现动态顺序表
typedef int DataType;
typedef struct SeqList
{
    DataType* _a;
    size_t _size;    // 有效数据个数
    size_t _capacity;    // 容量
}SeqList;

void SeqPrint(SeqList* pSeq);//打印
void SeqInit(SeqList* pSeq);//初始化
void SeqDestory(SeqList* pSeq);//销毁

void SeqPushBack(SeqList* pSeq, DataType x);//尾插
void SeqPopBack(SeqList* pSeq);//尾删
void SeqPushFront(SeqList* pSeq, DataType x);//头插
void SeqPopFront(SeqList* pSeq);//头删

void SeqInsert(SeqList* pSeq, size_t pos, DataType x);//插入
void SeqErase(SeqList* pSeq, size_t pos);//删除

int SeqFind(SeqList* pSeq, DataType x);//查找
void SeqAt(SeqList* pSeq, size_t pos, DataType x);//修改

void BubbleSort(SeqList* pSeq);//冒泡排序
void SelectSort(SeqList* pSeq);//选择排序
int Binary_Search(SeqList* pSeq, DataType x);//二分查找



void SeqPrint(SeqList* pSeq){
    assert(pSeq != NULL);
    if(pSeq->_size == 0){
        printf("NULL\n");
    }
    for(int i=0; i<pSeq->_size; i++){
        printf("%d - > ", pSeq->_a[i]);
    }
    printf("\n");
}

void SeqInit(SeqList* pSeq){
    assert(pSeq);
    pSeq->_capacity = INIT_CAPACITY;
    pSeq->_a = (DataType *)malloc(sizeof(DataType)*pSeq->_capacity);
    assert(pSeq->_a);
    pSeq->_size = 0;
}
void SeqDestory(SeqList* pSeq){
    assert(pSeq);
    free(pSeq->_a);
    
    pSeq->_capacity = 0;
    pSeq->_a = NULL;
    pSeq->_size = 0;
}


void ExpendIfRequired(SeqList* pSeq){
    if(pSeq->_capacity > pSeq->_size){
        return;
    }
    pSeq->_capacity = pSeq->_capacity*2;
    
    DataType* newArray = (DataType *)malloc(sizeof(DataType)*pSeq->_capacity);
    
    for(int i=0; i<pSeq->_size; i++){
        newArray[i] = pSeq->_a[i];
    }
    free(pSeq->_a);
    pSeq->_a = newArray;
    
}
void SeqPushBack(SeqList* pSeq, DataType x){
    assert(pSeq);
    ExpendIfRequired(pSeq);
    
    pSeq->_a[pSeq->_size] = x;
    pSeq->_size++;
}

void SeqPopBack(SeqList* pSeq){
    assert(pSeq);
    if(pSeq->_size == 0){
        printf("this SeqList is NULL\n");
        return;
    }
    pSeq->_size--;
}

void SeqPushFront(SeqList* pSeq, DataType x){
    assert(pSeq);
    ExpendIfRequired(pSeq);
    
    for(int i=(int)pSeq->_size; i>0; i--){
        pSeq->_a[i] = pSeq->_a[i-1];
    }
    pSeq->_a[0] = x;
    pSeq->_size++;
}
void SeqPopFront(SeqList* pSeq){
    assert(pSeq);
    
    for(int i=0; i<pSeq->_size-1; i++){
        pSeq->_a[i] = pSeq->_a[i+1];
    }
    pSeq->_size--;
}

void SeqInsert(SeqList* pSeq, size_t pos, DataType x){
    assert(pSeq);
    if(pos == 0){
        SeqPushFront(pSeq, x);
    }
    else if(pos == pSeq->_size){
        SeqPushBack(pSeq, x);
    }
    else{
        for(int i=(int)pSeq->_size; i>pos; i--){
            pSeq->_a[i] = pSeq->_a[i-1];
        }
        pSeq->_a[pos] = x;
        pSeq->_size++;
    }
}
void SeqErase(SeqList* pSeq, size_t pos){
    assert(pSeq);
    if(pos == 0){
        SeqPopFront(pSeq);
    }
    else if (pos == pSeq->_size){
        SeqPopBack(pSeq);
    }
    else{
        for(int i=(int)pos; i<pSeq->_size-1; i++){
            pSeq->_a[i] = pSeq->_a[i+1];
        }
        pSeq->_size--;
    }
}

int SeqFind(SeqList* pSeq, DataType x){
    assert(pSeq);
    if(pSeq->_size == 0){
        return -1;
    }
    for(int i=0; i<pSeq->_size; i++){
        if(x == pSeq->_a[i]){
            return i;
        }
    }
    return -1;
}
void SeqAt(SeqList* pSeq, size_t pos, DataType x)//修改
{
    assert(pSeq);
    if(pSeq->_size == 0 || pos >= pSeq->_size){
        printf("不合法\n");
        return;
    }
    pSeq->_a[pos] = x;
    
}

void Swap(int *n1, int * n2){
    int temp = *n1;
    *n1 = *n2;
    *n2 = temp;
}
//升序
void BubbleSort(SeqList* pSeq){
    assert(pSeq);
    for(int i=0; i<pSeq->_size-1; i++){
        for(int j=0; j<pSeq->_size-1-i; j++){
            if(pSeq->_a[j] > pSeq->_a[j+1]){
                Swap(pSeq->_a+j, pSeq->_a+j+1);
            }
        }
    }
}

void SelectSort(SeqList* pSeq){
    int max = 0;
    int min = 0;
    
    int left = 0;
    int right = (int)pSeq->_size-1;
    
    while(left < right){
        max = min = left;
        for(int i=left; i<=right; i++){
            if(pSeq->_a[i] > pSeq->_a[max]){
                max = i;
            }
            else if (pSeq->_a[i] < pSeq->_a[min]){
                min = i;
            }
        }
        Swap(pSeq->_a+min, pSeq->_a+left);
        if(max == left){
            max = min;
        }
        Swap(pSeq->_a+max, pSeq->_a+right);
        
        left++;
        right--;
        SeqPrint(pSeq);
    }
}

int Binary_Search(SeqList* pSeq, DataType x){
    assert(pSeq);
    int left = 0;
    int right = (int)pSeq->_size-1;
    while(left<=right){
        int mid = left+(right-left)/2;
        if(x == pSeq->_a[mid]){
            return mid;
        }
        else if(x > pSeq->_a[mid]){
            left = mid+1;
        }
        else{
            right = mid-1;
        }
        
    }
    return -1;
}