动态顺序表

动态为顺序表分配内存，实现基本的增、删、查、改、排序。

 List.h
#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#define MAXSIZE 3
typedef int Datatype;
typedef struct List{
   Datatype *_arr;
   size_t size; 
   size_t capicity;
}SeqList,*pSeqList;


void SeqInit(pSeqList L );
void SeqPrint(pSeqList L);

void SeqPushBack(pSeqList L, Datatype data) ;
void SeqPopBack(pSeqList L);
void SeqPushFront(pSeqList L, Datatype data);
void SeqPopFront(pSeqList L);

void SeqInsert(pSeqList L, int pos, Datatype data);
void SeqErase(pSeqList L, size_t pos); 
int SeqSearch(pSeqList L, Datatype data );  
void SeqAt(pSeqList L, size_t pos, Datatype data);    //替换 

void SeqInit(pSeqList L ){  //定义
    L->size = 0;
    L->capicity = MAXSIZE;
    L->_arr = (Datatype *)malloc(sizeof(Datatype) *L->capicity );
    if(L->_arr == NULL){
        printf("初始化失败！
");
        return;
    }
} 
SeqList* ExpandCapicity(pSeqList L){   //扩容
    assert(L);
    Datatype* temp; 
    if(L->size == L->capicity){
        temp = (Datatype *)realloc(L->_arr, sizeof(Datatype)*L->capicity*2);
       if( NULL == temp){
         printf("扩容失败！
");
         return ; 
       }
       L->capicity *=2; 
       L->_arr = temp;
    }    
    return L;
} 
void SeqPrint(pSeqList L){
    assert(L);
    int i= 0;
    for(i; i<L->size ; ++i){
        printf("%d ",L->_arr[i]);
    }
}
void SeqPushFront(pSeqList L, Datatype data){  //头插
    assert(L);
    size_t end = L->size - 1;
    if(L->size >= L->capicity){
        L= ExpandCapicity(L); 
    }    
    while((int)end >= 0){
        L->_arr[end+1] = L->_arr[end];
        end--;
    }
    L->_arr[0] = data;
    L->size++;
} 
void SeqPopFront(pSeqList L){    //头出
    assert(L);
    size_t begin = 1;
    if(L->size == 0){
        printf("NULL!");
        return;
    }
    while(begin < L->size){
        L->_arr[begin-1] = L->_arr[begin];
        begin++;
    }
    L->size--;
}
void SeqPushBack(pSeqList L, Datatype data){   //尾插
    assert(L);
    
    if(L->size > L->capicity){
        printf("SeqList is Full!");
        return ;
    }
    L->_arr[L->size++] = data;
    
}
void SeqPopBack(pSeqList L){
    assert(L);
    if(L->size <=0){
        printf("NULL");
        return;
    }
    L->size--;
    
}
void SeqInsert(pSeqList L, int pos, Datatype data){  //普通插入
    assert(L);
    assert(pos >= 0);
    if(pos > L->size){
        printf("Position Error!");
        return;
    }
    int end =L->size - 1;
    while(end >= pos){
        L->_arr[end+1] = L->_arr[end];
        end--;
    }
    L->_arr[pos] = data;
    L->size++;
}
void SeqErase(pSeqList L, size_t pos){   //删除
    assert(L);
    if(pos< 0 || pos > L->size){
        printf("No Exist!");
        return ;
    }
    size_t begin = pos +1;
    while(begin < L->size){
        L->_arr[begin -1] = L->_arr[begin];
        begin++;
    }
    L->size--;
    
}
int SeqSearch(pSeqList L, Datatype data){   //二分查找
    assert(L);
    int left = 0;
    int right = L->size - 1;
    while(left <= right){
        int mid = left + (right - left>> 1);
        if(L->_arr[mid] < data){
            left = mid +1;
        }
        else if(L->_arr[mid] > data)
            right = mid - 1;
        else return mid;
    }
    return -1;
}  
void SeqAt(pSeqList L, size_t pos, Datatype data){   //替换 
       assert(L);
    if(pos < 0 || pos >= L->size){
        printf("替换错误！
");
        return; 
    }
    L->_arr[pos] = data; 
}
void swap(int *x,int *y){
    int temp;
    temp = *x;
    *x = *y;
    *y =temp;
}
void BubbleSort(pSeqList L){  //冒泡排序
    assert(L);
    int i,j;
    for( i=0;i< L->size-1;++i){
        int flag= 0;
        for( j=0; j< L->size -1; ++j){
            if(L->_arr[j] > L->_arr[j+1]){
                swap(& L->_arr[j],&L->_arr[j+1]);
                flag =1;
            }
        }
        if(0 == flag){
            break;
        }
    }    
}

void SelectSort(pSeqList L){  //选择排序 
    size_t i,left = 0;
    size_t right = L->size - 1;
    size_t min = left;//存储最小值的下标
    size_t max = left;//存储最大值的下标

    while (left <= right)
    {
        min = left;
        max = left;
        for (i = left; i <= right; ++i)
        {
            if (L->_arr[i] < L->_arr[min])
            {
                min = i;
            }
            if (L->_arr[i] > L->_arr[max])
            {
                max = i;
            }
        }
        swap(&(L->_arr[left]), &(L->_arr[min]));
        if (left == max)
            max = min;
        swap(&(L->_arr[right]), &(L->_arr[max]));

        ++left;
        --right;
    }
}

#include <stdio.h>

int main(int argc, char *argv[]) {
//    test01();
//    test02();
//    test03();
//    test04();
//    test05();
    test06();
    return 0;
}