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;
}