数据结构——顺序表（C语言）

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/gdarg/article/details/102506625

TextMain.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"seqlist.h"
int main()
{
    //创建一个顺序表 mylist
	Seqlist mylist;
	//初始化结构体， SEQLIST_DEFAULT_SIZE是宏定义的初始化顺序表的大小
	SeqlistInit(&mylist, SEQLIST_DEFAULT_SIZE);


	int select = 1;
	int pos = 0;
	DataType item;   //datatype实际是int
	DataType ret;
	bool flag;
	while (select)
	{
		printf("******************************************\n");
		printf("* [1] push_back         [2] push_front   *\n");
		printf("* [3] show_list         [0] quit_system  *\n");
		printf("* [4] pop_back          [5] pop_front    *\n");
		printf("* [6] insert_pos        [7] insert_val   *\n");
		printf("* [8] delete_pos        [9] delete_val   *\n");
		printf("* [10] find_pos         [11] find_val    *\n");
		printf("* [12] sort             [13] reverse     *\n");
		printf("* [14] length           [15] clear       *\n");
		printf("* [16] modify_pos       [17] modify_val  *\n");
		printf("* [18] capacity                          *\n");
		printf("******************************************\n");
		printf("请选择:>");
		scanf("%d", &select);
		if (select == 0)
			break;
		switch (select)
		{
		case 1:
			printf("请输入要插入的数据<-1结束>:>");
			while (scanf("%d", &item), item != -1)
			{    //顺序表尾插
				SeqlistPushback(&mylist, item);
			}
			//显示尾插后的顺序表
			SeqlistShow(&mylist);
			break;
		case 2:
			printf("请输入要插入的数据<-1结束>:>");
			while (scanf("%d", &item), item != -1)
			{     //顺序表的头插
				SeqlistPushFront(&mylist, item);
			}
			SeqlistShow(&mylist);
			break;
		case 3:
		     //顺序表显示
			SeqlistShow(&mylist);
			break;
		case 4:
		     //顺序表的尾删
			SeqlistPopback(&mylist);
			SeqlistShow(&mylist);
			break;
		case 5:
		    //顺序表的头删
			SeqlistPopfront(&mylist);
			SeqlistShow(&mylist);
			break;
		case 6:
			printf("请输入要插入的位置：\n");
			scanf("%d", &pos);
			printf("请输入要插入的值：\n");
			scanf("%d", &item);
			//顺序表按位置插入
			SeqlistInsertBypos(&mylist, pos, item);
			SeqlistShow(&mylist);
			break;
		case 7:
			printf("请输入要插入的值：\n");
			scanf("%d", item);
			// 顺序表中按值插入一个数
			SeqlistInsertByval(&mylist, item);
			SeqlistShow(&mylist);
			break;
		case 8:
			printf("请输入要删除的位置：\n");
			scanf("%d ", &pos);
			//按位置删除一个数
			SeqlistDeleteBypos(&mylist, pos);
			SeqlistShow(&mylist);
			break;
		case 9:
			printf("请输入需要删除的值：\n");
			scanf("%d ", &item);
			//按值删除一个数
			SeqlistDeleteByval(&mylist, item);
			SeqlistShow(&mylist);
			break;
		case 10:
			printf("请输入要查找的位置：\n");
			scanf("%d", &pos);
			//按位置查找一个数
		 flag =	SeqlistFindByPos(&mylist, pos, &ret);
			if (flag)
				printf("查找的数据为存在.\n");
			else
				printf("查找的数据为不存在. \n");
			break;
		case 11:
			printf("请输入需要查找的值：\n");
			scanf("%d", &item);
			//按值查找一个数
		    pos =   SeqlistFindByVal(&mylist, item);
			if (pos == -1)
				printf("查找的下标不存在.\n");
			else
				printf("数据所在的下标为%d\n", pos);
			break;
		case 12:
		//顺序表的排序
			SeqlistSort(&mylist);
			SeqlistShow(&mylist);
			break;
		case 13:
		//顺序表的逆置
			SeqlistReverse(&mylist);
			SeqlistShow(&mylist);
			break;
		case 14:
		//顺序表的长度
			SeqlistLength(&mylist);
			SeqlistShow(&mylist);
			break;
		case 15:
		//顺序表的清空
			SeqlistClear(&mylist);
			SeqlistShow(&mylist);
			break;
		case 16:
			printf("请输入位置：\n");
			scanf("%d", &pos);
			printf("请输入需要修改的值：\n");
			scanf("%d ", &item);
			//按位置修改一个数
			SeqlistModifyByPos(&mylist, pos, item);
			SeqlistShow(&mylist);
			break;
		case 17:
			printf("请输入想要修改的值：\n");
			scanf("%d ", &item);

			printf("请输入修改以后的值：\n");
			scanf("%d ", &pos);
			//按值修改一个数
			SeqlistModifyVal(&mylist, item, pos);
			SeqlistShow(&mylist);
			break;
		case 18:
			printf("capacity = %d \n", SeqlistCapacity(&mylist));
			break;
		default:
			printf("输入错误，请重新输入......\n");
			break;
		}
		system("pause");
		system("cls");
	}
	SeqlistDestory(&mylist);
	return 0;
}

Seqlist.h
#ifndef _SEQLIST_H_
#define _SEQLIST_H_

#include"common.h"


#define SEQLIST_DEFAULT_SIZE 8 
#define SEQLIST_INC_SIZE 5 //宏定义，每次顺序表空间为满后，自动开辟5个字节的内存
typedef struct Seqlist
{
	DataType *base;
	size_t    capacite;
	size_t    size;
}Seqlist;//定义一个顺序表，然后将其改名为Seqlist



//函数的声明
void SeqlistInit(Seqlist *psl, int sz);//函数的初始化
bool SeqlistPushback(Seqlist *psl, DataType x);//尾插
bool SeqlistPushFront(Seqlist *psl, DataType x);//头插
bool SeqlistPopback(Seqlist *psl);//尾删
bool SeqlistPopfront(Seqlist *psl);//头删
bool SeqlistInsertBypos(Seqlist *psl,size_t pos ,DataType x);//按位置插入一个数
bool SeqlistInsertByval(Seqlist *psl, DataType x);//按值插入一个数
bool SeqlistDeleteBypos(Seqlist *psl, int pos);//按位置删除一个数
bool SeqlistDeleteByval(Seqlist *psl, DataType x);//按值珊瑚一个数
bool SeqlistFindByPos(Seqlist *psl, int pos, DataType *ret);//按位置查找一个数
bool SeqlistFindByVal(Seqlist *psl, DataType x);//按值查找一个数
void SeqlistSort(Seqlist *psl);//排序
void SeqlistReverse(Seqlist *psl);//逆置
void SeqlistClear(Seqlist *psl);//清空
void SeqlistDestory(Seqlist *psl);//摧毁
bool SeqlistModifyByPos(Seqlist *psl , int  pos, DataType x);//按位置修改一个数
bool SeqlistModifyVal(Seqlist *psl, DataType x, DataType n);//按值修改一个数
size_t SeqlistCapacity(Seqlist *psl);//容量
size_t SeqlistLength(Seqlist *psl);//长度



//判断函数是否已满
bool SeqlistIsFull(Seqlist *psl)
{
	return psl->size >= psl->capacite;
}
//判断顺序表中是否为空
bool SeqlistEmpty(Seqlist *psl)
{
	return psl->size == 0;
}
//内部接口函数
bool _SeqlistInc(Seqlist *psl)
{
	assert(psl != NULL);
	psl->base = (int *)realloc(psl->base, sizeof(DataType)*(psl->capacite + SEQLIST_INC_SIZE));
	if (psl->base == NULL)
	{
		return false;
	}
	psl->capacite += SEQLIST_INC_SIZE;
	return true;


}
//初始化顺序表
void SeqlistInit(Seqlist *psl, int sz)
{
	psl->capacite = sz > SEQLIST_DEFAULT_SIZE ? sz : SEQLIST_DEFAULT_SIZE;
	psl->base = (DataType*)malloc(sizeof(DataType)*(psl->capacite));
	psl->size = 0;
}
//尾部插入数据
bool SeqlistPushback(Seqlist *psl, DataType x)
{
	assert(psl != NULL);
	if (SeqlistIsFull(psl) && !_SeqlistInc(psl))
	{
		printf("顺序表已满，%d无法插入.\n", x);
		return false;
	}
	psl->base[psl->size++] = x;
	return true;
}
//头部插入数据
bool SeqlistPushFront(Seqlist *psl, DataType x)
{

	if (SeqlistIsFull(psl) && !_SeqlistInc(psl))
	{
		printf("列表已满，请重新输入：\n");
		return false;
	}
	for (int i = psl->size; i > 0; --i)
	{
		psl->base[i] = psl->base[i - 1];
	}
	psl->base[0] = x;
	psl->size++;
	return true;
}
//打印出顺序表中的数据
void SeqlistShow(Seqlist *psl)
{
	assert(psl != NULL);

	for (int i = 0; i < psl->size; ++i)
	{
		printf("%d ", psl->base[i]);
	}
	printf("\n");
}
//尾部删除
bool  SeqlistPopback(Seqlist *psl)
{
	assert(psl != NULL);

	if (SeqlistEmpty(psl))
	{
		printf("顺序表已满，无法进行删除！\n");
		return false;
	}
	psl->size--;
	return true;
}
//头部删除(将前面的数据用后面的数据覆盖)
bool SeqlistPopfront(Seqlist *psl)
{
	assert(psl != NULL);
	if (SeqlistEmpty(psl))
	{
		printf("顺序表中没有数据，无法进行删除！\n");
		return false;
	}
	for (int i = 0; i < psl->size-1; ++i)
	{
		psl->base[i] = psl->base[i+1];
	}
	psl->size--;
	return true;
}
//按位置插入
 bool SeqlistInsertBypos(Seqlist *psl, int  pos, DataType x)
{
	 assert(psl != NULL);
	 if (pos < 0 || pos >psl->size)
	 {
		 printf("插入的坐标不合法. \n");
		 return false;
	 }
	 for (int i = psl->size; i > pos; --i)
	 {
		 psl->base[i] = psl->base[i - 1];
	 }
	 psl->base[pos] = x;
	 psl->size++;
	 return true;
}
 //按值插入
 bool SeqlistInsertByval(Seqlist *psl, DataType x)
 {
	 assert(psl != NULL);
	 if (SeqlistIsFull(psl) && !_SeqlistInc(psl))
	 {
		 printf("顺序表已满，无法插入！\n");
		 return false;
	 }
	 int i;
	 for (i = psl->size - 1; i >= 0 && x < psl->base[i]; --i)
	 {
		 psl->base[i + 1] = psl->base[i];
	 }
	 psl->base[i + 1] = x;
	 psl->size++;
	 return true;
 }
 bool SeqlistDeleteBypos(Seqlist *psl, int pos)
 {
	 assert(psl != NULL);
	 if (pos<0 || pos>psl->size - 1)
	 {
		 printf("输入的坐标不合法，请重新输入：\n");
		 return false;
	 }
	 for (int i = pos; i < psl->size - 1; ++i)
	 {
		 psl->base[i] = psl->base[i + 1];
	 }
	 psl->size--;
	 return true;
 }
 bool SeqlistFindByVal(Seqlist *psl, DataType x)
 {
	 assert(psl != NULL);
	 for (int i = 0; i < psl->size; ++i)
	 {
		 if (psl->base[i] = x)
		 {
			 return i;
		 }
	 }
	 return -1;
 }
 bool SeqlistDeleteByval(Seqlist *psl, DataType x)
 {
	 assert(psl != NULL);
	 int index = SeqlistFindByVal(psl, x);
	 if (index == -1)
	 {
		 printf("要删除的数据不存在\n");
		 return false;
	 }
	return  SeqlistDeleteBypos(psl, index);
	
 }
 bool SeqlistFindByPos(Seqlist *psl, int pos, DataType *ret)
 {
	 assert(psl != NULL);
	 if (pos < 0 || pos >psl->size-1)
	 {
		 printf("输入的坐标不合法\n");
		 return false;
	 }
	 *ret = psl->base[pos];
	 return true;
 }
 int SeqlistFindVal(Seqlist *psl, DataType x)
 {
	 assert(psl != NULL);
	 for (int i = 0; i < psl->size; ++i)
	 {
		 if (psl->base[i] == x)
		 {
			 return i;
		 }
		 return -1;
	 }


 }
 void SeqlistSort(Seqlist *psl)
 {
	 for (int i = 0; i<psl->size - 1; ++i)
	 {
		 for (int j = 0; j<psl->size - i - 1; ++j)
		 {
			 if (psl->base[j] > psl->base[j + 1])
			 {
				 Swap(&(psl->base[j]), &(psl->base[j + 1]));
			 }
		 }
	 }
 }
void SeqlistReverse(Seqlist *psl)
 {
	 assert(psl != NULL);
	 int begin = 0;
	 int end = psl->size - 1;
	 while (begin < end)
	 {
		 Swap(&(psl->base[begin]), &(psl->base[end]));
		 begin++;
		 end--;
	 }
 }
 void SeqlistClear(Seqlist *psl)
 {
	 assert(psl != NULL);
	  psl->size = 0;
 }
 void SeqlistDestory(Seqlist *psl)
 {
	 free(psl->base);
	 psl->base = NULL;
	 psl->capacite = psl->size = 0;
 }

 bool SeqlistModifyByPos(Seqlist  *psl, int pos, DataType x)
 {
	 assert(psl != NULL);
	 if (pos < 0 || pos > psl->size - 1)
	 {
		 printf("修改的位置不合法. \n");
		 return false;
	 }
	 psl->base[pos] = x;
	 return true;
 }
 bool SeqlistModifyVal(Seqlist *psl, DataType x, DataType n)
 {
	 assert(psl != NULL);
	 int index = SeqlistFindByVal(psl, x);
	 if (index == -1)
		 return false;
	 psl->base[index] = n;
	 return true;
 }
 size_t SeqlistLength(Seqlist *psl)
 {
	 return	psl->size;
 }
 size_t SeqlistCapacity(Seqlist *psl)
 {
	 assert(psl != NULL);
	 return psl->capacite;
 }

common.h
#ifndef _COMMON_H_
#define _COMMON_H_


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
#include<stdbool.h>

//提高了程序的适用性
#define DataType int 
void Swap(DataType *a, DataType *b)
{
	DataType tmp = *a;
	*a = *b;
	*b = tmp;
}

#endif

如有大佬有更好的建议，联系方式1846074273