【数据结构】线性表（顺序表与链表）

一、顺序表

1.静态顺序表

2.动态顺序表

3.动态版本的代码集合献上

这里说明一下，为什么我们一般都只会使用动态版本的顺序表呢？

因为静态版本只适用于明确知道存储的数据的大小，这就要求我们会给一个定长，这样我们内存开大了就会造成浪费，小了不够用。而动态版本则可以避免这样的尴尬，根据我们的需求去动态的申请空间进行扩容的操作。

头文件---包含着所有的函数声明与类型声明

SeqList.h

#pragma once
#include 
#include 
#include 

typedef int SLDateType;

typedef struct SeqList
{
	SLDateType* a;
	int size;		//记录此时有效数据的大小
	int capacity;	//记录当前最大容量
}SL;

// 对数据的管理:增删查改 
void SeqListInit(SL* ps);

void SeqListDestroy(SL* ps);

void SeqListPrint(SL* ps);

void SeqListPushBack(SL* ps, SLDateType x);

void SeqListPushFront(SL* ps, SLDateType x);

void SeqListPopFront(SL* ps);

void SeqListPopBack(SL* ps);

// 顺序表查找
int SeqListFind(SL* ps, SLDateType x);

// 顺序表在pos位置插入x
void SeqListInsert(SL* ps, int pos, SLDateType x);

// 顺序表删除pos位置的值
void SeqListErase(SL* ps, int pos);

SeqList.c---所有的接口函数都在此文件内

#include"SeqList.h"

void SeqListInit(SL* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

void SeqListDestroy(SL* ps)
{
	assert(ps);
	if (ps->a != NULL)
	{
		free(ps->a);
		ps->a = NULL;
		ps->size = 0;
		ps->capacity = 0;
	}
}

void SeqListPrint(SL* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

void SLCheckCapacity(SL* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		//用tmp不用ps->a防止ps->指向的数据丢失
		//realloc是可以运行ps->a为空的，相当于malloc
		SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}
void SeqListPushBack(SL* ps, SLDateType x)
{
	assert(ps);

	SLCheckCapacity(ps);

	ps->a[ps->size] = x;
	ps->size++;
}


void SeqListPushFront(SL* ps, SLDateType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	//挪动数据
	int end = ps->size;
	while (end >= 0)
	{
		ps->a[end +1] = ps->a[end];
		--end;
	}
	ps->a[0] = x;
	ps->size++;
}


void SeqListPopBack(SL* ps)
{
	assert(ps);

	assert(ps->size > 0);

	ps->size--;
}
void SeqListPopFront(SL* ps)
{
	assert(ps);

	assert(ps->size > 0);
	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		++begin;
	}
	ps->size--;
}


int SeqListFind(SL* ps, SLDateType x)
{
	assert(ps);

	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

void SeqListInsert(SL* ps, int pos, SLDateType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	int  end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}

	ps->a[pos] = x;
	ps->size++;
}


void SeqListErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		++begin;
	}
	ps->size--;
}

实现完动态版本的顺序表我们又发现了一些问题：

虽然顺序表可以根据需要扩容申请内存空间，但对于我们想要头部或中间部分的插入删除的时间复杂度是O（N），时间上效率不高，而且增容时也会产生消耗，这都是不利的，所以就有了链表。

二、链表

1.单链表

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

像这样的链表依次找到下一个结点的地址来连接起来。

单链表分为带头和不带头

但实际区别并不大，带头无非就是多了一个头结点。

2.带头双向循环链表

对于链表类比可以有带头和不带头的单链表，又有循环链表，双向链表，组合起来可以有多种组合，所以我们就以一个结构最复杂的带头双向循环链表作为例子，别看它结构确实复杂，但实现起来却是最简单的。

3.单链表代码合集

SList.h---头文件

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

// 动态申请一个节点
SLNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SLNode* phead);
// 单链表尾插
void SLTPushBack(SLNode** pphead, SLTDateType x);
// 单链表的头插
void SLTPushFront(SLNode** pphead, SLTDateType x);
// 单链表的尾删
void SListPopBack(SLNode** pphead);
// 单链表头删
void SListPopFront(SLNode** pphead);
// 单链表查找
SLNode* SListFind(SLNode* phead, SLTDateType x);
// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
void SListInsertAfter(SLNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SLNode* pos);

// 在pos的前面插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLTDateType x);
// 删除pos位置
void SLTErase(SLNode** pphead, SLNode* pos);
void SLTDestroy(SLNode** pphead);

SList.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"SList.h"

SLNode* BuySListNode(SLTDateType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->val = x;
	newnode->next = NULL;
	return newnode;
}

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

void SLTPushBack(SLNode** pphead, SLTDateType x)
{
	assert(pphead);

	SLNode* newnode = BuySListNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

void SLTPushFront(SLNode** pphead, SLTDateType x)
{
	assert(pphead);

	SLNode* newnode = BuySListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

void SListPopBack(SLNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	//一个结点
	//多个结点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLNode* prev = NULL;
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		prev->next = NULL;
	}
}

void SListPopFront(SLNode** pphead)
{
	assert(pphead);
	assert(*pphead);

	SLNode* next = (*pphead)->next;
	free(*pphead);
	(*pphead) = next;
}

SLNode* SListFind(SLNode* phead, SLTDateType x)
{
	SLNode* cur = phead;
	while (cur->next != NULL)
	{
		if (cur->val == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

void SListInsertAfter(SLNode* pos, SLTDateType x)
{
	assert(pos);

	SLNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;

}

void SListEraseAfter(SLNode* pos)
{
	assert(pos);
	assert(pos->next);

	SLNode* tmp = pos->next;
	pos->next = pos->next->next;

	free(tmp);
	tmp = NULL;
}
//在pos前插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLTDateType x)
{
	assert(pphead);
	assert(pos);
	assert(*pphead);

	if (*pphead == pos)
	{
		//头插
		SLTPushFront(pphead, x);
	}
	else
	{
		SLNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLNode* newnode = BuySListNode(x);
		newnode->next = pos;
		prev->next = newnode;
	}
}

void SLTErase(SLNode** pphead, SLNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);

	if (*pphead == pos)
	{
		//头删
		SListPopFront(pphead);
	}
	else
	{
		SLNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

void SLTDestroy(SLNode** pphead)
{
	assert(*pphead);

	SLNode* cur = *pphead;
	while (cur)
	{
		SLNode* next = cur->next;
		free(cur);
		cur = next;;
	}

	*pphead = NULL;
}

4.带头双向循环链表代码合集

List.h

#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
#include

typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType val;
}LTNode;

// 创建返回链表的头结点.
LTNode* LTCreate();

// 双向链表销毁
void LTDestory(LTNode* phead);

// 双向链表打印
void LTPrint(LTNode* phead);

// 双向链表尾插
void LTPushBack(LTNode* phead, LTDataType x);

// 双向链表尾删
void LTPopBack(LTNode* phead);

// 双向链表头插
void LTPushFront(LTNode* phead, LTDataType x);

// 双向链表头删
void LTPopFront(LTNode* phead);

// 双向链表查找
LTNode* LTFind(LTNode* phead, LTDataType x);

// 双向链表在pos的前面进行插入
void LTInsert(LTNode* pos, LTDataType x);

// 双向链表删除pos位置的节点
void LTErase(LTNode* pos);

List.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"List.h"

LTNode* CreateLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->val = x;
	return newnode;
}
LTNode* LTCreate()
{
	LTNode* phead = CreateLTNode(-1);

	phead->next = phead;
	phead->prev = phead;

	return phead;
}

void LTDestory(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
	//phead = NULL;
}

void LTPrint(LTNode* phead)
{
	assert(phead);
	printf("哨兵位<=>");
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d<=>", cur->val);
		cur = cur->next;
	}
	printf("\n");
}

void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	/*LTNode* tail = phead->prev;
	LTNode* newnode = CreateLTNode(x);

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;*/
	LTInsert(phead, x);
}

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	LTNode* tail = phead->prev;

	//tail->prev->next = phead;
	//phead->prev = tail->prev;
	//free(tail);
	//tail = NULL;
	LTErase(tail);
}

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	/*LTNode* first = phead->next;
	LTNode* newnode = CreateLTNode(x);
	
	newnode->next = first;
	first->prev = newnode;
	newnode->prev = phead;
	phead->next = newnode;*/
	LTInsert(phead->next, x);
}

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	LTNode* first = phead->next;

	/*phead->next = first->next;
	first->next->prev = phead;
	free(first);
	first = NULL;*/
	LTErase(first);
}

LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;

	while (cur != phead)
	{
		if (cur->val == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

void LTErase(LTNode* pos)
{
	assert(pos);

	LTNode* posNext = pos->next;
	LTNode* posPrev = pos->prev;

	posPrev->next = posNext;
	posNext->prev = posPrev;

	free(pos);
	pos = NULL;
}

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = CreateLTNode(x);
	
	LTNode* posPrev = pos->prev;
	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

三、顺序表与链表的优缺比较

顺序表

优点：支持随机访问

缺点：插入删除数据效率低，需要扩容，降低效率

链表

优点：插入删除数据效率高，空间利用率较高

缺点：不支持随机访问

总结：需要频繁访问元素的可以使用顺序表，需要任意位置插入删除的可以使用链表。