顺序表实现之C语言（附加各种顺序表排序问题）

seqlist.h:


#include <stdio.h>
#include <assert.h>
#ifndef _SEQLIST_H
#define _SEQLIST_H
#define MAX 10
typedef int Datatype;
typedef struct {
    Datatype array[MAX];
    Datatype size;
}seqlist;
void Init_seq(seqlist*speq);
void push_back(seqlist*speq,Datatype data);
void Del_back(seqlist*speq);
void push_first(seqlist*speq, Datatype data);
void Del_first(seqlist*speq);
void Insert(seqlist*speq, unsigned int pos, Datatype data);
void Delete(seqlist*speq, unsigned int pos);
void printf_Seqlist(seqlist*speq);
int Find_Seqlist(seqlist*speq, Datatype data);
void Remove(seqlist*speq, Datatype data);
void Remove_all(seqlist*speq, Datatype data);
void Bubblesort(seqlist*speq);
void selectsort(seqlist*speq);
int Binarysearch(seqlist*speq, Datatype data);



test.c:
#include "seqlist.h"
void Init_seq(seqlist*Seq_p)
{
    assert(Seq_p);
    memset(Seq_p->array, 0, sizeof(Seq_p->array));
    Seq_p->size = 0;
    return;
}
void push_back(seqlist*speq,Datatype data)
{
    assert(speq);
    if (speq->size > MAX)
    {
        return;
    }
    speq->array[speq->size] = data;
    speq->size++;
}
void Del_back(seqlist*speq)
{
    assert(speq);
    speq->size--;
}
void push_first(seqlist*speq,Datatype data)
{
    int i = 0;
    if (NULL == speq || speq->size >= MAX)
    {
        return;
    }
    for (i = speq->size - 1; i >= 0; i--)
    {
        speq->array[i+1] = speq->array[i];
    }
    speq->array[0] = data;
    speq->size++;
}
void Del_first(seqlist*speq)
{
    int i = 0;
    assert(speq);
    for (i = 0; i < speq->size - 1; i++)
    {
        speq->array[i] = speq->array[i + 1];
    }
    speq->size--;
}
void Insert(seqlist*speq, unsigned int pos, Datatype data)
{
    int i = 0;
    if (NULL == speq || speq->size == MAX)
    {
        exit(0);
    }
    for (i = speq->size-1; i >= pos; i--)
    {
        speq->array[i + 1] = speq->array[i];
    }
    speq->array[pos] = data;
    speq->size++;
}
void Delete(seqlist*speq, unsigned int pos)
{
    int i = 0;
    if (NULL == speq || speq->size == MAX)
    {
        exit(0);
    }
    for (i = pos; i < speq->size-1; i++)
    {
        speq->array[i] = speq->array[i+1];
    }
    speq->size--;
}
void printf_Seqlist(seqlist*speq)
{
    int i = 0;
    assert(speq);
    for (i = 0; i < speq->size; i++)
    {
        printf("%d",speq->array[i]);
    }
    printf("\n");
}
int Find_Seqlist(seqlist*speq, Datatype data)
{
    int i = 0;
    assert(speq);
    for (i = 0; i < speq->size; i++)
    {
        if (speq->array[i] == data)
        {
            return i;
        }
    }
    return -1;
}
void Remove(seqlist*speq, Datatype data)
{
    int i = 0;
    assert(speq);
    i = Find_Seqlist(speq, data);
    if (-1 == i)
    {
        return;
    }
    Delete(speq, i);
}
void Remove_all(seqlist*speq, Datatype data)
{
    int i = 0;
    assert(speq);
    while (1)
    {
        i = Find_Seqlist(speq, data);
        if (-1 == i)
        {
            return;
        }
        Delete(speq, i);        //  while 中直接 Remove(speq, data); 错误  Remove函数中的return 只结束remove函数不可直接结束removeall函数 自己已测试 。
    }
}
static void swap(int * x, int * y)
{
    *x ^= *y;
    *y ^= *x;
    *x ^= *y;
}
void Bubblesort(seqlist*speq)
{
    int i = 0, j = 0;
    int k = 0;
    assert(speq);
    for (i = 0; i < speq->size - 1; i++)
    {
        for (j = 0; j < speq->size-1-i; j++)
        {
            if (speq->array[j]>speq->array[j + 1])
            {
                swap(&speq->array[j], speq->array[j + 1]);
                k = 1;
            }
        }
        if (0 == k)
        {
            return;
        }
    }
}
void selectsort(seqlist*speq)
{
    int i = 0, j = 0, k = 0;
    int maxpos = 0;
    assert(speq);
    for (i = 0; i < speq->size - 1; i++)
    {
        maxpos = 0;
        for (j = 1; j < speq->size - i; j++)
        {
            if (speq->array[maxpos] < speq->array[j])
            {
                maxpos = j;
                k = 1;
            }
        }
        if (0 == k)
        {
            return;
        }
        else
        {
            if (maxpos != speq->size - 1 - i)
            {
                swap(&speq->array[maxpos], &speq->array[speq->size - 1 - i]);  // 自己跟自己亦或会变为0
            }
        }
    }
}
int Binarysearch(seqlist*speq, Datatype data)
{
    int mid = 0;
    int left = 0, right = 0;
    assert(speq);
    left = 0;
    right = speq->size-1;
    mid = (speq->size) / 2;
    selectsort(speq);
    while (left<=right)
    {
        if (data == speq->array[mid])
        {
            return mid;
        }
        else if(data > speq->array[mid])
        {
            left = mid;
            mid = mid + (right - mid) / 2+1;
        }
        else
        {
            right = mid;
            mid = left + (mid - left) / 2+1;
        }
    }
    return -1;
}


main.c：
#include "seqlist.h"
void fun1(seqlist *speq)
{
    int ret = 0;
     Init_seq(speq);
     push_back(speq, 1);
     push_back(speq, 2);
     push_back(speq, 3);
     push_back(speq, 3);
     push_back(speq, 4);
     push_back(speq, 5);
     push_back(speq, 6);
     Del_back(speq);
     push_first(speq, 3);
     push_first(speq, 10);
     Del_first(speq);
    Insert(speq, 4, 8);
    Delete(speq, 4);
    printf_Seqlist(speq);
    Find_Seqlist(speq, 3);
    Remove(speq, 3);
    printf_Seqlist(speq);
    Remove_all(speq, 3);
    printf_Seqlist(speq);
    Bubblesort(speq);
    printf_Seqlist(speq);
    selectsort(speq);
    printf_Seqlist(speq);
    ret=Binarysearch(speq, 5);
    printf("%d", ret);
}
int main()
{
    seqlist seq;
    fun1(&seq);
    system("pause");
    return 0;
}