在上次的博客中完成了静态顺序表的初始化 、尾插 、尾删、 头插 、头删 、读任意位置元素 、修改任意位置元素 、查找指定元素值的下标 以及在任意位置插入元素。
这篇博客将介绍以下几种操作:
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