顺序表及相关操作

顺序表是用一组地址连续的存储单元依次存储一组数据，特点是每个数据元素的存储位置相邻

其结构体定义如下：

#define MAX_SIZE 1000               //顺序表最大容量
#define INIT_SIZE 2                 // 初始化大小

typedef int DataType;
typedef unsigned int size_t;

typedef struct SeqList
{
	DataType* array;
	size_t size;                   //下标
	size_t capacity;               // 当前容量
}SeqList, *PSeqList;

初始化操作为顺序表开辟两个单位容量，并将数据置为0，将下标size置为0，将顺序表当前容量capacity置为2.

void InitSeqList(PSeqList pSeqList)               //初始化顺序表
{
	pSeqList->array = (DataType*)malloc(sizeof(DataType)* INIT_SIZE);     //开辟空间
	if (NULL == pSeqList)
	{
		perror("out of memory");
	}
	pSeqList->size = 0;
	pSeqList->capacity = INIT_SIZE;
	memset(pSeqList->array, 0, sizeof(int)*INIT_SIZE);
}

插入数据之前需要先判断顺序表是否存在足够空间供新数据存放，若不够则需要在原基础上增加空间：

//判断是否扩容
void Check_Capacity(PSeqList pSeqList)
{
	assert(NULL != pSeqList);
	if (pSeqList->size >= INIT_SIZE)
	{
		DataType* New_Capacity = realloc(pSeqList->array, sizeof(DataType)*(pSeqList->capacity + INIT_SIZE));
		if (NULL == New_Capacity)
		{
			perror("out of memory");
		}
		else
		{
			pSeqList->array = New_Capacity;
			pSeqList->capacity = (pSeqList->capacity + INIT_SIZE);
		}
	}
}

// 尾插
void PushBack(PSeqList pSeqList, DataType data)
{
	assert(NULL != pSeqList);
	if (pSeqList->size >= pSeqList->capacity)
	{
		Check_Capacity(pSeqList);
	}
	pSeqList->array[pSeqList->size] = data;
	pSeqList->size++;

}

// 尾删
void PopBack(PSeqList pSeqList)
{
	assert(NULL != pSeqList);
	if (pSeqList->size <=0)
	{
		return;
	}
	pSeqList->size--;
}

// 打印顺序表
void PrintSeqList(PSeqList pSeqList)
{
	assert(NULL != pSeqList);
	size_t i = 0;
	for (i = 0; i < pSeqList->size; i++)
	{
		printf("%d ", pSeqList->array[i]);
	}
	printf("\n");
}

// 头插
void PushFront(PSeqList pSeqList, DataType data)
{
	int i = 0;
	assert(NULL != pSeqList);

	if (pSeqList->size >= pSeqList->capacity)
	{
		Check_Capacity(pSeqList);
	}
	for (i = pSeqList->size; i > 0; i--)
	{
		pSeqList->array[i] = pSeqList->array[i - 1];
	}
	pSeqList->array[0] = data;
	pSeqList->size++;

}

// 头删
void PopFront(PSeqList pSeqList)
{
	size_t i = 0;
	assert(NULL != pSeqList);
	if (pSeqList->size <= 0)
	{
		return;
	}
	for (; i <pSeqList->size; i--)
	{
		pSeqList->array[i] = pSeqList->array[i+1];
	}
	pSeqList->size--;

}

// 任意位置插入
void Insert(PSeqList pSeqList, int pos, DataType data)        //pos为元素在数组中的位置
{
	int i = 0;
	assert(NULL != pSeqList);
	if (pSeqList->size >= pSeqList->capacity)
	{
		Check_Capacity(pSeqList);
	}
	for (i = pSeqList->size; i>=pos ; i--)
	{
		pSeqList->array[i] = pSeqList->array[i - 1];           //元素后移
	}
	pSeqList->array[pos-1] = data;
	pSeqList->size++;

}

// 在顺序表中查找元素data
int Find_Data(PSeqList pSeqList, DataType data)
{
	size_t i = 0;
	assert(NULL != pSeqList);
	if (pSeqList->size <= 0)
	{
		return -1;
	}
	for (; i < pSeqList->size; i++)
	{
		if (pSeqList->array[i] == data)
		{
			return i;
		}
	}
	return -1;

}

// 删除顺序表中pos位置上的元素
void Erase(PSeqList pSeqList, int pos)
{
	size_t i = 0;
	assert(NULL != pSeqList);
	if (pSeqList->size <= 0)
	{
		return;
	}
	for (i = pos-1; i < pSeqList->size; i++)
	{
		pSeqList->array[i] = pSeqList->array[i + 1];
	}
	pSeqList->size--;
}

//移除顺序表中的元素data
void Remove(PSeqList pSeqList, DataType data)
{
	size_t i = 0;
	assert(NULL != pSeqList);
	if (pSeqList->size <= 0)
	{
		return;
	}
	for (i = 0; i < pSeqList->size; i++)
	{
		if (pSeqList->array[i] == data)
		{
			for (size_t j = i; j < pSeqList->size; j++)
			{
				pSeqList[j] = pSeqList[j + 1];
			}
			pSeqList->size--;
			return;
		}
	}
}

// 移除顺序表中所有元素data
void RemoveAll(PSeqList pSeqList, DataType data)
{
	size_t count = 0;
	size_t i = 0;
	for (i = 0; i < pSeqList->size; i++)
	{
		if (pSeqList->array[i] == data)
		{
			count++;
		}
	}
	for (i = 0; i < count; i++)
	{
		Remove(pSeqList, data);
	}
}

也可以对顺序表中的元素进行排序，此处的选择排序设置了两个标志位，一次循环结束找出当前最大和最小项，但是循环后的可能结果较多

void Bubble_sort(PSeqList pSeqList)                //冒泡排序
{
	size_t i = 0;
	size_t j = 0;
	int flag = 0;
	assert(NULL != pSeqList);
	if (pSeqList->size <= 1)
	{
		return;
	}
	for (i = 0; i < pSeqList->size - 1; i++)
	{
		for (j = 0; j < pSeqList->size - 1 - i; j++)
		{
			if (pSeqList->array[j] > pSeqList->array[j + 1])
			{
				flag = 1;
				DataType tmp = pSeqList->array[j];
				pSeqList->array[j] = pSeqList->array[j + 1];
				pSeqList->array[j + 1] = tmp;
			}
		}
		if (flag == 0)
		{
			return;
		}
	}
}

void Choose_sort(PSeqList pSeqList)      //选择排序
{
	size_t i = 0;
	size_t j = 0;
	size_t maxpos = 0;
	size_t minpos = 0;
	assert(NULL != pSeqList);
	if (pSeqList->size <= 1)
	{
		return;
	}
	for (i = 0; i < (pSeqList->size)/2; i++)
	{
		maxpos = i;
		minpos = i;
		for (j = i+1; j < pSeqList->size - i ; j++)
		{
			if (pSeqList->array[maxpos] < pSeqList->array[j])
			{
				maxpos = j;
			}
			if (pSeqList->array[minpos] > pSeqList->array[j])
			{
				minpos = j;
			}
		}
		if (maxpos == i && minpos == pSeqList->size - i - 1)
		{
			DataType tmp = pSeqList->array[maxpos];
			pSeqList->array[maxpos] = pSeqList->array[minpos];
			pSeqList->array[minpos] = tmp;
		}
		else if ((maxpos != pSeqList->size - i - 1)&&(minpos==pSeqList->size-i-1))
		{
			DataType tmp = pSeqList->array[minpos];
			pSeqList->array[minpos] = pSeqList->array[maxpos];
			pSeqList->array[maxpos] = pSeqList->array[i];
			pSeqList->array[i] =tmp;
		}
		else if ((minpos != i)&&(maxpos==i))
		{
			DataType tmp = pSeqList->array[pSeqList->size-i-1];
			pSeqList->array[pSeqList->size-i-1] = pSeqList->array[maxpos];
			pSeqList->array[maxpos] = pSeqList->array[minpos];
			pSeqList->array[minpos] = tmp;
		}
		else if ((minpos != i) && (maxpos == pSeqList->size - i - 1))
		{
			DataType tmp = pSeqList->array[minpos];
			pSeqList->array[minpos] = pSeqList->array[i];
			pSeqList->array[i] = tmp;
		}
		else if ((minpos == i) && (maxpos != pSeqList->size - i - 1))
		{
			DataType tmp = pSeqList->array[maxpos];
			pSeqList->array[maxpos] = pSeqList->array[pSeqList->size-1-i];
			pSeqList->array[pSeqList->size-i-1] = tmp;

		}
		maxpos = i;
		minpos = i;
	}

}

对顺序表进行二分查找

int Search_Two(PSeqList pSeqList,DataType data)  //二分查找
{
	int left = 0;
	int right = 0;
	int mid = 0;
	assert(NULL != pSeqList);
	if (pSeqList->size <= 0)
	{
		return -1;                      //元素不存在
	}
	Bubble_sort(pSeqList);
	left = 0;
	right = pSeqList->size - 1;
	mid = left + (right - left) / 2;
	while (left <= right)
	{
		if (pSeqList->array[mid] == data)
		{
			return (int)mid;
		}
		else if (pSeqList->array[mid]>data)
		{
			right = mid - 1;
		}
		else
		{
			left = mid + 1;
		}
	}
}

顺序表的销毁

/销毁
void Destroy_Pseqlist(PSeqList pSeqList)
{
	assert(NULL != pSeqList);
	free(pSeqList->array);
	pSeqList->array = NULL;
	pSeqList->size = 0;
	pSeqList->capacity = 0;
	
}