线性表的从上而下----顺序表与链表

引言

1.什么是线性表?
2.什么是线性结构?

一个线性表是n个具有相同特性的数据元素的有限序列。
线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储，但是把最后一个数据元素的尾指针指向了首位结点）。

线性结构是一个有序数据元素的集合。 数据结构中数据的逻辑结构分为**线性结构和非线性结构**。

常见的线性结构有:链表、顺序表、栈、队列
常见的非线性结构表有：广义表、图

一、关于顺序表

1、顺序表的概念与结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。
在数组上完成数据的增删查改。
而顺序表又可分为：

1. 静态的顺序表(一开始就规定了数组的大小)
2. 动态的顺序表

这里以动态的顺序表来实现

1、顺序表的实现----构建

typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* a;
	int size;               //记录先存顺序表大小
	int capacity;        //目前容量大小
}SL;

通常为了方便数据的通用性,直接typedef 数据类型
指针 a 为动态数组;

void SeqListInit(SeqList* head)
{
	head->a = NULL;
	head->size = 0;
	head->capacity = 0;
}

顺序表的初始化,对于动态数组也可以一开始开辟小部分空间

2、顺序表的增加

这里以尾插来实现

void SeqListCapacity(SeqList* head)
{
	assert(head);
	if (head->size == head->capacity)
	{
		//定义临时变量，改变当前容量储存
		int newCapacity = head->capacity == 0 ? 4 : head->capacity * 2;
		//等价于  
		/*if (head->capacity == 0)
		{
			int newCapacity = head->capacity = 4;
		}
		else
		{
			int newCapacity = head->capacity * 2;
		}*/
		SLDateType* pc = (SLDateType*)realloc(head->a, sizeof(SLDateType)*newCapacity);
		if (pc == NULL)
		{
			assert(pc);
		}
		head->a = pc;
		head->capacity = newCapacity;
	}
}


void SeqListPushBack(SeqList* head,SLDateType tem)
{
	assert(head);
	SeqListCapacity(head);
	head->a[head->size] = tem;
	head->size++;
}

3 、顺序表的查找

查找很好实现，一个循环就可以解决

int SeqListFind(SeqList* head, SLDateType val)
{
	for (int i = 0;i < head->size;i++)
	{
		if (head->a[i] == val)
			return i;
	}
}

4、顺序表的删除

这里以头删来实现

void SeqListPopFront(SeqList* head)
{
	assert(head);
	assert(head->size > 0);
	for (int i = 0;i < head->size;i++)
	{
		head->a[i] = head->a[i + 1];
	}
	head->size--;
}

顺序表的删除，尾删的效率更高，也更容易实现

5、顺序表的插入

先找到需要插入所需的位置，这里以找到val的值，然后插入到val的前面 为例

int SeqListFind(SeqList* head, SLDateType val)
{
	for (int i = 0;i < head->size;i++)
	{
		if (head->a[i] == val)
			return i;
	}
}

void SeqListInsert(SeqList* head, int pos, SLDateType val)
{
	assert(head);
	assert(pos >= 0 && pos <= head->size);
	
	SeqListCapacity(head);
	for (int i = head->size;i > pos;i--)
	{
		head->a[i] = head->a[i - 1];
	}
	head->a[pos] = val;
	head->size++;
}

6、顺序表的销毁

最后的销毁可以类似初始化，把开辟的动态数组释放即可

二、关于链表

链表的概念与结构

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

逻辑结构：

在实际上的物理结构是没有联系的

1、链表的实现----构建

typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType val;
	struct SListNode* next;
}SLNode;

next是用来储存指向下一个结点的指针域

注意：指针的大小是固定的，所以结构体可以嵌套指针，但不可以嵌套结构体（也就是并不能自己嵌套自己）

在链表的构建时，可以设置哨兵位，无用头节点不储存数据
这里以不设置哨兵位为例

2、链表的插入

以头插为例，buySlistNode函数用来方便开辟链表的空间

SListNode* BuySListNode(SLTDateType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	assert(newnode);
	newnode->val = x;
	newnode->next = NULL;
	return newnode;
}

void SListPushFront(SListNode** head, SLTDateType x)
{
	assert(head);
	SLNode* newnode = BuySListNode(x);
	newnode->next = *head;
	*head = newnode;
}

逻辑图：

这里参数为二级指针的理由：head也就是开始插入时，head只是一个结构体类型的指针。而插入的第一个结点，要把它变成指向一块区域的结构体指针，需要改变它的值（指针）

在之前都知道，int max（int x, int y)并不改变原有的值，只是形参的复制，这里也是一样

3、链表的打印

void SListPrint(SListNode* head)
{
	SLNode* cur = head;
	while (cur != NULL)
	{
		printf("%d->", cur->val);
		cur = cur->next;
	}
	printf("NULL\n");
}

4、链表的删除

这里以头删为例

void SListPopFront(SListNode** head)
{
	assert(head);
	//注意当头节点也为空的时候
	assert(*head);

	SLNode* cur = (*head)->next;
	free(*head);
	*head = cur;
}

5、链表的销毁

void SLTDestroy(SLNode** head) 
{
	assert(head);
	while (*head)
	{
		//SListPopFront(head);
		//也可以重复尾删
		SLNode* cur = (*head)->next;
		free(*head);
		*head = cur;
	}
	*head = NULL;
}

总结：链表和顺序表是储存数据的俩种结构，也是实现其他结构的基础