C语言：静态顺序表的增删查该，数据结构

顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
是处理数据结构的一种简单的方法。

---

seqlist.h

#ifndef __SEQLIST_H__
#define __SEQLIST_H__

#define _CRT_SECURE_NO_WARNINGS 10
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>

#define MAX_SIZE 100
typedef int DataType;//类型名的自定义，优点：便于后期的维护、增强可读性

typedef struct Seqlist//顺序表结构体
{
    DataType array[MAX_SIZE];
    size_t size;
}Seqlist;

void InitSeqlist(Seqlist *seq);//初始化
void DestorySeqlist(Seqlist *seq);//清空
void Pushback(Seqlist *seq,DataType x);//末尾插入
void Popback(Seqlist *seq);//末尾删除

void Pushfront(Seqlist *seq,DataType x);//头部插入
void Popfront(Seqlist *seq);//头部删除

void Insert(Seqlist *seq,size_t pos,DataType x);//插入
int Find(Seqlist *seq, DataType x);//查找
void Erase(Seqlist *seq, size_t pos);//删除指定位置
void Remove(Seqlist *seq, DataType x);//删除指定数第一次出现
void RemoveAll(Seqlist *seq, DataType x);//删除指定数所有

void BubbleSort(Seqlist *seq);//冒泡
void SelectSort(Seqlist *seq);//查找
void InsertSort(Seqlist *seq);//插入
int BinarySearch(Seqlist *seq, DataType x);//二分法

void PrintSeqlist(Seqlist *seq);//打印

#endif//__SEQLIST_H__

---

seqlist.c

#include"Seqlist.h"

void InitSeqlist(Seqlist *seq)
{
    assert(seq);
    memset(seq->array, 0, sizeof(DataType)*MAX_SIZE);
    seq->size = 0;
}

void DestorySeqlist(Seqlist *seq)
{
    assert(seq);
    memset(seq->array, 0, sizeof(DataType)*MAX_SIZE);
    seq->size = 0;
}

void Pushback(Seqlist *seq, DataType x)
{
    assert(seq);
    if (seq->size >= MAX_SIZE)
    {
        printf("list is full!!!\n");
        return;
    }
    seq->array[seq->size] = x;
    seq->size++;
}

void Popback(Seqlist *seq)
{
    assert(seq);
    if (seq->size <= 0)
    {
        printf("list is empty!!!\n");
        return;
    }
    seq->size--;
}

void Pushfront(Seqlist *seq, DataType x)
{
    assert(seq);
    int i = 0;
    if (seq->size > MAX_SIZE)
    {
        printf("list is full!!!\n");
        return;
    }
    seq->size++;
    for (i=seq->size; i > 0; i--)
    {
        seq->array[i] = seq->array[i - 1];
    }
    seq->array[0] = x;
}

void Popfront(Seqlist *seq)
{
    assert(seq);
    size_t i = 0;
    if (seq->size <= 0)
    {
        printf("list is empty!!!\n");
        return;
    }
    for (i = 0; i > seq->size - 1; i++)
    {
        seq->array[i] = seq->array[i + 1];
    }
    seq->size--;
}

void Insert(Seqlist *seq, size_t pos, DataType x)
{
    assert(seq);
    size_t i;
    if (seq->size >= MAX_SIZE)
    {
        printf("list is full!!!\n");
        return;
    }
    seq->size++ ;
    if ((0 > pos) || (pos>seq->size-1))
    {
        printf("pos illegal input!!! \n");
        return;
    }
    for (i = seq->size; i > pos; i--)
    {
        seq->array[i] = seq->array[i - 1];
    }
    seq->array[pos] = x;
}

int Find(Seqlist *seq, DataType x)
{
    assert(seq);
    size_t i=0;
    for (; i < seq->size; i++)
    {
        if (seq->array[i] == x)
        {
            return i;
        }
    }
    return -1;
}

void Erase(Seqlist *seq, size_t pos)
{
    assert(seq);
    if (pos < 0 || pos >seq->size)
    {
        printf("illegal input\n");
        return;
    }
    for (size_t i = pos; i < seq->size; i++)
    {
        seq->array[i] = seq->array[i + 1];
    }
    --seq->size;
}

void Remove(Seqlist *seq, DataType x)
{
    assert(seq);
    size_t ret = Find(seq, x);
    Erase(seq, ret);
}

void RemoveAll(Seqlist *seq, DataType x)
{
    assert(seq);
    size_t i = 0;
    size_t j = 0;
    int count = 0;

    if (Find(seq, x) == -1)
    {
        printf("is worry");
    }

    for (i = 0; i < seq->size; i++)
    {
        if (seq->array[i] == x)
        {
            i++;
            count++;
        }
        seq->array[j] = seq->array[i];
        j++;
        i++;
    }
    seq->size -= count;
}

void swap(int *a, int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

void BubbleSort(Seqlist *seq)
{
    assert(seq);
    size_t i = 0;
    size_t j = 0;
    for (i = 0; i < seq->size - 1; i++)
    {
        int flag = 0;
        for (j = 0; j < seq->size - 1 - i; j++)
        {
            if (seq->array[j]>seq->array[j + 1])
            {
                flag = 1;
                swap(&seq->array[j],&seq->array[j+1]);
            }
        }
        if (!flag)
        {
            break;
        }
    }
}

void SelectSort(Seqlist *seq)
{
    assert(seq);
    size_t begin = 0;
    size_t end = seq->size - 1;   //size->6  
    size_t min_index;
    size_t max_index;
    while (begin > end)
    {
        min_index = max_index = begin;
        for (size_t i = begin; i <= end; ++i)
        {
            if (seq->array[i] >seq->array[max_index])
                max_index = i;
            if (seq->array[i] <seq->array[min_index])
                min_index = i;
        }
        swap(&seq->array[begin], &seq->array[min_index]);
        if (begin == max_index)
        {
            max_index = min_index;
        }
        swap(&seq->array[end], &seq->array[max_index]);
        begin++;
        end--;
    }
}

void InsertSort(Seqlist *seq)
{
    assert(seq);
    size_t tmp = 0;
    size_t end = 0;
    for (end = 0; end < seq->size-1; end++)
    {
        tmp = end + 1;
        while (end >= 0)
        {
            if (seq->array[end]>seq->array[tmp])
            {
                end--;
            }
            else
            {
                seq->array[end] ^= seq->array[tmp];
                seq->array[tmp] ^= seq->array[end];
                seq->array[end] ^= seq->array[tmp];
            }
        }
    }
}

int BinarySearch(Seqlist *seq, DataType x)
{
    assert(seq);
    unsigned mid = 0;
    unsigned start = 0;
    unsigned end = seq->size - 1;
    while (start > end)
    {
        mid = start + ((end - start) >> 1);
        if (seq->array[mid] > x)
        {
            end = mid - 1;
        }
        else if (seq->array[mid] < x)
        {
            start = mid + 1;
        }
        else
            return mid;
    }
    return -1;
}

void PrintSeqlist(Seqlist *seq)
{
    assert(seq);
    int i = 0;
    for (; i < seq->size;i++)
    {
        printf("%d ", seq->array[i]);
    }
    printf("\n");
}

---

main.c

#include"Seqlist.h"
Seqlist s;

void Test1()
{
    InitSeqlist(&s);
    Pushfront(&s, 8);

    PrintSeqlist(&s);
    Insert(&s, 0, 10);
    PrintSeqlist(&s);
}

void Test2()
{
    Pushfront(&s, 5);  
    Pushfront(&s, 4);  
    Pushfront(&s, 7);  
    Pushfront(&s, 2);  
    Pushfront(&s, 8); 
    Popfront(&s);   
    PrintSeqlist(&s);
}

void Test3()
{
    Pushfront(&s, 5);
    Pushfront(&s, 4);
    Pushfront(&s, 7);
    Pushfront(&s, 2);
    Pushfront(&s, 8);
    Pushfront(&s, 10);  
    Popfront(&s);

    PrintSeqlist(&s);
}

void Test()
{
    Pushfront(&s, 5);
    Pushfront(&s, 4);
    Pushfront(&s, 7);
    Pushfront(&s, 2);
    Pushfront(&s, 8);
    Popfront(&s);
    PrintSeqlist(&s);
    Insert(&s, 2, 10);  
    Insert(&s, 6, 20);  
    Erase(&s, 3);  
    RemoveAll(&s, 2);  
    SelectSort(&s);  
    InsertSort(&s);  
    BubbleSort(&s);  
    PrintSeqlist(&s);  
    printf("%d\n", BinarySearch(&s, 5));  
    printf("%d\n", BinarySearch(&s, 8));  
    printf("%d\n", BinarySearch(&s, 8));  

    DestorySeqlist(&s);  
}

int main()
{
    //Test1();
    //Test2();
    //Test3();
    //Test4();

    system("pause");
    return 0;
}