静态顺序表

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

typedef struct SeqList
{
    DataType array[MaxSize];
    int size;   // 有效数据元素的个数
}SeqList;

//
// 初始化顺序表
void InitSeqList(SeqList* pSeq)
{
    assert(pSeq);
    memset(pSeq->array,0, sizeof(DataType)*MaxSize);    
    pSeq->size=0;
}

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

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

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

// 删除顺序表头部元素
void PopFront(SeqList* 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(SeqList* pSeq, size_t pos, DataType data)
{
    size_t idx=0;
    assert(pSeq);
    if(NULL==pSeq||pos>pSeq->size||pSeq->size>MaxSize)
        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(SeqList* 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(SeqList* 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(SeqList* pSeq, DataType data)
{
    assert(pSeq);
    Erase(pSeq,Find(pSeq,data));
}

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

// 使用冒泡排序给顺序表中的元素排序
void BubbleSort(SeqList* 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(SeqList* 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(SeqList* 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(SeqList* pSeq)
{
    size_t i=0;
    assert(pSeq);
    if(pSeq==NULL)
        printf("The seqlist is empty");
    else if(pSeq->size>=MaxSize)
        printf("The seqlist is full");
    else
    {
        for(i;i<pSeq->size;i++)
            printf("%2d",pSeq->array[i]);
        printf("\n");
    }       
}

void FunTest()
{
    int pos=0;
    SeqList list1;
    InitSeqList(&list1);
    PushBack(&list1,0);
    PushBack(&list1,7);
    PushBack(&list1,3);
    PushBack(&list1,2);
    PushBack(&list1,5);
    PushBack(&list1,6);
    PushBack(&list1,5);
    PrintList(&list1);
    //PopBack(&list);
    //PushFront(&list,2);
    PopFront(&list);
    //Insert(&list,1,3);
    //Erase(&list,1,3);
    //Find(&list,2);
    //Remove(&list,2);
    //RemoveAll(&list,5);
    BubbleSort(&list1);
    PrintList(&list1);
    SelectSort(&list1);
    PrintList(&list1);
    pos=BinarySearch(&list1,5);
    printf("%d\n",pos);
}

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