静态顺序表的基本操作 --- ( 尾插，尾删，头插，头删，指定位置插入，指定位置删除，选择排序，二分查找）

typedef int DataType;
#define MAX 10
typedef struct SeqList
{
    DataType data[MAX];
    int sz;
}SeqList,*pSeqList;

静态顺序表基础函数

void InitSeqList(pSeqList pSeq)//初始化
{
    assert(pSeq);
    memset(pSeq->data, 0, sizeof(DataType)*MAX);
    pSeq->sz = 0;
}

void PushBack(pSeqList pSeq, DataType data)//尾插
{
    assert(pSeq != NULL);
    if (pSeq->sz == MAX)
    {
        printf("空间已满\n");
        return 0;
    }
    pSeq->data[pSeq->sz] = data;
    pSeq->sz++;
}

void PrintSeqList(pSeqList pSeq)//打印顺序表
{
    assert(pSeq);
    int i = 0;
    for (i = 0; i < pSeq->sz; i++)
    {
        printf("%d->", pSeq->data[i]);
    }
    printf("NULL\n");
}

void PopBack(pSeqList pSeq)//尾删
{
    assert(pSeq);
    if (pSeq->sz == 0)
    {
        printf("顺序表为空\n");
        return;
    }
    pSeq->sz--;
}

void PushFront(pSeqList pSeq, DataType data)//头插
{
    assert(pSeq);
    if (pSeq->sz == MAX)
    {
        printf("顺序表已满\n");
        return;
    }
    int i = 0;
    for (i = pSeq->sz-1; i >= 0; i--)
    {
        pSeq->data[i+1] = pSeq->data[i];
    }
    pSeq->data[0] = data;
    pSeq->sz++;
}

void PopFront(pSeqList pSeq)//头删
{
    int i = 0;
    assert(pSeq);
    if (pSeq->sz == 0)
    {
        printf("顺序表为空\n");
        return;
    }
    for (i = 0; i < pSeq->sz - 1; i++)
    {
        pSeq->data[i] = pSeq->data[i + 1];
    }
    pSeq->sz--;
}

int Find(pSeqList pSeq, DataType data)//查找指定元素
{
    int i = 0;
    assert(pSeq);
    for (i = 0; i < pSeq->sz; i++)
    {
        if (pSeq->data[i] == data)
            return i;
    }
    return -1;

}

void Insert(pSeqList pSeq, int pos, DataType data)//指定位置插入
{
    int i = 0;
    assert(pSeq);
    if (pSeq->sz == MAX)
    {
        printf("顺序表已满\n");
        return;
    }
    for (i = pSeq->sz - 1; i >= pos - 1; i--)
    {
        pSeq->data[i+1] = pSeq->data[i];
    }
    pSeq->data[pos - 1] = data;
    pSeq->sz++;
}

void Erase(pSeqList pSeq, int pos)//删除指定位置元素
{
    int i = 0;
    assert(pSeq);
    for (i = pos - 1; i < pSeq->sz-1; i++)
    {
        pSeq->data[i] = pSeq->data[i + 1];
    }
    pSeq->sz--;
}

void Remove(pSeqList pSeq, DataType data)//删除指定元素
{
    int i;
    assert(pSeq);
    for (i = 0; i < pSeq->sz; i++)
    {
        if (pSeq->data[i] == data)
            break;
    }
    for (; i < pSeq->sz - 1; i++)
    {
        pSeq->data[i] = pSeq->data[i + 1];
    }
    pSeq->sz--;
}

void RemoveAll(pSeqList pSeq, DataType data)//删除所有的指定元素
{
    int i;
    int count = 0;
    assert(pSeq);
    for (i = 0; i < pSeq->sz; i++)
    {

        if (pSeq->data[i] != data)
        {
            pSeq->data[count++] = pSeq->data[i];
        }
    }
    pSeq->sz = count;
}

int Size(pSeqList pSeq)//返回顺序表的大小
{
    assert(pSeq);
    return (pSeq->sz*sizeof(DataType));
}

int Empty(pSeqList pSeq)//判断顺序表是否为空
{
    assert(pSeq);
    return pSeq->sz;
}

void swap(DataType *p1,DataType *p2)
{
    DataType tmp;
    tmp = *p2;
    *p2 = *p1;
    *p1 = tmp;
}

void BubbleSort(pSeqList pSeq)//冒泡排序
{
    assert(pSeq);
    int i = 0;
    int j = 0;
    for (i = 0; i < pSeq->sz-1; i++)
    {
        for (j = 0; j < pSeq->sz - 1 - i;j++)
        {
            if (pSeq->data[j] < pSeq->data[j + 1])
            {
                swap(pSeq->data + j, pSeq->data + j + 1);
            }
        }

    }
}

void SelectSort(pSeqList pSeq)//选择排序
{
    assert(pSeq);
    int i = 0;
    for (i = 0; i < pSeq->sz - 1; i++)
    {
        int m = 0;
        int j = 0;
        for (j = 1; j < pSeq->sz - i; j++)
        {
            if (pSeq->data[m] > pSeq->data[j])
                m = j;

        }
        swap(pSeq->data + m, pSeq->data+pSeq->sz - 1 - i);
    }

}

void SelectSortOP(pSeqList pSeq)//选择排序优化
{
    assert(pSeq);
    int i = 0;
    int j = 0;
    int start = 0;
    int end = pSeq->sz-1;
    while (start < end)
    {
        int maxpos = start;
        int minpos = start;
        i = start;
        for (; i < end; i++)
        {
            if (pSeq->data[maxpos] < pSeq->data[i + 1])
                maxpos = i + 1;
            if (pSeq->data[minpos] > pSeq->data[i + 1])
                minpos = i + 1;
        }
        /*swap(pSeq->data + maxpos, pSeq->data + end);
        if (maxpos != start || minpos != end)
        {
            if (minpos == end)
            {
                minpos == maxpos;
                swap(pSeq->data + minpos, pSeq->data + start);
            }
            else
                swap(pSeq->data + minpos, pSeq->data + start);
        }*/
        if (minpos != start)
        {
            swap(pSeq->data + minpos, pSeq->data + start);
        }
        if (maxpos == start)
        {
            maxpos = minpos;
        }
        if(maxpos!=end)
        {
            swap(pSeq->data + maxpos, pSeq->data + end);
        }
            start++;
            end--;
    }
}

int BinarySearch(pSeqList pSeq, DataType data)//二分查找
{
    assert(pSeq);
    int left = 0;
    int right = pSeq->sz - 1;
    while (left < right)
    {
        int mid = left + (right - left) / 2;
        if (pSeq->data[mid] > data)
        {
            right = mid;
            left;
        }
        else if (pSeq->data[mid] < data)
        {
            left = mid;
            right;
        }
        else
            return mid;
    }
    return -1;
}

int BinarySearch_R(pSeqList pSeq, int left, int right, DataType d)//二分查找递归
{
    assert(pSeq);
    if (left > right)
        return-1;
    int mid = left + (right - left) / 2;
    if (pSeq->data[mid] > d)
        BinarySearch_R(pSeq, left, mid, d);
    else if (pSeq->data[mid] < d)
        BinarySearch_R(pSeq, mid, right, d);
    else
        return mid;
}