动态顺序表

#include<stdio.h>
#include<assert.h> 
#include<malloc.h>
typedef int DataType;

typedef struct SeqListD
{
    DataType* array;
    size_t size;   // 有效数据元素的个数
    size_t capacity;//最大容量
}SeqListD,*pSeqListD;

//
// 初始化顺序表
void InitSeqListD(pSeqListD pSeq)//指针变量
{
    pSeq->array=(DataType*)malloc(10*sizeof(DataType));  
    if(pSeq->array)
    {
        pSeq->capacity=10;
    }
    pSeq->size=0;
}

void Destroy(pSeqListD pSeq)
{
    assert(pSeq);
    while(pSeq->array)
    {
        free(pSeq);
        pSeq=NULL;
        pSeq->size=0;
        pSeq->capacity=0;
    }
}

int CheckCapacity(pSeqListD pSeq)
{
    assert(pSeq);
    if(pSeq->size>=pSeq->capacity)
    {
        DataType* pTemp=(DataType*)realloc(pSeq->array,pSeq->capacity*2*sizeof(DataType));
        if(pTemp)
        {
            return 0;
        }
        else
        {
            pSeq->array=pTemp;
            pSeq->capacity*=2;
        }
    }
    return 1;
}


// 在顺序表的尾部插入值为data的元素
void PushBack(pSeqListD pSeq, DataType data)
{
    assert(pSeq);
    if(0==CheckCapacity(pSeq))
        return;
    pSeq->array[pSeq->size++]=data;
}

 //删除顺序表的最后一个元素
void PopBack(pSeqListD pSeq)
{
    assert(pSeq);
    if(0==pSeq->size)
        return;
    pSeq->size--;
}

// 在顺序表的头部插入值为data的元素
void PushFront(pSeqListD pSeq, DataType data)
{
    int idx=0;
    assert(pSeq);
    if(0==CheckCapacity(pSeq))
        return; 
    for(idx=pSeq->size-1;idx>=0;idx--)
    {
        pSeq->array[idx+1]=pSeq->array[idx];
    }
    pSeq->array[0]=data;
    pSeq->size++;
}

// 删除顺序表头部元素
void PopFront(pSeqListD pSeq)
{
    int idx=0;
    assert(pSeq);
    if(0==pSeq->size)
        return;
    for(idx;idx<pSeq->size;idx++)
        pSeq->array[idx]=pSeq->array[idx+1];
    pSeq->size--;
}

// 在顺序表中pos位置上插入值为data的元素
void Insert(pSeqListD pSeq, size_t pos, DataType data)
{
    size_t idx=0;
    assert(pSeq);
    if(NULL==pSeq||pos>pSeq->size||0==CheckCapacity(pSeq))
        return;
    for(idx=pSeq->size-1;idx>=pos;idx--)
    {
        pSeq->array[idx+1]=pSeq->array[idx];
    }
    pSeq->array[pos]=data;
    pSeq->size++;
}

// 删除顺序表中pos位置上的元素
void Erase(pSeqListD pSeq, size_t pos)
{
    size_t idx=0;
    assert(pSeq);
    if(NULL==pSeq||pSeq->size==0||pos>pSeq->size)
        return;
    for(idx=pos;idx<pSeq->size-1;idx++)
        pSeq->array[idx]=pSeq->array[idx+1];
    pSeq->size--;
}

// 在顺序表中查找值为data的元素，找到返回该元素的位置，否则返回-1
int Find(pSeqListD pSeq, DataType data)
{
    size_t idx=0;
    assert(pSeq);
    for(idx;idx<pSeq->size;++idx)
    {
        if(pSeq->array[idx]==data)
            return idx;
    }
    return -1;
}

// 删除顺序表中第一个值为data的元素
void Remove(pSeqListD pSeq, DataType data)
{
    assert(pSeq);
    Erase(pSeq,Find(pSeq,data));
}

// 删除顺序表中所有值为data的元素
void RemoveAll(pSeqListD pSeq, DataType data)
{
    int pos;
    assert(pSeq);
    while(-1!=(pos=Find(pSeq,data)))
    {
        Erase(pSeq,pos);
    }
}

// 使用冒泡排序给顺序表中的元素排序
void BubbleSort(pSeqListD pSeq)//由小到大
{
    int i=0;
    int j=0;
    int flag=0;
    assert(pSeq);
    for(i=0;i<pSeq->size-1;i++)
    {
        flag=0;
        for(j=0;j<pSeq->size-i-1;j++)
        {
            if(pSeq->array[j]>pSeq->array[j+1])
            {
                DataType tmp=pSeq->array[j];
                pSeq->array[j]=pSeq->array[j+1];
                pSeq->array[j+1]=tmp;
                flag=1;
            }
        }
        if(0==flag)
            return;
    }
}

// 使用选择排序给顺序表中的元素排序
void SelectSort(pSeqListD pSeq)//由小到大
{
    int i=0;
    int j=0;
    int pos=0;
    assert(pSeq);
    for(i=0;i<pSeq->size-1;i++)
    {
        pos=0;
        for(j=1;j<pSeq->size-i;j++)
        {
            if(pSeq->array[j]>pSeq->array[pos])
            {
                pos=j;//一直循环到pos为最大元素的位置
            }
        }
        if(pos!=j-1)
        {
            DataType tmp=pSeq->array[pos];
            pSeq->array[pos]=pSeq->array[j-1];
            pSeq->array[j-1]=tmp;
        }
    }
}

// 使用二分查找在顺序表中查找值为data
int BinarySearch(pSeqListD pSeq, DataType data)
{
    int left=0;
    int mid=0;
    int right=0;
    assert(pSeq);

    right=pSeq->size-1;
    while(left<=right)
    {
        mid=left+((right-left)>>1);
        if(pSeq->array[mid]==data)
            return mid;
        else if(pSeq->array[mid]>data)      
            right=mid-1;
        else
            left=mid+1;
    }
}

void PrintList(pSeqListD pSeq)
{
    size_t i=0;
    assert(pSeq);
    for(i;i<pSeq->size;i++)
        printf("%2d",pSeq->array[i]);
    printf("\n");

}

void FunTest()
{
    int pos=0;
    SeqListD list1;
    InitSeqListD(&list1);
    PushBack(&list1,2);
    PushBack(&list1,7);
    PushBack(&list1,3);
    PushBack(&list1,5);
    PushBack(&list1,6);
    PushBack(&list1,1);
    PushBack(&list1,8);
    PushBack(&list1,0);
    PushBack(&list1,9);
    PushBack(&list1,3);
    PrintList(&list1);

    PopBack(&list1);
    PrintList(&list1);

    PushFront(&list1,2);
    PrintList(&list1);

    PopFront(&list1);
    PrintList(&list1);

    Insert(&list1,1,3);
    PrintList(&list1);

    Erase(&list1,1,3);
    PrintList(&list1);

    Find(&list1,2);
    PrintList(&list1);

    Remove(&list1,2);
    PrintList(&list1);

    RemoveAll(&list1,3);
    PrintList(&list1);



    BubbleSort(&list1);
    PrintList(&list1);

    SelectSort(&list1);
    PrintList(&list1);

    pos=BinarySearch(&list1,7);
    printf("%d\n",pos);


}

int main()
{
    FunTest();
    return 0;
}