C语言实现顺序表

头文件部分：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int DataType;
#define MaxSize 10

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


//打印顺序表的内容
void PrintSeqList(SeqList*seq);

// 初始化顺序表
void InitSeqList(SeqList* seq);

// 在顺序表的尾部插入值为data的元素
void PushBack(SeqList* pSeq, DataType data);

// 删除顺序表的最后一个元素
void PopBack(SeqList* pSeq);

// 在顺序表的头部插入值为data的元素
void PushFront(SeqList* pSeq, DataType data);

// 删除顺序表头部元素
void PopFront(SeqList* pSeq);

// 在顺序表中pos位置上插入值为data的元素
void Insert(SeqList* pSeq, size_t pos, DataType data);

// 删除顺序表中pos位置上的元素
void Erase(SeqList* pSeq, size_t pos);

// 在顺序表中查找值为data的元素，找到返回该元素的位置，否则返回-1
int Find(SeqList* pSeq, DataType data);

// 删除顺序表中第一个值为data的元素
void Remove(SeqList* pSeq, DataType data);

// 删除顺序表中所有值为data的元素
void RemoveAll(SeqList* pSeq, DataType data);

// 使用冒泡排序给顺序表中的元素排序
void BubbleSort(SeqList* pSeq);

// 使用选择排序给顺序表中的元素排序
void SelectSort(SeqList* pSeq);

// 使用二分查找在顺序表中查找值为data
int BinarySearch(SeqList* pSeq, DataType data);

函数实现部分：

#include"SeqList.h"

// 打印顺序表的内容
void PrintSeqList(SeqList*seq)
{
    assert(seq);

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

// 初始化顺序表
void InitSeqList(SeqList* seq)
{
    assert(seq);

    int i = 0;
    for (i = 0; i < MaxSize; i++)
    {
        seq->array[i] = 0;
    }
    seq->size = 0;
}

// 在顺序表的尾部插入值为data的元素
void PushBack(SeqList* pSeq, DataType data)
{
    assert(pSeq);

    if (pSeq->size == MaxSize)
    {
        return;
    }

    int i = pSeq->size;
    pSeq->array[i] = data;
    pSeq->size++;
}

// 删除顺序表的最后一个元素
void PopBack(SeqList* pSeq)
{
    assert(pSeq);

    if (pSeq->size == 0)
    {
        return;
    }

    pSeq->size--;
}

// 在顺序表的头部插入值为data的元素
void PushFront(SeqList* pSeq, DataType data)
{
    assert(pSeq);

    if (pSeq->size == MaxSize)
    {
        return;
    }

    int i = 0;
    for (i = pSeq->size; i > 0; i--)
    {
        pSeq->array[i] = pSeq->array[i - 1];
    }
    pSeq->array[i] = data;
    pSeq->size++;
}

// 删除顺序表头部元素
void PopFront(SeqList* pSeq)
{
    assert(pSeq);

    if (pSeq->size == 0)
    {
        return;
    }

    int i = 0;
    for (i = 0; i < pSeq->size; i++)
    {
        pSeq->array[i] = pSeq->array[i + 1];
    }
    pSeq->size--;
}

// 在顺序表中pos位置上插入值为data的元素
void Insert(SeqList* pSeq, size_t pos, DataType data)
{
    assert(pSeq);

    if (pSeq->size == MaxSize||pos>pSeq->size)
    {
        return;
    }

    int i = 0;
    for (i = pSeq->size; i > pos; i--)
    {
        pSeq->array[i] = pSeq->array[i - 1];
    }
    pSeq->array[i] = data;
    pSeq->size++;
}

// 删除顺序表中pos位置上的元素
void Erase(SeqList* pSeq, size_t pos)
{
    assert(pSeq);

    if (pSeq->size == 0 || pos >= pSeq->size)
    {
        return;
    }

    int i = 0;
    for (i = pos; i < pSeq->size; i++)
    {
        pSeq->array[i] = pSeq->array[i + 1];
    }
    pSeq->size--;
}

// 在顺序表中查找值为data的元素，找到返回该元素的位置，否则返回-1
int Find(SeqList* pSeq, DataType data)
{
    assert(pSeq);

    int i = 0;
    for (i = 0; i < pSeq->size; i++)
    {
        if (pSeq->array[i] == data)
            return i;
    }
    return -1;
}

// 删除顺序表中第一个值为data的元素
void Remove(SeqList* pSeq, DataType data)
{
    int pos = Find(pSeq, data);
    if (pos >= 0)
    {
        Erase(pSeq, pos);
    }
    else
        printf("error\n");
}

// 删除顺序表中所有值为data的元素
void RemoveAll(SeqList* pSeq, DataType data)
{
    assert(pSeq);

    int i = 0;
    int count = 0;
    for (i = 0; i < pSeq->size; i++)
    {
        if (pSeq->array[i] == data)
            count++;
        else
            pSeq->array[i - count] = pSeq->array[i];
    }
    pSeq->size -= count;
}

// 使用冒泡排序给顺序表中的元素排序
void BubbleSort(SeqList* pSeq)
{
    assert(pSeq);

    int i = 0, j = 0,flag=0;
    for (i = 0; i < pSeq->size-1; i++)
    {
        for (j = 0; j < pSeq->size - 1 - i; j++)
        {
            if (pSeq->array[j]>pSeq->array[j + 1])
            {
                int temp = pSeq->array[j];
                pSeq->array[j] = pSeq->array[j + 1];
                pSeq->array[j + 1] = temp;
                flag = 1;
            }
        }
        if (!flag)
            return;
    }
}

// 使用选择排序给顺序表中的元素排序
void SelectSort(SeqList* pSeq)
{
    assert(pSeq);

    int i = 0, j = 0;
    for (i = 0; i < pSeq->size - 1; i++)
    {
        for (j = i + 1; j < pSeq->size; j++)
        {
            if (pSeq->array[i]>pSeq->array[j])
            {
                int temp = pSeq->array[j];
                pSeq->array[j] = pSeq->array[i];
                pSeq->array[i] = temp;
            }
        }
    }
}

// 使用二分查找在顺序表中查找值为data
int BinarySearch(SeqList* pSeq, DataType data)
{
    assert(pSeq);

    int left = 0;
    int right = pSeq->size - 1;
    int mid = left + ((right - left) >> 1);
    while (left <= right)
    {
        if (pSeq->array[mid] == data)
        {
            return mid;
        }
        else if (pSeq->array[mid] > data)
        {
            right = mid - 1;
            mid = left + ((right - left) >> 1);
        }
        else
        {
            left = mid + 1;
            mid = left + ((right - left) >> 1);
        }
    }
    return -1;
}

测试部分：

#include"SeqList.h"

void FunTestA()//尾插和尾删测试函数
{
    SeqList seq;
    SeqList*pSeq;
    pSeq = &seq;
    InitSeqList(&seq);
    PushBack(pSeq, 3);
    PushBack(pSeq, 2);
    PushBack(pSeq, 6);
    PushBack(pSeq, 1);
    PushBack(pSeq, 4);
    PrintSeqList(&seq);
    PopBack(pSeq);
    PrintSeqList(&seq);
}

void FunTestB()//头插和头删测试函数
{
    SeqList seq;
    SeqList*pSeq;
    pSeq = &seq;
    InitSeqList(&seq);
    PushFront(pSeq, 3);
    PushFront(pSeq, 2);
    PushFront(pSeq, 6);
    PushFront(pSeq, 1);
    PushFront(pSeq, 4);
    PrintSeqList(&seq);
    PopFront(pSeq);
    PrintSeqList(&seq);
}

void FunTestC()//任意位置插入、删除测试函数
{
    SeqList seq;
    SeqList*pSeq;
    pSeq = &seq;
    InitSeqList(&seq);
    PushFront(pSeq, 3);
    PushFront(pSeq, 2);
    PushFront(pSeq, 6);
    PushFront(pSeq, 1);
    PushFront(pSeq, 4);
    PrintSeqList(&seq);
    Insert(pSeq, 3, 100);
    PrintSeqList(&seq);
    Erase(pSeq, 3);
    PrintSeqList(&seq);
}

void FunTestD()//查找删除、删除全部数据，
{
    SeqList seq;
    SeqList*pSeq;
    pSeq = &seq;
    InitSeqList(&seq);
    PushFront(pSeq, 3);
    PushFront(pSeq, 2);
    PushFront(pSeq, 6);
    PushFront(pSeq, 2);
    PushFront(pSeq, 1);
    PushFront(pSeq, 2);
    PushFront(pSeq, 4);
    PrintSeqList(&seq);
    printf("%d",Find(pSeq, 2));
    Remove(pSeq, 2);
    PrintSeqList(&seq);
    RemoveAll(pSeq, 2);
    PrintSeqList(&seq);
}

void FunTestE()//排序、折半查找测试函数
{
    SeqList seq;
    SeqList*pSeq;
    pSeq = &seq;
    InitSeqList(&seq);
    PushFront(pSeq, 3);
    PushFront(pSeq, 2);
    PushFront(pSeq, 6);
    PushFront(pSeq, 2);
    PushFront(pSeq, 1);
    PushFront(pSeq, 2);
    PushFront(pSeq, 4);
    PrintSeqList(&seq);
    //BubbleSort(pSeq);
    SelectSort(pSeq);
    PrintSeqList(&seq);
    printf("%d\n",BinarySearch(pSeq, 3));
}

int main()
{
    //FunTestA();
    //FunTestB();
    //FunTestC();
    //FunTestD();
    FunTestE();
    system("pause");
    return 0;
}