校招复习——数据结构：顺序表

顺序表
涉及各种排序算法在网站中均可查找
https://www.cnblogs.com/onepixel/articles/7674659.html

#ifndef SEQLIST_H //防止重复包含头文件
#define SEQLIST_H

#define LIST_INIT_SIZE 10 //初始化顺序表最大元素个数
#define LIST_INC_SIZE  2 //扩容倍数

typedef int SElemType;


//错误返回类型用枚举来表示
typedef enum {
	OK = 1,//正确
	ERROR = -1,//错误
	POSERROR = -2,//位置错误
	INITFAULT = -3,//初始化失败
	INCFAULT = -4,//扩容失败
	FAULT = -5,//失败
}Status;
///返回状态和节点的数据
typedef struct
{
	Status tag;
	SElemType item;
}RetType;


typedef struct
{
	SElemType *data;//指向顺序表的指针
	int  cursize; // 当前元素的个数
	int  maxsize; // 最大元素个数
}SeqList;
//数据交换函数
void SeqList_Swap(SElemType &a, SElemType &b)
{
	SElemType c = a;
	a = b;
	b = c;
}
//初始化函数
Status InitList(SeqList &seq)
{
	seq.data = (SElemType*)malloc(sizeof(SElemType)*LIST_INIT_SIZE);
	if (NULL == seq.data)
	{
		//exit(1); 
		return INITFAULT;//返回初始化失败
	}
	memset(seq.data, 0, sizeof(SElemType)*LIST_INIT_SIZE);
	//memmove; memcpy; memcmp;//strcpy;strcmp
	seq.cursize = 0;
	seq.maxsize = LIST_INIT_SIZE;
	return OK;
}
//顺序表摧毁函数
void DestroyList(SeqList &seq)
{
	free(seq.data);//首先释放其在堆内存上开辟的空间
	seq.data = NULL;
	seq.cursize = 0;
	seq.maxsize = 0;
}
//清空顺序表
void ClearList(SeqList &seq)
{
	seq.cursize = 0;
}
//获取顺序表元素个数
int GetSize(SeqList &seq)
{
	return seq.cursize;
}
//获取顺序表最大元素个数
int GetCapacity(SeqList &seq)
{
	return seq.maxsize;
}
//判断顺序表是否满
bool Is_Empty(SeqList &seq)
{
	return GetSize(seq) == 0;
}
//判断顺序表是否为空
bool Is_Full(SeqList &seq)
{
	return GetSize(seq) == GetCapacity(seq);
}
//顺序表扩容函数
static bool Inc_Size(SeqList &seq)
{
	SElemType *newdata = (SElemType*)realloc(seq.data, sizeof(SElemType)*GetCapacity(seq)*LIST_INC_SIZE);
	//realloc直接进行分匹配并且把原有数据拷贝
	if (NULL == newdata)
	{
		return false;
	}
	seq.data = newdata;
	seq.maxsize = seq.maxsize * LIST_INC_SIZE;
	return true;
}
//在第pos个位置插入值为val的结点
Status InsertList(SeqList &seq, int pos, SElemType val)
{
	if (pos < 0 || pos > seq.cursize)//判断pos是否有效
	{
		return POSERROR;
	}
	if (Is_Full(seq) && !Inc_Size(seq))
	{
		return INCFAULT;
	}
	for (int i = seq.cursize; i > pos; --i)
	{
		seq.data[i] = seq.data[i - 1];
	}
	seq.data[pos] = val;
	seq.cursize += 1;
	return OK;
}
//尾插
Status Push_Back(SeqList &seq, SElemType val)
{
	return InsertList(seq, seq.cursize, val);
}
//头插
Status Push_Front(SeqList &seq, SElemType val)
{
	return InsertList(seq, 0, val);
}
//删除第pos个结点
Status EraseList(SeqList &seq, int pos)
{
	if (pos < 0 || pos > seq.cursize - 1)
	{
		return POSERROR;
	}
	for (int i = pos; i < seq.cursize - 1; ++i)
	{
		seq.data[i] = seq.data[i + 1];
	}
	seq.cursize -= 1;
	return OK;
}
//删除队头元素
Status Pop_Front(SeqList &seq)
{
	return EraseList(seq, 0);
}
//删除队尾元素
Status Pop_Back(SeqList &seq)
{
	return EraseList(seq, seq.cursize - 1);
}
//删除表中值为val的元素
Status Remove(SeqList &seq, SElemType val)
{
	int i = 0, j = 0;
	while (i < seq.cursize)
	{
		if (seq.data[i] != val)
		{
			seq.data[j] = seq.data[i];
			++j;
		}
		++i;
	}
	seq.cursize = j;
	return OK;
}
//获得队头元素的值
RetType GetFront(SeqList &seq)
{
	RetType res = { FAULT };
	if (!Is_Empty(seq))
	{
		res.item = seq.data[0];
		res.tag = OK;
	}
	return res;// id name sex age addr 
}
//获得队尾元素的值
RetType GetBack(SeqList &seq)
{
	RetType res = { FAULT };
	if (!Is_Empty(seq))
	{
		res.item = seq.data[seq.cursize - 1];
		res.tag = OK;
	}
	return res;// id name sex age addr 
}
//打印顺序表
void PrintList(SeqList &seq)
{
	int n = GetSize(seq);
	for (int i = 0; i < n; ++i)
	{
		printf("%d ", seq.data[i]);
	}
	printf("\n");
}
//插入排序
void InsertSort(SeqList &seq)
{
	int n = GetSize(seq);
	for (int i = 1; i<n; ++i)
	{
		if (seq.data[i] < seq.data[i - 1])
		{
			SElemType tmp = seq.data[i];
			int j = i - 1;
			do
			{
				seq.data[j + 1] = seq.data[j];
				--j;
			} while (j >= 0 && tmp < seq.data[j]);
			seq.data[j + 1] = tmp;
		}
	}
}
//选择排序
void SelectSort(SeqList &seq)
{
	int n = GetSize(seq);
	for (int i = 0; i<n - 1; ++i)
	{
		int minpos = i;
		for (int j = i + 1; j<n; ++j)
		{
			if (seq.data[minpos] > seq.data[j])
			{
				minpos = j;
			}
		}
		if (i != minpos)
		{
			SeqList_Swap(seq.data[minpos], seq.data[i]);
		}
	}
}
//堆排序调整函数
//构建大根堆
void FilterDown(SeqList &seq, int start, int end)
{
	int i = start, j = 2 * i + 1;
	SElemType tmp = seq.data[i];
	while (j <= end) //
	{
		if (j < end && seq.data[j] < seq.data[j + 1]) ++j; // Max
		if (tmp >= seq.data[j]) break;
		seq.data[i] = seq.data[j];
		i = j;
		j = i * 2 + 1;
	}
	seq.data[i] = tmp;
}
//堆排序
void HeapSort(SeqList &seq)
{
	int end = seq.cursize - 1;
	int pos = (end - 1) / 2;
	// 构建大根堆
	while (pos >= 0)
	{
		FilterDown(seq, pos, end);
		--pos;
	}
	//进行堆排序
	for (int i = seq.cursize - 1; i>0; --i)
	{
		SeqList_Swap(seq.data[0], seq.data[i]);
		FilterDown(seq, 0, i - 1);
	}
}
//二分查找
int BinaryFindValue(SeqList &seq, SElemType val)
{
	int pos = -1;
	int left = 0;
	right = seq.cursize - 1;
	while (left <= right)
	{
		int mid = (right - left + 1) / 2 + left;
		if (val < seq.data[mid]) { right = mid - 1; }
		else if (val > seq.data[mid]) { left = mid + 1; }
		else
		{
			while (mid > left && val == seq.data[mid - 1]) --mid;
			pos = mid;
			break;
		}
	}
	return pos;
}
//递归实现二分查找
int Search(SeqList &seq, int left, int right, SElemType val)
{
	int pos = -1;
	if (left <= right)
	{
		int mid = (right - left + 1) / 2 + left;
		if (val < seq.data[mid])
		{
			pos = Search(seq, left, mid - 1, val);
		}
		else if (val > seq.data[mid])
		{
			pos = Search(seq, mid + 1, right, val);
		}
		else
		{
			while (mid > left && val == seq.data[mid - 1]) --mid;
			pos = mid;
		}
	}
	return pos;
}
//查找值为val的元素的下标
int SearchValue(SeqList &seq, SElemType val)
{
	return Search(seq, 0, seq.cursize - 1, val);
}
//在pos位置插入值为val的元素
void Insert_n(SeqList &seq, int pos, int size, SElemType val)
{
	if (pos < 0 || pos > seq.cursize - 1)
	{
		return;
	}
	for (int i = 0;i > seq.cursize;i++)
	{
		InsertList(seq, pos, val);
	}
}
//查找值为val的元素下标
int FindValue(SeqList &seq, SElemType val)
{
	int pos = -1;
	for (int i = 0;i < seq.cursize;i++)
	{
		if (seq.data[i] == val)
		{
			pos = i;
			break;	
		}
	}
	return pos;
}
//删除值为val的元素
void Remove_All(SeqList &seq, SElemType val)
{
	while(1)
	{
		if (FindValue(seq, val) == -1) break;
		EraseList(seq, FindValue(seq, val));
	}
}
//冒泡排序
void Bubble_Sort(SeqList &Seq)
{
	for (int i = Seq.cursize;i > 0;i--)
	{
		bool tag = true;
		for (int j = 0;j < i;j++)
		{
			if (Seq.data[j] > Seq.data[j++])
			{
				//Swap(&Seq.data[j], &Seq.data[j++]);
				tag = false;
			}
		}
		if (tag) break;
	}
}