顺序表基本操作（完整）

Seqlist.h

#define _CRT_SECURE_NO_WARNINGS 1

#pragma once
#include<stddef.h>
#define SeqlistMaxsize 100
typedef char SeqlistType;

typedef struct Seqlist{
	SeqlistType data[SeqlistMaxsize];
	size_t size;
}Seqlist;
void SeqlistInit(Seqlist *seqlist);//初始化

void pushback(Seqlist *seqlist, SeqlistType value);//尾插

void deleteback(Seqlist *seqlist);//尾删

void SeqlistpushFront(Seqlist *seqlist, SeqlistType value);//头插

void Seqlistpopback(Seqlist *seqlist);//头部删除

void SeqlistInsert(Seqlist *seqlist, size_t num, SeqlistType value);//在指定位置插入元素

void SeqlistDelete(Seqlist *seqlist, size_t num);//在指定位置删除元素

SeqlistType SeqListGet(Seqlist* seq, size_t pos, SeqlistType default_value);//在指定位置取出元素

void SeqListSet(Seqlist* seq, size_t pos,	SeqlistType value);//修改指定位置的值

size_t SeqListFind(Seqlist* seq, SeqlistType value);//查找顺序表中指定元素的下标

void SeqListRemove(Seqlist* seq, SeqlistType to_delete);//删除顺序表中指定的值, 如果存在重复元素, 只删除第一个

void SeqListRemoveAll(Seqlist* seq, SeqlistType to_delete);// 删除顺序表中所有的指定的值, 另外要实现一个时间复杂度为 O(N) 的优化版本


size_t SeqListSize(Seqlist* seqlist);//获取顺序表元素个数


int SeqListEmpty(Seqlist* seqlist);//判定顺序表是否为空


void SeqListBubbleSort(Seqlist* seqlist);//冒泡排序



typedef int (*Cmp)(SeqlistType a, SeqlistType b);
void SeqListBubbleSortEx(Seqlist* seqlist, Cmp cmp);//回调函数冒泡排序

Seqlist.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "seqlist.h"
#include<stdio.h>
#define PrintHeader printf("\n=================%s=================\n",__FUNCTION__)
void SeqlistInit(Seqlist *seqlist)
{
	if (seqlist == NULL)
	{
		return;
	}
	seqlist->size = 0;
	seqlist->data[seqlist->size] = '\0';
}
void pushback(Seqlist *seqlist, SeqlistType value)
{
	if (seqlist == NULL)
	{
		return;
	}
	if (seqlist->size >= SeqlistMaxsize)
	{
		printf("内存已满\n");
		return;
	}
	seqlist->data[seqlist->size] = value;
	++seqlist->size;
	seqlist->data[seqlist->size] = '\0';
	return;
}
void deleteback(Seqlist *seqlist)
{
	if (seqlist == NULL)
	{
		return;
	}
	if (seqlist->size == 0)
	{
		return;
	}
	--seqlist->size;
}
void printSeqlist(Seqlist *seqlist,char *msg)
{
	if (seqlist == NULL)
	{
		return;
	}
	printf("%s\n", msg);
	SeqlistType i = 0;
	for (; i < seqlist->size; i++)
	{
		printf("%c ", seqlist->data[i]);
	}
	printf("\n");
}
void SeqlistpushFront(Seqlist *seqlist, SeqlistType value)
{
	if (seqlist == NULL){
		return;
	}
	if (seqlist->size >= SeqlistMaxsize){
		return;
	}
	++seqlist->size;
	size_t i = seqlist->size - 1;
	for (; i > 0; --i)
	{
		seqlist->data[i] = seqlist->data[i-1];
	}
	seqlist->data[0] = value;
	return;

}
void Seqlistpopback(Seqlist *seqlist)
{
	if (seqlist == NULL){
		return;
	}
	size_t i =0;
	for (; i<seqlist->size-1; i++)
	{
		seqlist->data[i] = seqlist->data[i+1];
	}
	--seqlist->size;
	return;
}
void SeqlistInsert(Seqlist *seqlist, size_t num, SeqlistType value)
{
	if (seqlist == NULL){
		return;
	}
	++seqlist->size;
	size_t i = seqlist->size-1;
	for (; i > num; i--)
	{
		seqlist->data[i] = seqlist->data[i - 1];
	}
	seqlist->data[num] = value;
	return;
}
void SeqlistDelete(Seqlist *seqlist, size_t num)
{
	if (seqlist == NULL){
		return;
	}
	if (seqlist->size == 0){
		return;
	}
	size_t i = num;
	for (; i < seqlist->size-1; i++)
	{
		seqlist->data[i] = seqlist->data[i + 1];
	}
	--seqlist->size;
	return;
}
SeqlistType SeqListGet(Seqlist* seq, size_t pos, SeqlistType default_value)
{
	if (seq == NULL){
		return 0;
	}
	if (pos >= seq->size){
		return 0;
	}
	SeqlistType *p = seq->data[pos];
	return p;
}
void SeqListSet(Seqlist* seq, size_t pos, SeqlistType value)
{
	if (seq == NULL){
		return 0;
	}
	if (pos >= seq->size){
		return 0;
	}
	seq->data[pos] = value;
}
size_t SeqListFind(Seqlist* seq, SeqlistType value)
{
	if (seq == NULL){
		return -1;
	}
	size_t i = 0;
	for (; i < seq->size; ++i){
		if (value == seq->data[i])
		{
			return i;
		}
	}
	return 0;
}
void SeqListRemove(Seqlist* seq, SeqlistType to_delete)
{
	if (seq == NULL){
		return 0;
	}
	size_t ret=SeqListFind(seq,to_delete);
	if (ret == 0){
		return;
	}
	SeqlistDelete(seq, ret);
	return;
}
void SeqListRemoveAll(Seqlist* seq, SeqlistType to_delete)
{
	if (seq == NULL){
		return 0;
	}
	while (1){
		size_t ret = SeqListFind(seq, to_delete);
		if (ret == 0){
			break;
		}
		SeqlistDelete(seq, ret);
	}
	return;
}
size_t SeqListSize(Seqlist* seq)
{
	if (seq == NULL){
		return 0;
	}
	size_t i = 0;
	while (seq->data[i])
	{
		i++;
	}
	return i;
}
int SeqListEmpty(Seqlist* seq)
{
	if (seq == NULL){
		return 1;
	}
	if (seq->data[0] == '\0')
	{
		return 1;
	}
	return 0;
}
void swap(SeqlistType *x, SeqlistType *y)
{
	SeqlistType p = *x;
	*x = *y;
	*y = p;
	return;
}
void SeqListBubbleSort(Seqlist* seq)//冒泡排序
{
	size_t i = 0;
	size_t j = 0;
	for (i=0; i < seq->size; i++)
	{
		for (j =0; j<seq->size - i - 1; j++)
		{
			if (seq->data[j] > seq->data[j + 1])
			{
				swap(&seq->data[j], &seq->data[j + 1]);
			}
		}
	}
}
void greater(SeqlistType a, SeqlistType b)
{
	return a > b ? 1 : 0;
}
void SeqListBubbleSortEx(Seqlist* seq, Cmp cmp)
{
	size_t i = 0;
	size_t j = 0;
	for (i = 0; i < seq->size; i++)
	{
		for (j = 0; j<seq->size - i - 1; j++)
		{
			if (!cmp(seq->data[j],seq->data[j + 1]))
			{
				swap(&seq->data[j], &seq->data[j + 1]);
			}
		}
	}
}
测试代码//
void testinit()
{
	PrintHeader;
	Seqlist seqlist;
	SeqlistInit(&seqlist);
	printf("%lu\n", seqlist.size);
}
void testpushback()
{
	PrintHeader;
	Seqlist seqlist;
	SeqlistInit(&seqlist);
	pushback(&seqlist, 'a');
	pushback(&seqlist, 'b');
	pushback(&seqlist, 'c');
	printSeqlist(&seqlist,"尾部插入三个元素");
}
void testdeleteback()
{
	PrintHeader;
	Seqlist seqlist;
	SeqlistInit(&seqlist);
	deleteback(&seqlist);
	printSeqlist(&seqlist, "对空顺序表进行尾删");

	pushback(&seqlist, 'a');
	pushback(&seqlist, 'b');
	pushback(&seqlist, 'c');
	deleteback(&seqlist);
	//deleteback(&seqlist);
	printSeqlist(&seqlist, "对顺序表删除1个");

}
void testSeqlistpushFront()
{
	PrintHeader;
	Seqlist seqlist;
	SeqlistInit(&seqlist);
	SeqlistpushFront(&seqlist, 'O');
	SeqlistpushFront(&seqlist, 'L');
	printSeqlist(&seqlist, "对顺序表头插入两个元素");
}
void testSeqlistpopback()
{
	PrintHeader;
	Seqlist seqlist;
	SeqlistInit(&seqlist);
	pushback(&seqlist, 'a');
	pushback(&seqlist, 'b');
	pushback(&seqlist, 'c');
	Seqlistpopback(&seqlist);
	printSeqlist(&seqlist, "对顺序表头部删除一个元素");
}
void testSeqlistInsert()
{
	PrintHeader;
	Seqlist seqlist;
	SeqlistInit(&seqlist);
	pushback(&seqlist, 'a');
	pushback(&seqlist, 'b');
	pushback(&seqlist, 'c');
	SeqlistInsert(&seqlist, 1, 'p');
	printSeqlist(&seqlist, "对顺序表指定位置插入一个元素");
}
void testSeqlistDelete()
{
	PrintHeader;
	Seqlist seqlist;
	SeqlistInit(&seqlist);
	pushback(&seqlist, 'a');
	pushback(&seqlist, 'b');
	pushback(&seqlist, 'c');
	SeqlistDelete(&seqlist, 1);
	printSeqlist(&seqlist, "对顺序表指定位置删除一个元素");
}
void TestSeqListGet()
{
	PrintHeader;
	Seqlist seq;
	SeqlistInit(&seq);
	pushback(&seq, 'a');
	pushback(&seq, 'b');
	pushback(&seq, 'c');
	printSeqlist(&seq, "对顺序表指定位置查找一个元素");
	SeqlistType ret=SeqListGet(&seq, 2, 'E');
	printf("%c\n", ret);
}
void TestSeqListSet()
{
	PrintHeader;
	Seqlist seqlist;
	SeqlistInit(&seqlist);
	pushback(&seqlist, 'a');
	pushback(&seqlist, 'b');
	pushback(&seqlist, 'c');
	SeqListSet(&seqlist, 2, 'A');;
	printSeqlist(&seqlist, "对顺序表指定位置修改元素");
}
void TestSeqListFind()
{
	PrintHeader;
	Seqlist seqlist;
	SeqlistInit(&seqlist);
	pushback(&seqlist, 'a');
	pushback(&seqlist, 'b');
	pushback(&seqlist, 'c');
	size_t ret=SeqListFind(&seqlist,'b');
	printSeqlist(&seqlist, "通过元素查找下标");
	printf("%lu\n", ret);
}
void TestSeqListRemove()
{
	PrintHeader;
	Seqlist seqlist;
	SeqlistInit(&seqlist);
	pushback(&seqlist, 'a');
	pushback(&seqlist, 'b');
	pushback(&seqlist, 'c');
	//SeqListRemove(&seqlist,'b');
	//printSeqlist(&seqlist, "删除指定值");
    SeqListRemoveAll(&seqlist, 'b');
    printSeqlist(&seqlist, "删除所有指定值");
}
void TestSeqListSize()
{
	PrintHeader;
	Seqlist seqlist;
	SeqlistInit(&seqlist);
	pushback(&seqlist, 'a');
	pushback(&seqlist, 'b');
	pushback(&seqlist, 'c');
	size_t ret=SeqListSize(&seqlist);
	printf("顺序表元素个数为：%d\n",ret);
	printSeqlist(&seqlist, "获取顺序表元素个数");
}
void TestSeqListEmpty()
{
	PrintHeader;
	Seqlist seqlist;
	SeqlistInit(&seqlist);
	/*pushback(&seqlist, 'a');
	pushback(&seqlist, 'b');
	pushback(&seqlist, 'c');*/
	int ret = SeqListEmpty(&seqlist);
	printSeqlist(&seqlist, "顺序表是否为空");
	printf("%d\n", ret);
}
void TestSeqListBubbleSort()
{
	PrintHeader;
	Seqlist seqlist;
	SeqlistInit(&seqlist);
	pushback(&seqlist, 'Z');
	pushback(&seqlist, 'A');
	pushback(&seqlist, 'D');
	//SeqListBubbleSort(&seqlist);
	//printSeqlist(&seqlist, "冒泡排序");
	SeqListBubbleSortEx(&seqlist, greater);
	printSeqlist(&seqlist, "冒泡排序EX");
}
///
int main()
{
	testinit();
	testpushback();
	testdeleteback();
	testSeqlistpushFront();
	testSeqlistpopback();
	testSeqlistInsert();
	testSeqlistDelete();
	TestSeqListGet();
	TestSeqListSet();
	TestSeqListFind();
	TestSeqListRemove();
	TestSeqListSize();
	TestSeqListEmpty();
	TestSeqListBubbleSort();
	system("pause");
	return 0;
}