顺序表

Seqlist.h
#pragma once 
#define N 10
typedef int DataType;
typedef struct SeqList
{
    DataType _a[N];
    size_t size;
}SeqList;
//初始化尾插、删 头插、删
void SeqlistInit(SeqList *pSeq);
void SeqlistPushBack(SeqList *pSeq,DataType x);
void SeqlistPushFront(SeqList *pSeq, DataType x);
void SeqlistPopBack(SeqList *pSeq);
void SeqlistPopFront(SeqList *pSeq);
void SeqlistInsert(SeqList *pSeq,size_t pos,DataType x);
void SeqlistErase(SeqList *pSeq,size_t pos);
int SeqlistFind(SeqList *pSeq, DataType x);
void SeqlistModify(SeqList *pSeq, size_t pos,DataType x);
void SeqDestory(SeqList* pSeq);
void BubbleSort(SeqList* pSeq);
int BinarySearch(SeqList* pSeq, DataType x);
void SeqlistInit(SeqList *pSeq)//创建
{
    memset(pSeq->_a, 0, sizeof(DataType)*N);//初始化数组，让每个数组元素都为0
    pSeq->size = 0;//数组的元素的个数
}
void SeqlistPushBack(SeqList *pSeq, DataType x)
{
    assert(pSeq);
    if (pSeq->size >= N)
    {
        printf("数据已插满\n");
        return;
    }
    else
    {
        pSeq->_a[pSeq->size] = x;
        pSeq->size++;
    }
}//尾插
void SeqlistPrint(SeqList *pSeq)//顺序表的输出
{
    DataType i = 0;
    for (i = 0; i < (pSeq->size); ++i)
    {
        printf("%d ",pSeq->_a[i]);
    }
    printf("\n");
}
void SeqlistPushFront(SeqList *pSeq, DataType x)//顺序表的头插
{
    DataType  i = 0;;
    assert(pSeq);
    if (pSeq->size >= N)
    {
        printf("数据已满\n");
        return;
    }
    else
    {
        for (i = pSeq->size -1 ; i >= 0; i--)
        {
            pSeq->_a[i + 1] = pSeq->_a[i];
        }
        pSeq->_a[0] = x;
        pSeq->size++;
    }
}
void SeqlistPopBack(SeqList *pSeq)//顺序表的尾删
{
    assert(pSeq);
    if (pSeq->size == 0)
    {
        return;
    }
    else
    {
        --pSeq->size;
    }
}
void SeqlistPopFront(SeqList *pSeq)//顺序表的头删
{
    assert(pSeq);
    int i = 0;
    for (; i < pSeq->size; ++i)
    {
        pSeq->_a[i] = pSeq->_a[i + 1];
    }
    --pSeq->size;
}
void SeqlistInsert(SeqList *pSeq, size_t pos, DataType x)//顺序表插入
{
    assert(pSeq);
    assert(pos<=pSeq->size);
    if (pSeq->size >= N)
    {
        printf("数据已满\n");
        return;
    }
    else
    {
        int  i = 0;
        for (i = pSeq->size -1 ; i >= (int)pos ; --i)
        {
            pSeq->_a[i + 1] = pSeq->_a[i];
        }
        pSeq->_a[pos] = x;
        ++pSeq->size;
    }
}
void SeqlistErase(SeqList *pSeq, size_t pos)//删除顺序表特定位置的数据
{
    assert(pSeq);
    DataType i = pos ;
    for (; i <= pSeq->size -1; ++i)
    {
        pSeq->_a[i] = pSeq->_a[i + 1];
    }
    --pSeq->size;
}
int SeqlistFind(SeqList *pSeq, DataType x)
{
    assert(pSeq);
    int i = 0;
    while (pSeq->size--)
    {
        if (pSeq->_a[i] == x)
        {
            return i;
        }
        i++;
    }
}
void SeqlistModify(SeqList *pSeq, size_t pos, DataType x)
{
    assert(pSeq);
    DataType i = 0;
    if (pos > pSeq->size)
    {
        printf("位置越界");
        return;
    }
    pSeq->_a[pos] = x;
}
void SeqDestory(SeqList* pSeq)
{
    if (pSeq)
    {
        free(pSeq);
        pSeq = NULL;
        printf("销毁成功");
        return 1;
    }
    else
        return "error";

}
void BubbleSort(SeqList* pSeq)
{
    DataType i = 0,j=0,flag=0;
    for (; i < pSeq->size - 1; ++i)
    {
        for (j = 1; j < (pSeq->size) - 1 - i; ++j)
        {
            if (pSeq->_a[i] > pSeq->_a[j])
            {
                DataType b = 0;
                b = pSeq->_a[i];
                pSeq->_a[i] = pSeq->_a[j];
                pSeq->_a[j] = b;
                flag++;
            }   
        }
        if (flag == 0)
            {
                break;
            }
    }
}
//[]
//[)
int BinarySearch(SeqList* pSeq,DataType x)
{
    assert(pSeq);
    DataType left=0, right=0, mid=0;
    right = pSeq->size-1;
    while (right >= left)
    {
        mid = (left + right)>>1;
        if (pSeq->_a[mid] < x)
        {
            left = mid + 1;
        }
        else if (pSeq->_a[mid] > x)
        {
            right = mid - 1;
        }
        else
        {
            printf("找到了\n");
            return mid;
        }
    }
    return -1;
}


void Test1()
{
    SeqList list;
    DataType pos = 0;
    SeqlistInit(&list);
    SeqlistPushBack(&list, 1);
    SeqlistPushBack(&list, 2);
    SeqlistPushBack(&list, 3);
    SeqlistPushBack(&list, 4);
    SeqlistPushBack(&list, 5);
    SeqlistPrint(&list);
    SeqlistPopBack(&list);
    SeqlistPopFront(&list);
    SeqlistPrint(&list);
    SeqlistInsert(&list,2,1);
    SeqlistInsert(&list,2,6);
    SeqlistPrint(&list);
    SeqlistErase(&list,2);
    SeqlistPrint(&list);
    SeqlistInsert(&list, 0, 3);
    SeqlistErase(&list, 2);
    SeqlistPrint(&list);
    SeqlistErase(&list, 0);
    SeqlistInsert(&list, 2, 6);
    SeqlistInsert(&list, 2, 6);
    SeqlistErase(&list, 2);
    SeqlistPrint(&list);
    SeqlistModify(&list,2,4);
    SeqlistPrint(&list);
    //SeqDestory(&list);
    BubbleSort(&list);
    SeqlistPrint(&list);
    pos=BinarySearch(&list,4);
    printf("%d\n",pos);
}
test.c
#include<stdio.h>
#include<string.h>
#include<assert.h>
#include<windows.h>
#include"Seqlist.h"

int main()
{
    Test1();
    system("pause");
    return 0;
}