数据结构之链表

线性表之链表

【本节目标】

1. .链表表示和实现（单链表+双向链表）
2. 链表的常见OJ题
3. 顺序表和链表的区别和联系

1.链表表示和实现（单链表+双向链表）

顺序表的问题及思考
问题：

1. 中间/头部的插入删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
   思考：
   如何解决以上问题呢？下面给出了链表的结构来看看。

1.1 链表的概念及结构

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

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

1. 单向、双向
2. 带头、不带头
3. 循环、非循环
   
   
   虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：
   
   1.无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结
   构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
   2.带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都
   是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带
   来很多优势，实现反而简单了，后面我们代码实现了就知道了。

1.2单链表的实现

// 1、无头+单向+非循环链表增删查改实现
typedef int SLTDateType;
typedef struct SListNode
{
 SLTDateType data;
 struct SListNode* next;
}SListNode;
// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之前插入x
void SListInsert(SListNode** pplist, SListNode* pos, SLTDateType x);
// 单链表删除pos位置的值
void SListErase(SListNode** pplist, SListNode* pos);

1.3 双向链表的表示和实现

这里只给出实现代码，看不懂的可以参考这位老兄的文章·····

// 2、带头+双向+循环链表增删查改实现
#include<stdio.h>
#include<malloc.h>
#include<assert.h>

typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prve;
	LTDataType data;
}ListNode;


ListNode* ListInit();
void ListDestory(ListNode* plist);
void ListPrint(ListNode* plist);
void ListPushBack(ListNode* plist, LTDataType x);
void ListPushFront(ListNode* plist, LTDataType x);
void ListPopBack(ListNode* plist);
void ListPopFront(ListNode* plist);
ListNode* ListFind(ListNode* plist,LTDataType x);
void ListInsert(ListNode* pos, LTDataType x);//在pos 位置之前插入x
void ListErase(ListNode* pos);

完整代码实现

#include"List.h"
ListNode* BuyListNode(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	newnode->data = x;
	newnode->next = NULL;
	newnode->prve = NULL;

	return newnode;
}
void ListPrint(ListNode* plist)
{
	ListNode* cur = plist->next;
	while (cur != plist)
	{
		printf("%d-> ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
ListNode* ListInit()
{
	ListNode* phead = BuyListNode(0);
	phead->next = phead;
	phead->prve = phead;
	return phead;
}
void ListDestory(ListNode* plist)
{
	assert(plist);
	ListNode* cur = plist->next;
	while (cur != plist)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
}
void ListPushBack(ListNode* plist, LTDataType x)
{
	assert(plist);
	/*ListNode* tail = plist->prve;
	ListNode* newnode = BuyListNode(x);
	tail->next = newnode;
	newnode->prve = tail;
	newnode->next = plist;
	plist->prve = newnode;*/
	ListInsert(plist, x);
}

void ListPushFront(ListNode* plist, LTDataType x)
{
	/*assert(plist);
	ListNode* first = plist->next;
	ListNode* newnode = BuyListNode(x);
	plist->next = newnode;
	newnode->prve = plist;
	newnode->next = first;
	first->prve = newnode;*/
	ListInsert(plist->next, x);
}
void ListPopFront(ListNode* plist)
{
	/*assert(plist);
	assert(plist->next != plist);
	ListNode* first = plist->next;
	ListNode* second = first->next;
	plist->next = second;
	second->prve = plist;
	free(first);
	first = NULL;*/
	ListErase(plist->next);

}

void ListPopBack(ListNode* plist)
{
	/*assert(plist);
	assert(plist->next != plist);
	ListNode* tail = plist->prve;
	ListNode* prev = tail->prve;
	prev->next = plist;
	plist->prve = prev;
	free(tail);
	tail = NULL;*/
	ListErase(plist->prve);
}

ListNode* ListFind(ListNode* plist, LTDataType x)
{
	assert(plist);
	ListNode* cur = plist->next;
	while (cur != plist)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
void ListInsert(ListNode* pos, LTDataType x) 
{
	assert(pos);
	ListNode* prev = pos->prve;
	ListNode* newnode = BuyListNode(x);
	prev->next = newnode;
	newnode->prve = prev;
	newnode->next = pos;
	pos->prve = newnode;

}//在pos 位置之前插入x
void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* prev = pos->prve;
	ListNode* next = pos->next;
	prev->next = next;
	next->prve = prev;
	free(pos);
	pos = NULL;

}

测试代码

#include"List.h"


void Test1()
{
	ListNode* plist = ListInit();
	
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	/*ListPushBack(plist, 5);
	ListPushBack(plist, 6);
	ListPushFront(plist, 0);*/
	ListPushFront(plist, 0);
	ListPrint(plist);
	/*ListPushFront(plist,8);
	ListPrint(plist);
	ListPopFront(plist);
	ListPrint(plist);
	ListPopBack(plist);
	ListPrint(plist);
	ListDestory(plist);*/

}
void Test2()
{
	ListNode* plist = ListInit();

	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPrint(plist);
	ListNode* pos = ListFind(plist, 3);
	if (pos)
	{
		pos->data = 30;
		printf("找到了！修改数据为*10\n");
	}
	else {
		printf("找不到\n");
	}
	ListPrint(plist);
	ListInsert(pos, 300);
	ListPrint(plist);
	ListErase(pos);
	ListPrint(plist);

}

int main(void)
{
	Test2();

	return 0;
}

2.链表的常见OJ题

1.反转单链表

2.链表的中间结点

3.合并两个有序链表

3.顺序表和链表的区别和联系

顺序表：
优点：
空间连续、支持随机访问
缺点：

1. 中间或前面部分的插入删除时间复杂度O(N)
2. 2.增容的代价比较大。
   链表：
   缺点：
   以节点为单位存储，不支持随机访问
   优点：
3. 任意位置插入删除时间复杂度为O(1)
4. 没有增容消耗，按需申请节点空间，不用了直接释放。