数据结构之C语言实现顺序表（SeqList）无主函数

#include<stdio.h>
#include<assert.h>
#include<malloc.h>
#define ElemType int
#define SEQLIST_DEFAULT_SIZE 8
#define SEQLIST_INC_SIZE     5
//定义顺序表结构体
typedef struct SeqList
{
	ElemType *base; //int *base
	size_t    capacity;//顺序表容量
	size_t    len;//顺序表大小（长度）
}SeqList;


void InitSeqList(SeqList *list);//初始化
void ShowSeqList(SeqList *list);//打印
bool push_back(SeqList *list, ElemType x);//尾插
bool push_front(SeqList *list, ElemType x);//头插
size_t Length(SeqList *list);//求长度
bool insert_pos(SeqList *list, int pos, ElemType x);//按位置插入
bool pop_back(SeqList *list);//尾删
bool pop_front(SeqList *list);//头删
bool insert_val(SeqList *list, ElemType x);//按值插入
bool delete_pos(SeqList *list, int pos);//按位置删除
bool delete_val(SeqList *list, ElemType key);//按值删除
int  find_key(SeqList *list, ElemType key);//查找一个值
void reverse_list(SeqList *list);//逆置顺序表
void sort_list(SeqList *list);//排序
void clear_list(SeqList *list);//清除
void destroy_list(SeqList *list);//摧毁


bool IsFull(SeqList *list)//判满
{
	return list->len >= list->capacity;
}
bool IsEmpty(SeqList *list)//判空
{
	return list->len == 0;
}
void Swap(ElemType &a, ElemType &b)//交换值
{
	ElemType tmp = a;
	a = b;
	b = tmp;
}
//异常安全 
bool Inc(SeqList *list)
{
	size_t new_capacity = list->capacity+SEQLIST_INC_SIZE;
	ElemType *new_base = (ElemType*)realloc(list->base, sizeof(ElemType)*new_capacity);
	if(new_base == NULL)
		return false;
	list->capacity = new_capacity;
	list->base = new_base;
	return true;
}


void InitSeqList(SeqList *list)
{
	list->base = (ElemType*)malloc(sizeof(ElemType)*SEQLIST_DEFAULT_SIZE);//先开辟空间
	assert(list->base != NULL);//断言，如果为假则不执行下面语句
	list->capacity = SEQLIST_DEFAULT_SIZE;
	list->len = 0;
}
void ShowSeqList(SeqList *list)
{
	for(int i=0; i<list->len; ++i)
	{
		printf("%d",list->base[i]);
	}
	printf("\n");
}

bool push_back(SeqList *list, ElemType x)
{
	if(list->len>=list->capacity && !Inc(list))
		//if(!Inc(list) && list->len>=list->capacity)
	{
		printf("空间已满，不能插入");
			return false;
	}
	list->base[list->len++] = x;
	//list->len++;

	return true;
}

bool push_front(SeqList *list, ElemType x)
{
	if(list->len >= list->capacity)
	{
		printf("空间已满，不能头部插入\n");
		return false;
	}
	for(int i=list->len; i>0; --i)
	{
		list->base[i] = list->base[i-1];
	}
	list->base[0] = x;
	list->len++;
	return true;
}

size_t Length(SeqList *list)
{
	return list->len;
}

bool insert_pos(SeqList *list, int pos, ElemType x)
{
	if(list->len >= list->capacity)
	{		
		printf("空间已满，不能插入\n");

		return false;
	}
	if(pos<0 || pos>list->len)
	{

		printf("插入的位置非法\n");

		return false;
	}

	for(int i=list->len; i>pos; --i)
	{
		list->base[i] = list->base[i-1];
	}
	list->base[pos] = x;
	list->len++;
	return true;
}
bool pop_back(SeqList *list)
{
	if(list->len == 0)
	{
		printf("顺序表已空，不能删除\n");
		return false;
	}
	list->len--;
	return true;
}

bool pop_front(SeqList *list)
{
	if(list->len == 0)
	{
		printf("顺序表已空，不能删除\n");
		return false;
	}

	for(int i=0; i<list->len-1; ++i)
	{
		list->base[i] = list->base[i+1];
	}
	list->len--;
	return true;
}
bool insert_val(SeqList *list, ElemType x)
{
	if(list->len >= list->capacity)
	{
		printf("空间已满，不能插入\n");
		return false;
	}
	int i,j;
	for(i=0; i<list->len; ++i)
	{
		if(x < list->base[i])
		{
			for(j=list->len; j>i; --j)
			{
				list->base[j] = list->base[j-1];
			}
			break;
		}
	}
	list->base[i] = x;
	list->len++;
	return true;
}

bool delete_pos(SeqList *list, int pos)
{
	if(list->len == 0)
	{
		printf("顺序表已空，不能删除\n");
		return false;
	}
	if(pos<0 || pos>=list->len)
	{
		printf("删除的位置非法，不能删除\n");
		return false;
	}
	for(int i=pos; i<list->len-1; ++i)
	{
		list->base[i] = list->base[i+1];
	}
	list->len--;
	return true;
}

bool delete_val(SeqList *list, ElemType key)
{
	if(list->len == 0)
	{
		printf("顺序表已空，不能删除\n");
		return false;
	}
	int del_pos = find_key(list, key);
	if(del_pos == -1)
	{
		printf("要删除的数据不存在\n");
		return false;
	}
	return delete_pos(list, del_pos);
}

int  find_key(SeqList *list, ElemType key)
{
	for(int i=0; i<list->len; ++i)
	{
		if(key == list->base[i])
			return i;
	}
	return -1;
}

void reverse_list(SeqList *list)
{
	if(list->len > 1)
	{
		int low = 0;
		int high = list->len-1;
		while(low < high)
		{
			Swap(list->base[low], list->base[high]);
			low++;
			high--;
		}
	}
}

void sort_list(SeqList *list)
{
	if(list->len > 1)
	{
		for(int i=0; i<list->len-1; ++i)
		{
			for(int j=0; j<list->len-i-1; ++j)
			{
				if(list->base[j] > list->base[j+1])
				{
					Swap(list->base[j], list->base[j+1]);
				}
			}
		}
	}
}

void clear_list(SeqList *list)
{
	list->len = 0;
}

void destroy_list(SeqList *list)
{
	free(list->base);
	list->base = NULL; // 预防野指针
	list->capacity = list->len = 0;
}