1、用于存放声明的头文件
#ifndef __SEP__LIST__
#define __SEP__LIST__
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#define MAX_SIZE 10 //使顺序表中可以插入的数据是可以很方便调整的
typedef int DataType;
typedef struct SeqList
{
DataType arr[MAX_SIZE]; //保存顺序表的数据
size_t size; //顺序表中元素的个数
}SeqList,*PSeqList;
//所有函数中出现的某个元素的位置,都指的是它是顺序表第几个元素,而不是它在顺序表中的下标值
// 初始化顺序表
void InitSeqList(SeqList* seqList);
// 在顺序表的尾部插入元素data
void PushBack(SeqList* seqList, DataType data);
// 将顺序表尾部的元素抛出
void PopBack(SeqList* seqList);
// 顺序表的头部插入元素data
void PushFront(SeqList* pSeqList, DataType data);
// 顺序表的头部的元素删除
void PopFront(SeqList* pSeqList);
// 顺序表中查找数据data,返回该元素在顺序表中的位置
int Find(SeqList* pSeqList, DataType data);
// 在顺序表的ipos位置上插入元素data
void Insert(SeqList* pSeqList, size_t pos, DataType data);
// 删除顺序表pos位置上的元素
void Erase(SeqList* pSeqList, size_t pos);
// 移除顺序表中的元素data
void Remove(SeqList* pSeqList, DataType data);
// 移除顺序表中的所有值为data的元素
void RemoveAll(SeqList* pSeqList, DataType data);
// 选择排序
void SelectSort(SeqList* pSeqList);
// 冒泡排序
void BorbbleSort(SeqList* pSeqList);
// 查找已序顺序表中的元素data
int BinarySearch(SeqList* pSeqList, DataType data);
// 打印顺序表
void PrintSeqList(SeqList* pSeqList);
#endif
2、用于实现声明的.c文件
#include "Seq_List.h"
void InitSeqList(SeqList* seqList)
{
assert(seqList);
memset(seqList, 0, sizeof(DataType)*MAX_SIZE);
seqList->size = 0; //使最开始的数据是从顺序表的第一个位置开始插入的
}
void PushBack(SeqList* seqList, DataType data)
{
assert(seqList);
if (MAX_SIZE == seqList->size)
{
printf("顺序表已满,不能再插入数据。\n");
return;
}
seqList->arr[seqList->size] = data;
seqList->size++;
}
void PopBack(SeqList* seqList)
{
assert(seqList);
if (0 == seqList->size)
{
printf("顺序表是空的,不能抛出数据。\n");
return;
}
seqList->size--; //虽然此时顺序表的存储的数据元素并没有被真是的删除,但是因为顺序表中此时的元素个数少了一个,
//使最后的那个元素相当于无效元素,这就达到了删除的效果
}
void PushFront(SeqList* pSeqList, DataType data)
{
size_t index = pSeqList->size;
assert(pSeqList);
if (MAX_SIZE == pSeqList->size)
{
printf("顺序表已满,不能插入数据。\n");
return;
}
for (; index > 0; index--)
{
pSeqList->arr[index] = pSeqList->arr[index - 1];
//因为是从顺序表的第一个位置开始插入元素,因此顺序表中原有的所有元素都要向后挪一个位置,避免被覆盖
}
pSeqList->arr[index] = data;
pSeqList->size++;
}
void PopFront(SeqList* pSeqList)
{
size_t index = 1;
assert(pSeqList);
if (0 == pSeqList->size)
{
printf("顺序表是空的,不能抛出数据。\n");
return;
}
for (; index < pSeqList->size; index++)
{
pSeqList->arr[index-1] = pSeqList->arr[index];
//此处的index初始化为1,并且在操作时是对index-1,而没有执行index+1操作是因为害怕数组下标越界
}
pSeqList->size--;
}
int Find(SeqList* pSeqList, DataType data)
{
size_t index = 0;
assert(pSeqList);
for (; index < pSeqList->size; index ++ )
{
if (pSeqList->arr[index] == data)
{
return index + 1; //位置应该是从1开始的,不会存在从0开始的位置,所以位置应该是下标加1
}
}
return -1; //位置不会是负数,所以当返回为负数时,就可以知道顺序表中不存在要找的数据
}
void Insert(SeqList* pSeqList, size_t pos, DataType data)
{
size_t index = pSeqList->size;
assert(pSeqList);
if (pos > pSeqList->size)
{
printf("插入位置不合法。");
//要保证数据元素插入后所有元素都是连续的,否则不能叫作顺序表
return;
}
if (MAX_SIZE == pSeqList->size)
{
printf("顺序表已满,不能插入数据。\n");
return;
}
for (; index >= pos; index--)
{
pSeqList->arr[index] = pSeqList->arr[index - 1];
//把插入位置及其后面的元素,整体向后挪一个元素的位置,用来存放插入的元素
}
pSeqList->arr[index] = data;
pSeqList->size++;
}
void Erase(SeqList* pSeqList, size_t pos)
{
size_t index = pos-1;
assert(pSeqList);
if (pos > pSeqList->size)
{
printf("该位置没有存储数据元素。");
return;
//若果此处不这样处理,下面的pSeqList->size-1会溢出
}
for (; index < pSeqList->size-1; index++)
{
pSeqList->arr[index] = pSeqList->arr[index + 1];
//此时不会发生数组下标越界,因为index最多到size-2,那么index+1最多到size-1,不会越界
}
pSeqList->size --;
//当pos == pSeqList->size时,不会进入循环,但这样也不会出错,因为它后面没有元素了,那么就不需要经过循环把元素
//前移,直接把元素个数减1即可
}
void Remove(SeqList* pSeqList, DataType data)
{
size_t index = 0;
size_t temp = 0;
assert(pSeqList);
for (; index < pSeqList->size; index++)
{
if (pSeqList->arr[index] == data)
{
for (temp = index; temp < pSeqList->size - 1; temp++)
{
pSeqList->arr[temp] = pSeqList->arr[temp + 1];
}
//当在顺序表中找到了该数时,就把该数之后的所有元素全部向前挪一个元素的位置,把原数据覆盖即可达到移除的目的
pSeqList->size--;
//当要删除的数在顺序表中最后一个位置时,index == pSeqList->size-1,因此不会进入循环,但因为该数后面就
//没有数据了,所以此时的移除方法是直接把该顺序表的元素个数减1,使该元素成为无效元素即可达到删除的目的
return;
}
}
}
void RemoveAll(SeqList* pSeqList, DataType data)
{
size_t index = 0;
size_t rem = 0;
assert(pSeqList);
for (; index < pSeqList->size; index++)
{
if (pSeqList->arr[index] == data)
{
for (rem = index; rem < pSeqList->size - 1; rem++) //可以考虑是否可以递归
{
pSeqList->arr[rem] = pSeqList->arr[rem + 1];
}
//当在顺序表中找到了该数时,就把该数之后的所有元素全部向前挪一个元素的位置,把原数据覆盖即可达到移除的目的
pSeqList->size--;
index--;
//index--是因为删除一个元素之后,后面的元素都会前移,那么可能前移元素中的最前面的元素和我们要删除的元素
//的值是一样的,而此时index++了,它的值是前移元素中的第二个元素的值,因此要给index--,使它的值为前移元素
//中的第一个元素的值
//因为这个函数是要删除顺序表中所有的值为data的元素,所以在这儿不能直接删除一个就返回了,而是知道遍历所有
//元素,删除对应的元素,才会返回
}
}
}
void Swap(int *num1, int *num2)
{
int temp = *num1; //变量是在需要交换两个元素位置时充当临时变量的,因为也不知道元素的符号,所以用int类型而非size_t
*num1 = *num2;
*num2 = temp;
}
void SelectSort(PSeqList pSeqList)
{
size_t num = 0;
size_t index = 0;
size_t end = pSeqList->size;
assert(pSeqList);
for (; num < pSeqList->size / 2; num++)
{
size_t min = num;
size_t max = num;
for (index = num + 1; index < end; index++)
{
min = pSeqList->arr[min] < pSeqList->arr[index] ? min : index;
max = pSeqList->arr[max] > pSeqList->arr[index] ? max : index;
//每次比较两个元素,把比较完成后最小和最大的元素的下标保存起来,下一次比较时比较的两个对象分别是保存的下
//标对应的元素和还没有进行比较的所有元素中最前面的那一个元素(当然,也可以是未进行比较的所有元素中的任意一个)
}
Swap(&pSeqList->arr[min], &pSeqList->arr[num]);
Swap(&pSeqList->arr[max], &pSeqList->arr[--end]); //注意这儿的--end是为了使下一次循环里的比较范围缩小,
//同时也为了这儿取得是正确的下标值
//把最小和最大的元素交换到对应的位置去
}
}
void BorbbleSort(PSeqList pSeqList) //排序为从小到大
{
size_t index = 0;
size_t num = 0;
int flag = 1;
assert(pSeqList);
while (flag == 1) //对冒泡排序的优化,当某一趟排序时发现没有发生交换的情况,说明此时已经排序成功,那么就可以
//不用再进入下一趟排序,直接跳出循环,执行下面的操作
{
for (; num < pSeqList->size - 1; num++) //思考冒泡排序两个循环的次数个应该各是多少
{
for (index = 0; index < pSeqList->size - num - 1; index++) //不减1可能会造成越界访问
{
if (pSeqList->pData[index]>pSeqList->pData[index + 1])
{
Swap(&pSeqList->pData[index], &pSeqList->pData[index + 1]);
//每次比较相邻两个元素,若前面的元素大于后面的,则交换两个元素的位置
flag = 1;
}
}
}
}
}
int BinarySearch(SeqList* pSeqList, DataType data) //二分法在顺序表中找一个数
{
int left = 0;
int right = pSeqList->size - 1;
assert(pSeqList);
if (pSeqList->size == 0)
{
return -1;
//因为此时顺序表里没有数据,而pSeqList->size是无符号整型,减1的话出来的值是一个非常大的值,所以为了
//保证函数的正确性,在顺序表无数据时,直接返回
}
while (left <= right) //注意right的取值对此处是用:left <= right还是left < right的影响
{
int mid = left + (right-left) / 2; //没有写成mid = (left + right) / 2是因为害怕怕两数直接相加会溢出
if (pSeqList->arr[mid] == data)
{
return mid;
}
else if (pSeqList->arr[mid] > data)
{
right = mid - 1; //因为排序的函数是把顺序表的元素由小到大排列的
}
else
{
left = mid + 1;
}
}
return -1; //当没有找到要查找的数时,返回一个负值,以声明要查找的元素在顺序表中不存在,因为要是找到了,
//返回一个数的位置,那么不会小于0
}
void PrintSeqList(SeqList* pSeqList)
{
size_t index = 0;
for (; index < pSeqList->size; index++)
{
printf("%d ", pSeqList->arr[index]);
}
printf("\n");
}
3、用于测试函数正确性的Test.c文件
#include "Seq_List.h"
SeqList seqList;
//测试尾插与尾删函数
void TestFun1()
{
InitSeqList(&seqList);
PushBack(&seqList, 1);
PushBack(&seqList, 2);
PushBack(&seqList, 3);
PushBack(&seqList, 4);
PrintSeqList(&seqList);
PopBack(&seqList);
PopBack(&seqList);
PrintSeqList(&seqList);
}
//测试头插与头删函数
void TestFun2()
{
InitSeqList(&seqList);
PushFront(&seqList, 1);
PushFront(&seqList, 2);
PushFront(&seqList, 3);
PushFront(&seqList, 4);
PrintSeqList(&seqList);
PopFront(&seqList);
PopFront(&seqList);
PrintSeqList(&seqList);
}
//测试任意位置查找插入删除函数
void TestFun3()
{
int ret = 0;
InitSeqList(&seqList);
PushFront(&seqList, 1);
PushFront(&seqList, 2);
PushFront(&seqList, 3);
PushFront(&seqList, 4);
ret = Find(&seqList, 4);
Insert(&seqList, 3, 5);
Erase(&seqList, 5);
printf("%d\n", ret);
PrintSeqList(&seqList);
}
//测试移除函数
void TestFun4()
{
InitSeqList(&seqList);
PushFront(&seqList, 1);
PushFront(&seqList, 2);
PushFront(&seqList, 2);
PushFront(&seqList, 4);
PushFront(&seqList, 1);
PushFront(&seqList, 2);
PushFront(&seqList, 2);
PushFront(&seqList, 4);
Remove(&seqList, 2);
PrintSeqList(&seqList);
RemoveAll(&seqList, 2);
PrintSeqList(&seqList);
}
//测试排序与二分查找函数
void TestFun5()
{
int ret = 0;
InitSeqList(&seqList);
PushFront(&seqList, 3);
PushFront(&seqList, 9);
PushFront(&seqList, 1);
PushFront(&seqList, 4);
PushFront(&seqList, 2);
PushFront(&seqList, 8);
PushFront(&seqList, 7);
PushFront(&seqList, 0);
SelectSort(&seqList);
//BorbbleSort(&seqList);
ret = BinarySearch(&seqList, 5);
printf("%d\n", ret);
PrintSeqList(&seqList);
}
int main()
{
//TestFun1();
//TestFun2();
//TestFun3();
//TestFun4();
TestFun5();
system("pause");
return 0;
}