数据结构-------链表

书摘

人生如棋。棋盘上的胜与负，荣与辱，喜与悲，的确是人生或亮或暗色彩的折射。只有自己担当了一切的棋局，才有意思；只有自己担当了一切的人生，才是真正有价值的。成为自己的最高评判者，不在乎他人的喋喋不休，才能以一个完整的人的身份，享受胜利，荣辱和喜悦。

链表的结构

链表的每一个元素包含一个数据成员和指向下一个元素的指针，每一个元素也叫做一个节点。
如下：

template <class T>
struct ListNode
{
	T data;	//用于存储数据
	ListNode* next;	//指向下一个节点的指针
	/*构造函数*/
	ListNode(T x):data(x), next(nullptr){}
};
/*由于是模板化的结构体，不可以使用typedef重命名哦！*/
typedef ListNode<T>* pListNode; //会报错，无法为pListNode分配内存空间

图解：一个完整的链表包括一个头节点和存储数据的节点。
@头节点是一个ListNode类型的指针，其中不储存元素，它的存在只是为了方便对于链表操作。
@最后一个节点的next指针是nullptr，代表链表的尽头，因为没有下一个节点了。

创建链表

头插法创建链表

头插法创建链表是把每一个节点都插入到现有链表的head后面。头插法的特点就是链表中数据的顺序和原数据顺序相反
如下是插入一个节点的效果：

代码实现：

template <class T> 
//从数组创建链表
ListNode<T>* ListNode_CreateHeadInsert(T arr[], int n)
{
	//创建头节点
	ListNode<T>* Head = new ListNode<T>;
	
	//尽量避免直接操作头节点Head，这里用temp来代替Head完成需要的操作
	ListNode<T>* temp = Head;
	
	for(int i = 0; i < n; ++i)
	{
		//调用构造函数来初始化节点的Data成员。
		ListNode<T>* p = new ListNode<T>(arr[i]);
		
		//下面两句的顺序要注意！！先为p->next赋值。
		p->next = temp->next;
		temp->next = p;
	}
	//返回头节点信息。
	return Head;	
}

尾插法创建链表

把每一个节点插入到链表尾部。
效果如下：

代码实现：

template <class T>
ListNode<T>* ListNode_CreateEndingInsert(T arr[], int n)
{
	//头节点
	ListNode<T>* Head = new ListNode<T>;
	//temo存储的是链表的最后一个节点
	ListNode<T>* temp = Head;
	for(int i = 0; i < n; ++i)
	{
		ListNode<T>* p = new ListNode<T>(arr[i]);
		temp->next = p;
		temp = p;
	}
	return Head;
}

链表技巧

此处介绍一些基本的链表操作，为初学者拓展一下思路。

翻转链表

翻转链表是一个非常常用的操作，比如原来的链表数据是1，2，3翻转后是3，2，1。
代码的编写有两种，一种是递归的，一种是不递归的，先介绍不递归的来说明原理，在来递归简化代码量。

== 非递归代码==
遍历一个链表然后用头插法创建一个新的链表就是翻转。

template <class T>
ListNode<T>* ListNode_Toggle(ListNode<T>* Head)
{
	//新链表的头
	ListNode<T>* Head2;
	ListNode<T>* temp = Head->next;	//存储遍历到的节点信息
	ListNode<T>* p;	//存储temp的下一个节点信息
	while(temp)	//next不是nullptr
	{
		p = temp->next；
		temp->next = Head2->next;	//头插法
		Head2->next = temp;
		temp = p;
	}
	return Head2;
}

递归代码

template <class T>
ListNode<T>* ListNode_Toggle(ListNode<T>* Head, ListNode<T>* prev = nullptr)
{
	if(!Head)	//递归的break条件
		return prev;
	ListNode<T>* next = Head->next;
	Head->next = prev;
	return ListNode_Toggle(next, Head);
}

判断两个链表是否相交

就是判断两个链表有没有共同的点，如下的链表经过 a + b + c 个步骤找到共同点。
过程：创建两个指针p1和p2分别指向head1和head2，当p1或者p2走到链表的尽头，令其指向另一个头Head2或者Head1，p1和p2相遇的地方就是交点。

代码实现：

//有共同节点返回节点信息，没有共同节点返回nullptr
ListNode<T>* ListNode_Intersection(ListNode<T>* Head1, ListNode<T>* Head2)
{
	ListNode<T>* p1 = Head1;
	ListNode<T>* p2 = Head2;
	while(p1 != p2)
	{
		p1 = (p1? p1->next : Head2);	//括号里是if条件句的缩写哈
		p2 = (p2? p2->next : Head1); 
	}
	return p1;
}

判断一个链表是否存在环

具体的解释看这篇博客
floyd判圈算法

回文链表

回文链表是一种对称的链表例如 1，2，3，2，1.
实质是将链表翻转后和原来的链表做比较如果相同则是回文链表。

//需要调用上面的ListNode_Toggle函数
bool ListNode_Palindrome(ListNode<T>* Head)
{
	ListNode<T>* Head2 = ListNode_Toggle(Head);
	ListNode<T>* temp1 = Head;
	ListNode<T>* temp2 = Head2;
	while(temp1)
	{
	//if条件句
		temp1->data == temp2->data ? {
			temp1 = temp1->next;
			temp2 = temp2->next;
		}:return flase;
	}
	return true;
}

总结

链表不难，只要掌握了基本操作接下来的学习会简单很多。重要的是不要直接操作头节点，而是建立指针变量来操作链表！