顺序表与链表

线性表

在说顺序表和链表之前，我们先来说说线性表吧。
（1）线性表：是具有n个相同特性的数据元素的有限序列，线性表是在实际中广泛使用的数据结构。
（2）常见的线性表：顺序表，链表，字符串，栈，队列
（3）结构：线性表在逻辑上是线性结构，也就说是一条连续的直线。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。

顺序表

1.概念和结构
（1）顺序表：用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。
（2）顺序表一般分为：
静态顺序表：使用定长数组存储
动态顺序表：使用动态开辟的数组存储

//静态顺序表
#define N 100
typedef struct SeqList
{
	DataType array[N];//定长数组
	size_t size;//有效数据个数
}SeqList;
//动态顺序表
typedef struct SeqList
{
	DataType* _array; // 保存顺序表中有效元素个数 
	int _capacity; // 空间总大小 
	int _size; // 有效元素个数 
}SeqList, *PSeqList;

2、顺序表的基本功能能实现

//初始化
void SeqListInit(PSeqList ps)
{
	ps->_array = (int *)malloc(sizeof(int)*DEFAULT_CAPACITY);
	ps->_capacity = DEFAULT_CAPACITY;
	ps->_size = 0;
}

//销毁
void SeqListDestroy(PSeqList ps)
{
	free(ps->_array);
	ps->_size = ps->_capacity = 0;

}

// 尾插 
void SeqListPushBack(PSeqList ps, DataType data)
{
	ps->_array[ps->_size] = data;
	ps->_size++;
}
// 尾删 
void SeqListPopBack(PSeqList ps)
{
	assert(ps->_size>0);
	ps->_size--;
}

// 头插 
void SeqListPushFront(PSeqList ps, DataType data)
{
	for (int i = 0; i<ps->_size - 1; i ++ )
	{
		ps->_array[i] = ps->_array[i + 1];
	}
	ps->_array[0] = data;
	ps->_size++;
}
// 头删 
void SeqListPopFront(PSeqList ps)
{
	assert(ps->_size>0);
	for (int i = 0; i < ps->_size - 2; i++)
	{
		ps->_array[i] = ps->_array[i + 1];

	}
	ps->_size--;
}

// 在顺序表任意位置插入 数据
void SeqListInsert(PSeqList ps, int pos, DataType datda)
{
	if (pos<0 || pos>ps->_size)
	{
		printf("下表不合法\n");
		return;
	}
	if (ps->_size > ps->_capacity)
	{
		int* newArray = (int*)malloc(sizeof(int)* 2 * ps->_capacity);
		for (int i = 0; i < ps->_size; i++)
		{
			newArray[i] = ps->_array[i];
		}
		free(ps->_array);
		ps->_array = newArray;
	}
	for (int i = ps->_size; i < pos; i--)
	{
		ps->_array[i] = ps->_array[i + 1];
	}
	ps->_array[pos] = datda;
	ps->_size++;
}

// 在顺序表的任意位置删除数据
void SeqListErase(PSeqList ps, int pos)
{
	assert(ps->_size > 0);
	for (int i = pos; i < ps->_size-2; i++)
	{
		ps->_array[i] = ps->_array[i + 1];
	}
	ps->_size--;
}

// 检测data是否放在顺序表中 
int SeqListFind(PSeqList ps, DataType data)
{
	for (int i = 0; i < ps->_size ; i++)
	{
		if (ps->_array[i] == data)
		{
			return i;
		}
	}
}

// 移除顺序表中第一个值为data的元素 
void SeqListRemove(PSeqList ps, DataType data)
{
	int index = SeqListFind(ps, data);
	if (index != -1)
	{
		SeqListErase(ps, index);
	}
}

// 移除顺序表中所有值为data的元素 
void SeqListRemoveAll(PSeqList ps, DataType data)
{
	int j = 0;
	for (int i = 0; i < ps->_size; i++)
	{
		if (ps->_array[i] != data)
		{
			ps->_array[j++] = ps->_array[i];
		}
	}
	ps->_size = j;
}

// 获取顺序表有效元素个数 
int SeqListSize(PSeqList ps)
{
	return ps->_size;
}

// 获取顺序表的容量 
int SeqListCapacity(PSeqList ps)
{
	return ps->_capacity;
}

// 检测顺序表是否为空 
int SeqListEmpty(PSeqList ps)
{
	return ps->_size = 0 ? 1 : 0;
}

// 获取顺序表中第一个元素 
DataType SeqListFront(PSeqList ps)
{
	return ps->_array[0];
}

// 获取顺序表中最后一个元素 
DataType SeqListBack(PSeqList ps)
{
	return ps->_array[ps->_size - 1];
}

链表

1.概念和结构
概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
数据结构：

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向、双向 2. 带头、不带头 3. 循环、非循环
   
   但是我们比较常用的是
   （1）无头单向不循环链表：结构简单，一般不会单独用来存储数据，实际中更多是作为其他数据结构的子结构
   （3）带头双向循环链表：结构最为复杂，一般用在单独存储数据，实际中使用的链表数据结构，都是带头双向循环链表。
   2、链表的基本功能实现
   这里就像不介绍链表的基本功能实现了、下一篇博客见。
   博客地址：https://blog.csdn.net/qq_42430426/article/details/98099233
   链表和顺序表的区别和联系
   顺序表：
   优点：空间连续、支持随机访问、不容易产生内存碎片
   缺点：（1）中间或者前面部分的插入删除时间复杂度为O(N) （2）增容代价比较大
   链表：
   优点：（1）任意位置插入删除时间复杂度为O(1) （2）没有增容问题，插入一个开辟一个空间
   缺点：以节点为单位存储，不支持随机访问