数据结构——顺序表（动态）

本文是对静态顺序表的理解

（这只是在下的粗浅理解，不足的地方还请谅解，欢迎留言提出，后期理解深入后会加以改进）

上一篇对静态顺序表的理解，这一篇是对动态顺序表的理解，相对于静态属性表，动态的顺序表就是能够开辟内存，

静态的是一开始就开辟一个固定容量的数组，满了就不能在装了，而动态的在满了之后还可以进行扩容。

静态顺序表链接：

http://blog.csdn.net/z_freedom/article/details/79534072

动态顺序表：

首先定义一个结构体，里面包含一个指针数组，容量以及有效数据个数

接下来就是动态顺序表的各种操作了，动态顺序表与静态顺序表的操作是一样的，除过扩容，下面我只写插入和删除与重点的扩容，剩下的与可以看静态的。

首先还是初始化：

接下来就是插入操作了，也分为头插和尾插

在插入之前需要进行容量的判断，若是第一次插入或者满了的话就要进行扩容了，所以先介绍扩容了

扩容

扩完容就是插入了，动态的插入其实和静态的是一样的

void SeqPushFront(SeqList* pSeq, DataType x)   //头插
{
	assert(pSeq);
	size_t end = pSeq->_size;
	CheckCatacity(pSeq);
	while (end)
	{
		pSeq->_a[end] = pSeq->_a[end - 1];
		end--;
	}
	pSeq->_size++;
	pSeq->_a[end] = x;
}
void SeqPushBack(SeqList* pSeq, DataType x)   //尾插
{
	assert(pSeq);
	CheckCatacity(pSeq);
	pSeq->_a[pSeq->_size++] = x;
}

删除操作：

void SeqPopFront(SeqList* pSeq)                //头删
{
	assert(pSeq);
	size_t start = 0;
	while (start < pSeq->_size)
	{
		pSeq->_a[start] = pSeq->_a[start + 1];
		start++;
	}
	pSeq->_size--;
}
void SeqPopBack(SeqList* pSeq)        //尾删
{
	assert(pSeq);
	if (pSeq->_size == 0)
	{
		printf("Seqlist is empty！\n");
		return;
	}
	pSeq->_size--;
}

以下是所有代码：

void SeqPrint(SeqList* pSeq)          //打印
{
	assert(pSeq);
	size_t i = 0;
	for (i = 0; i < pSeq->_size; i++)
	{
		printf("%d ", pSeq->_a[i]);
	}
	printf("\n");
}
void SeqInit(SeqList* pSeq)              //初始化
{
	assert(pSeq);
	pSeq->_a = NULL;        //首先初始化指针为NULL
	pSeq->_size = 0;        //还没插入数据，初始化为0
	pSeq->_capacity = 0;    //还没开辟空间，容量也初始化为0
}
void SeqDestory(SeqList* pSeq)         //释放空间
{
	assert(pSeq);
	if (pSeq->_a)
		free(pSeq);
}

void CheckCatacity(SeqList* pSeq)      //扩容函数
{
	if (pSeq->_size == pSeq->_capacity)
	{
		size_t newCatacity = pSeq->_capacity > 0 ? pSeq->_capacity * 2 : 3;
		pSeq->_a = (DataType*)realloc(pSeq->_a, newCatacity*sizeof(DataType));
	}
}

void SeqPushBack(SeqList* pSeq, DataType x)   //尾插
{
	assert(pSeq);
	CheckCatacity(pSeq);
	pSeq->_a[pSeq->_size++] = x;
}

void SeqPopBack(SeqList* pSeq)        //尾删
{
	assert(pSeq);
	if (pSeq->_size == 0)
	{
		printf("Seqlist is empty！\n");
		return;
	}
	pSeq->_size--;
}

void SeqPushFront(SeqList* pSeq, DataType x)   //头插
{
	assert(pSeq);
	size_t end = pSeq->_size;
	CheckCatacity(pSeq);
	while (end)
	{
		pSeq->_a[end] = pSeq->_a[end - 1];
		end--;
	}
	pSeq->_size++;
	pSeq->_a[end] = x;
}

void SeqPopFront(SeqList* pSeq)                //头删
{
	assert(pSeq);
	size_t start = 0;
	while (start < pSeq->_size)
	{
		pSeq->_a[start] = pSeq->_a[start+1];
		start++;
	}
	pSeq->_size--;
}
void SeqInsert(SeqList* pSeq, size_t pos, DataType x)      //任意位置插入
{
	assert(pSeq);
	CheckCatacity(pSeq);
	int end = pSeq->_size;
	while (end > pos)
	{
		pSeq->_a[end] = pSeq->_a[end - 1];
		end--;
	}
	pSeq->_a[end] = x;
	pSeq->_size++;
}
void SeqErase(SeqList* pSeq, size_t pos)    //任意位置删除
{
	assert(pSeq);
	assert(pos <= pSeq->_size);
	int start = pos + 1;
	if (pSeq->_size == 0)
	{
		return;
	}
	while (start < pSeq->_size)
	{
		pSeq->_a[start - 1] = pSeq->_a[start];
		start++;
	}
	pSeq->_size--;
}

int SeqFind(SeqList* pSeq, DataType x)               //查找x
{
	assert(pSeq);
	size_t i = 0;
	for (i = 0; i < (int)pSeq->_size; i++)
	{
		if (pSeq->_a[i] == x)
			return i;
		//printf("%d\n", i);
	}
	return -1;
}
void SeqAt(SeqList* pSeq, size_t pos, DataType x)    //替换pos位置
{
	assert(pSeq);
	assert(pos < pSeq->_size);

	pSeq->_a[pos] = x;
}
void swap(DataType* x, DataType* y)
{
	DataType *tmp = *x;
	*x = *y;
	*y = tmp;
}
void BubbleSort(SeqList* pSeq)                      //冒泡排序
{
	assert(pSeq);
	//size_t begin;
	//size_t finish = pSeq->_size;
	//while (finish>1)
	//{
	//	begin = 1;
	//	while (begin < finish)
	//	{
	//		if (pSeq->_a[begin - 1] > pSeq->_a[begin])
	//		{
	//			swap(&pSeq->_a[begin], &pSeq->_a[begin - 1]);
	//		}
	//		begin++;
	//	}
	//	finish--;
	//}
	size_t i = 0;
	size_t j = 0;
	size_t flag = 0;
	for (i = 0; i < pSeq->_size; i++)
	{
		flag = 0;
		for (j = 0; j < pSeq->_size - 1 - i; j++)
		{
			if (pSeq->_a[j]>pSeq->_a[j + 1])
			{
				flag = 1;
				swap(&pSeq->_a[j], &pSeq->_a[j + 1]);
			}
		}
		if (flag == 0)
			return;
	}
}
void SelectSort(SeqList* pSeq)   //选择排序
{
	assert(pSeq);
	size_t start = 0;
	size_t end = pSeq->_size - 1;
	size_t i = 0;
	while (start < end)
	{
		size_t max = start;
		size_t min = start;
		for (i = start; i <= end; i++)
		{
			if (pSeq->_a[i] > pSeq->_a[max])
				max = i;
			if (pSeq->_a[i] < pSeq->_a[min])
				min = i;
		}
		swap(&pSeq->_a[max], &pSeq->_a[end]);
		if (max != start)
			swap(&pSeq->_a[min], &pSeq->_a[start]);
		end--, start++;
	}
}
int _BinarySearch(DataType *a, size_t start, size_t end, DataType x)   //递归实现
{
	size_t mid;
	if (start > end)
		return -1;
	mid = start + ((end - start) >> 1);
	if (a[mid] > x)
		return _BinarySearch(a, start, mid - 1, x);
	else if (a[mid] < x)
		return _BinarySearch(a, mid + 1, end, x);
	else
		return mid;
}
int BinarySearch(SeqList* pSeq, DataType x)       //二分查找
{
	assert(pSeq);
	return _BinarySearch(pSeq->_a, 0, pSeq->_size - 1, x);
}