《时间复杂度》《空间复杂度》《顺序表模拟实现》

时间复杂度
算法中基本操作的执行次数，为算法的时间复杂度

基本操作，即只有常数项，认为其时间复杂度为O(1)
顺序结构，时间复杂度按加法进行计算
循环结构，时间复杂度按乘法进行计算
分支结构，时间复杂度取最大值
判断一个算法的效率时，往往只需要关注操作数量的最高次项，其它次要项和常数项可以忽略
在没有特殊说明时，我们所分析的算法的时间复杂度都是指最坏时间复杂度

空间复杂度
空间复杂度算的是变量的个数。空间复杂度计算规则基本跟实践
复杂度类似，也使用大O渐进表示法。

顺序表
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构。
定义

typedef int DataType;

typedef struct SeqList
{
	DataType* _arr; //动态数组存储
	size_t _size;  //有效元素的个数
	size_t _capacity; //容量
}SeqList;

初始化

void Init(SeqList* s)
{
	s->_arr = NULL;
	s->_size = s->_capacity = 0;
}

销毁

void Destroy(SeqList* s)
{
	if (s->_arr)
	{
		free(s->_arr);
		s->_arr = NULL;
		s->_size = s->_capacity = 0;
	}
}

扩容

void Reserve(SeqList* s, size_t new_capacity)
{
	DataType* tmp = (DataType*)malloc(sizeof(DataType) * new_capacity);
	if (s->_arr)
	{
		memcpy(tmp, s->_arr, sizeof(DataType) * s->_size);
	}
	free(s->_arr);
	s->_arr = tmp;
	s->_capacity = new_capacity;
}

尾插

void PushBack(SeqList* s, DataType val)
{
	if (s->_size == s->_capacity)
	{
		size_t new_capacity = s->_capacity == 0 ? 2 : s->_capacity * 2;
		Reserve(s, new_capacity);
	}
	s->_arr[s->_size++] = val;
}

尾删

void PopBack(SeqList* s)
{
	assert(s->_arr != NULL);
	--s->_size;
}

头插

void PushFront(SeqList* s, DataType val)
{
	if (s->_size == s->_capacity)
	{
		size_t new_capacity = s->_capacity == 0 ? 2 : s->_capacity * 2;
		Reserve(s, new_capacity);
	}
	size_t end = s->_size;
	while (end > 0)
	{
		s->_arr[end] = s->_arr[end - 1];
		--end;
	}
	s->_arr[0] = val;
	++s->_size;
}

头删

void PopFront(SeqList* s)
{
	assert(s->_arr != NULL);
	size_t begin = 1;
	while (begin < s->_size)
	{
		s->_arr[begin - 1] = s->_arr[begin];
		++begin;
	}
	--s->_size;
}

pos位置插入

void Insert(SeqList* s, size_t pos, DataType val)
{
	assert(pos <= s->_size);
	if (s->_size == s->_capacity)
	{
		size_t new_capacity = s->_capacity == 0 ? 2 : s->_capacity * 2;
		Reserve(s, new_capacity);
	}

	size_t end = s->_size;
	while (end > pos)
	{
		s->_arr[end] = s->_arr[end - 1];
		--end;
	}
	s->_arr[pos] = val;
	++s->_size;
}

pos位置删除

void Erase(SeqList* s, size_t pos)
{
	assert(pos < s->_size);
	size_t begin = pos + 1;
	while (begin < s->_size)
	{
		s->_arr[begin - 1] = s->_arr[begin];
		++begin;
	}
	--s->_size;
}

查找

int Find(SeqList* s, DataType val)
{
	for (size_t i = 0; i < s->_size; ++i)
	{
		if (s->_arr[i] == val)
		{
			return i;
		}
	}
	return -1;
}