静态数组顺序表之二

  在上次的博客中完成了静态顺序表的初始化 、尾插 、尾删、 头插 、头删 、读任意位置元素 、修改任意位置元素 、查找指定元素值的下标 以及在任意位置插入元素。
这篇博客将介绍以下几种操作：
1. 删除指定值第一个值
2. 删除指定值所有值
3.获取顺序表中元素个数
4.判断顺序表是否是空表
5.冒泡排序
6.利用回调函数的冒泡排序
7.查找排序
8.二分查找
9.销毁顺序表

以下是实现代码：

SeqList.h

#pragma once     //防止头文件重复包含

#include <stddef.h> 

#define SeqListMaxNum 1000    //数组最大元素个数

typedef char SeqListType;    //重定义类型
typedef struct SeqList
{
    SeqListType SeqListArr[SeqListMaxNum];
    size_t size;      //元素个数
}SeqList;

void SeqListInit(SeqList* seq);       //初始化顺序表
void SeqListPrint(SeqList* seq, char* ch);      //打印顺序表

void SeqListRemove(SeqList* seq, SeqListType to_delete);          //删除指定值的第一个
void SeqListRemoveAll(SeqList* seq, SeqListType to_delete);          //删除指定值的所有值

size_t SeqListSize(SeqList* seq);                  //获取顺序表中元素个数
int SeqListEmpty(SeqList* seq);                    //判断顺序表是否是空表

void SeqListBubbleSort(SeqList* seq);           //冒泡排序
void SeqListBubbleSortEx(SeqList* seq, int(*cmp)(SeqListType, SeqListType));       //利用回调函数的冒泡排序

void SeqListSelectSort(SeqList* seq);         //查找排序
size_t SeqListBinarySearch(SeqList* seq, SeqListType value);           //二分查找

void SeqListDestroy(SeqList* seq);          //销毁顺序表

SeqList.c

#include "SeqList.h"
#include <stdio.h>
#include <assert.h>

//初始化顺序表
void SeqListInit(SeqList* seq)
{
    assert(seq);
    seq->size = 0;
}

//打印顺序表
void SeqListPrint(SeqList* seq, char* ch)
{
    assert(seq);
    int i = 0;
    printf("%s\n", ch);
    for (i = 0; i < seq->size; i++)
    {
        printf("下标为%d的元素是：[%c]\n",i,seq->SeqListArr[i]);
    }
    printf("size = %ld\n\n", seq->size);
}

//删除指定值的第一个
void SeqListRemove(SeqList *seq, SeqListType to_delete)
{
    assert(seq);
    if (seq->size == 0)
    {
        printf("顺序表为空表，无法删除！\n");
        return;
    }
    size_t pos = SeqListGetpos(seq,to_delete);
    if (pos == (size_t)-1)
    {
        return;
    }
    SeqListPopPosition(seq, pos);
}

//删除指定值的所有值
void SeqListRemoveAll(SeqList *seq, SeqListType to_delete)
{
    assert(seq);
    if (seq->size == 0)
    {
        printf("顺序表是空表，无法删除！\n");
        return;
    }
    while (1)
    {
        size_t pos = SeqListGetpos(seq, to_delete);
        if (pos == (size_t)-1)
        {
            return;
        }
        SeqListPopPosition(seq, pos);
    }
    return;
}

//获取顺序表中元素个数
size_t SeqListSize(SeqList* seq)
{
    assert(seq);
    return seq->size;
}

//判断顺序表是否是空表
int SeqListEmpty(SeqList* seq)
{
    assert(seq);
    return seq->size == 0 ? 1 : 0;
}


static void swap(SeqListType* a, SeqListType* b)
{
    assert(a);
    assert(b);
    SeqListType tmp = *a;
    *a = *b;
    *b = tmp;
    return;
}
//冒泡排序
void SeqListBubbleSort(SeqList* seq)
{
    assert(seq);
    size_t count = 0;
    for (; count < seq->size - 1; ++count)
    {
        size_t flag = 0;
        size_t cur = 0;
        for (cur = 0; cur < seq->size - 1 - count; ++cur)
        {
            if (seq->SeqListArr[cur] > seq->SeqListArr[cur + 1])
            {
                flag = 1;
                swap(&seq->SeqListArr[cur], &seq->SeqListArr[cur + 1]);
            }
        }
        if (flag == 0)
        {
            break;
        }
    }
}

//利用回调函数的冒泡排序
void SeqListBubbleSortEx(SeqList* seq, int(*cmp)(SeqListType, SeqListType))
{
    assert(seq);
    size_t count = 0;
    for (; count < seq->size - 1; ++count)
    {
        int flag = 0;
        size_t cur = 0;
        for (cur = 0; cur < seq->size - 1 - count; ++cur)
        {
            if (cmp(seq->SeqListArr[cur], seq->SeqListArr[cur + 1])>0)
            {
                flag = 1;
                swap(&seq->SeqListArr[cur], &seq->SeqListArr[cur + 1]);
            }
        }
        if (flag == 0)
        {
            break;
        }
    }
}

//查找排序
void SeqListSelectSort(SeqList* seq)
{
    assert(seq);
    size_t min_pos = 0;
    for (; min_pos < seq->size; ++min_pos)
    {
        size_t cur = min_pos;
        for (; cur < seq->size; ++cur)
        {
            if (seq->SeqListArr[cur] < seq->SeqListArr[min_pos])
            {
                swap(&seq->SeqListArr[cur], &seq->SeqListArr[min_pos]);
            }
        }
    }
    return;
}

//二分查找
size_t SeqListBinarySearch(SeqList* seq, SeqListType value)
{
    assert(seq);
    size_t start = 0;
    size_t end = seq->size;
    while (start < end)
    {
        size_t mid = start + (end - start) / 2;
        if (value > seq->SeqListArr[mid])
        {
            start = mid + 1;
        }
        else if (value < seq->SeqListArr[mid])
        {
            end = mid;
        }
        else
        {
            return mid;
        }
    }
    return (size_t)-1;
}

//销毁顺序表
void SeqListDestroy(SeqList* seq)
{
    assert(seq);
    seq->size = 0;
    return;
}

Test.c

//以下是测试代码
#include "SeqList.h"
#include <stdio.h>
#include <windows.h>

//测试删除指定值的第一个
void TestSeqListRemove()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListRemove(&seq, 'a');
    SeqListPrint(&seq, "*****尝试在空表中删除*****");
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'b');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'd');
    SeqListPushEnd(&seq, 'e');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'c');
    SeqListRemove(&seq, 'c');
    SeqListPrint(&seq, "*****删除顺序表中指定元素的第一个*****");
}

//测试删除指定值的所有值
void TestSeqListRemoveAll()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListRemoveAll(&seq, 'a');
    SeqListPrint(&seq, "*****尝试在空表中删除*****");
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'b');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'd');
    SeqListPushEnd(&seq, 'e');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'c');
    SeqListRemoveAll(&seq, 'c');
    SeqListPrint(&seq, "*****删除顺序表中指定元素的所有值*****");
}

//测试获取顺序表中元素个数
void TestSeqListSize()
{
    SeqList seq;
    SeqListInit(&seq);
    size_t count = SeqListSize(&seq);
    printf("count = %lu\n", count);
    SeqListPrint(&seq, "*****统计空表中元素个数*****");
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'b');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'd');
    SeqListPushEnd(&seq, 'e');
    size_t count1 = SeqListSize(&seq);
    printf("count = %lu\n", count1);
    SeqListPrint(&seq, "*****统计顺序表中元素个数*****");
}

//测试判断顺序表是否是空表
void TestSeqListEmpty()
{
    SeqList seq;
    SeqListInit(&seq);
    int flag = SeqListEmpty(&seq);
    if (flag == 0)
    {
        printf("该顺序表不是空表！\n");
    }
    else
    {
        printf("该顺序表是空表！\n");
    }
    SeqListPrint(&seq, "*****顺序表是空表*****");
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'b');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'd');
    flag = SeqListEmpty(&seq);
    if (flag == 0)
    {
        printf("该顺序表不是空表！\n");
    }
    else
    {
        printf("该顺序表是空表！\n");
    }
    SeqListPrint(&seq, "*****顺序表不是空表情况*****");
}

//测试冒泡排序
void TestSeqListBubbleSort()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'd');
    SeqListPushEnd(&seq, 'f');
    SeqListPushEnd(&seq, 'e');
    SeqListPushEnd(&seq, 'i');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'b');
    SeqListPrint(&seq, "*****对顺序表进行冒泡排序前*****");
    SeqListBubbleSort(&seq);
    SeqListPrint(&seq, "*****对顺序表进行冒泡排序后*****");
}

//测试利用回调函数的冒泡排序
int int_cmp(const SeqListType a, const SeqListType b)            //从小到大顺序排序
{
    return a > b;
}
int int_cmp1(const SeqListType a, const SeqListType b)            //从大到小顺序排序
{
    return a < b;
}
void TestSeqListBubbleSortEx()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'd');
    SeqListPushEnd(&seq, 'f');
    SeqListPushEnd(&seq, 'e');
    SeqListPushEnd(&seq, 'i');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'b');
    SeqListPrint(&seq, "*****对顺序表进行冒泡排序前*****");
    SeqListBubbleSortEx(&seq, int_cmp);
    SeqListPrint(&seq, "*****对顺序表进行从小到大排序*****");
    SeqListBubbleSortEx(&seq, int_cmp1);
    SeqListPrint(&seq, "*****对顺序表进行从大到小排序*****");
}

//测试查找排序
void TestSeqListSelectSort()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'd');
    SeqListPushEnd(&seq, 'f');
    SeqListPushEnd(&seq, 'e');
    SeqListPushEnd(&seq, 'i');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'b');
    SeqListPrint(&seq, "*****对顺序表进行查找排序前*****");
    SeqListSelectSort(&seq);
    SeqListPrint(&seq, "*****对顺序表进行查找排序后*****");
}

//测试二分查找
void TestSeqListBinarySearch()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'd');
    SeqListPushEnd(&seq, 'f');
    SeqListPushEnd(&seq, 'e');
    SeqListPushEnd(&seq, 'i');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'b');
    size_t pos = SeqListBinarySearch(&seq, 'o');
    SeqListPrint(&seq, "*****查找一个不存在的元素o*****");
    printf("o expect -1:%lu\n", pos);
    pos = SeqListBinarySearch(&seq, 'd');
    SeqListPrint(&seq, "*****查找一个存在的元素d*****");
    printf("d expect 1:%lu\n", pos);
}

//测试销毁顺序表
void TestSeqListDestroy()
{
    SeqList seq;
    SeqListInit(&seq);
    SeqListPushEnd(&seq, 'a');
    SeqListPushEnd(&seq, 'b');
    SeqListPushEnd(&seq, 'c');
    SeqListPushEnd(&seq, 'd');
    SeqListPrint(&seq, "*****销毁前*****");
    SeqListDestroy(&seq);
    SeqListPrint(&seq, "*****销毁后*****");
}

int main()
{
    TestSeqListRemove();
    TestSeqListRemoveAll();
    TestSeqListSize();
    TestSeqListEmpty();
    TestSeqListBubbleSort();
    TestSeqListBubbleSortEx();
    TestSeqListSelectSort();
    TestSeqListBinarySearch();
    TestSeqListDestroy();
    system("pause");
    return 0;
}

结果如下：

1. 删除指定值第一个值

2. 删除指定值所有值

3.获取顺序表中元素个数

4.判断顺序表是否是空表

5.冒泡排序

6.利用回调函数的冒泡排序

7.查找排序

8.二分查找

9.销毁顺序表

以上内容接上篇博客，如有疑问可对比
http://blog.csdn.net/adorable_/article/details/78720919