Leetcode学习之链表（1）

开宗明义：本系列基于小象学院林沐老师课程《面试算法 LeetCode 刷题班》，刷题小白，旨在理解和交流，重在记录，望各位大牛指点！

---

Leetcode学习之链表（1）

---

---

链表的定义

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。

链表是由一个 head 指针变量和许多节点组成。每个节点有许多元素，最后一个元素是一个指向下一个节点首地址的指针，第一个节点的首地址交给head，末尾的指针指向第二个节点的首地址，以此类推，到达最后一个节点，最后一个节点的末尾指针指向 NULL。

一条链表必须有一个 head 指针才能寻找到第一个节点，否则无法进行链表的访问，并且每个节点的末尾指针必须指向下一个节点的首地址，否则就无法进行链式访问数据，并且最后一个节点的末尾指针必须指向NULL，避免指针指向未知区域。

链表的分类：

---

1、链表基础

定义一个结构体指针 p，将一个结构体变量的变量名赋给 p，则此时 p 指向的是结构体的首地址，如果对想通过结构体指针p来访问该结构体变量的成员，就需要进行节引用运算。方法如下:

1. (*p). 成员名
2. p -> 成员名

测试代码：

#include <stdio.h>
#include <iostream>
//先定义一个节点结构体，这个结构体可以存放数据和末尾指针 
struct ListNode {
	int val;  //存储元素的数据域
	//float score;
	struct ListNode *next;  //存储下一节点地址的指针域  
};

//struct ListNode {
//	int val;  //存储元素的数据域
//	ListNode *next;  //存储下一节点地址的指针域  
//};

int main()
{
	ListNode a, b, c, d, e;
	a.val = 10;
	b.val = 20;
	c.val = 30;
	d.val = 40;
	e.val = 50;
	a.next = &b;//b链表的地址
	b.next = &c;
	c.next = &d;
	d.next = &e;
	e.next = NULL;//最后一个节点指针指向NULL，避免指向未知区域
	
	ListNode *head = &a;//一条链表必须有一个 head 指针才能寻找到第一个节点，否则无法进行链表的访问。
	while (head)
	{
		printf("%d\n",head->val);//这边涉及结构体的解析
		head = head->next;
		//printf("%d\n", (*head).val);//这边涉及结构体的解析
		//head = (*head).next;
	}
	system("pause");
	return 0;
}

效果图：

---

2、链表逆序 LeetCode 206

题目来源：$LeetCode206.ReserveLinkedList$
题目描述：已知链表头节点指针head，将链表逆序（不可申请额外空间）。
要求描述：

2.1 解决思路① 就地逆置法

依次遍历链表节点，每遍历一个节点即逆置一个节点。这就需要设置新建一个节点指针，这个节点指针指向空地址，中间还需要设置一个临时链表节点指针做过渡。

测试代码：

#include <stdio.h>
#include <iostream>
//先定义一个节点结构体，这个结构体可以存放数据和末尾指针 
struct ListNode {
	int val;  //存储元素的数据域
	ListNode *next;  //存储下一节点地址的指针域  
	ListNode(int x) :val(x), next(NULL) {}  //默认构造函数
	//在C++中，结构体和类有很多相似之处，如结构体也可以有构造函数和析够函数，类中成员变量默认为私有，而结构体中则为公有
	//所以在定义一个新的结构体实例时，会自动执行其构造函数ListNode(int x);进行初始化。
	//关于val(x), next(NULL)这叫“初始化列表”，和在构造函数里面直接赋值效果是一样的，但是用初始化列表更好
};

class Solution {
public://这个函数形式表示返回的是一个指针
	ListNode* reverseList(ListNode* head){
		//新建一个节点，这个节点指向空地址
		ListNode *new_head = NULL;
		while (head)
		{//这边取个指针做过渡
			ListNode *next = head->next;//备份当前节点指向下一个节点的地址；
			head->next = new_head;  //这就是第一个new_head指向 NULL 的意义
			new_head = head;//把new_head这个指针向前移动一个
			head = next;//head这个也向前移动一个
		}
		return new_head;//返回新链表头节点
	}
};

int main()
{
	ListNode a(1), b(2), c(3), d(4), e(5);//构造函数
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	e.next = NULL;
	Solution solve;//类
	ListNode *head1 =&a;//链表的第一个节点
	//display
	while (head1) 
	{	
		printf("%d\n", head1->val);
		head1 = head1->next;
	}
	ListNode *head2 = NULL;
	head2=solve.reverseList(&a);
	printf("反转后：\n");
	while (head2)
	{
		printf("%d\n", head2->val);
		head2 = head2->next;
	}
	system("pause");
	return 0;
}

效果图：

2.2 解决思路② 头插法

设置一个临时头节点(temp_head)，利用head指针遍历链表，每遍历一个节点就将该节点插入到temp_head之中。
测试代码：

// 头插法

#include <stdio.h>
#include <iostream>
//先定义一个节点结构体，这个结构体可以存放数据和末尾指针 
struct ListNode {
	int val;  //存储元素的数据域
	ListNode *next;  //存储下一节点地址的指针域  
	ListNode(int x) :val(x), next(NULL) {}  //默认构造函数
											//在C++中，结构体和类有很多相似之处，如结构体也可以有构造函数和析够函数，类中成员变量默认为私有，而结构体中则为公有
											//所以在定义一个新的结构体实例时，会自动执行其构造函数ListNode(int x);进行初始化。
											//关于val(x), next(NULL)这叫“初始化列表”，和在构造函数里面直接赋值效果是一样的，但是用初始化列表更好
};

class Solution {
public:
	ListNode* reverseList(ListNode* head) {
		ListNode temp_head(0);//设置一个临时节点
		while (head)
		{
			ListNode *next = head->next;
			head->next = temp_head.next;
			temp_head.next = head;
			head = next;
		}
		return temp_head.next;
	}
};

---

3、链表求固定长度的逆序 LeetCode 92

题目来源：$LeetCode92.ReserveLinkedListII$
题目描述：已知链表头节点指针 $head$，将链表从位置 $m$ 到 $n$ 逆序(不申请额外空间)。
要求描述：

解决思路：

测试代码：

#include <stdio.h>
#include <iostream>

struct ListNode {
	int val;  //存储元素的数据域
	ListNode *next;  //存储下一节点地址的指针域  
	ListNode(int x) :val(x), next(NULL) {}  //默认构造函数
};

class Solution {
public:                      //链表头指针，从 m 逆至到 n 
	ListNode* reverseBetween(ListNode *head, int m, int n) {
		int change_len = n - m + 1;//计算需要逆置的节点个数
		ListNode *pre_head = NULL;//初始化开始逆置的节点的前驱
		ListNode *result = head;//最终转换后的链表头节点，非特殊情况即为head，换句话说就是返回的节点头
		while (head && --m)  //将head向前移动m-1个位置
		{
			pre_head = head;//记录head的前驱
			head = head->next;
		}
		//
		ListNode *modify_list_tail = head;//将modify_list_tail指向当前的head，即逆置前的链表头，逆置后的链表尾。
		ListNode *new_head = NULL;  //这边只是一个指针

		while (head && change_len)//逆置change_len个节点
		{
			ListNode *next = head->next;
			head->next = new_head;
			new_head = head;
			head = next;
			change_len--;//每完成一个节点逆置，chang_len--
		}
		modify_list_tail->next = head;//modify_list_tail逆置后的链表尾。此时head是逆置后的后一个元素

		if (pre_head)
		{//如果pre_head不为空，表示不是从第一个节点开始逆置的，也就是 m > 1。
			pre_head->next = new_head;  //new_head是反转后的第一个,将逆置链表开始的节点前驱与逆置后的头节点相连
		}
		else
		{//pre_head为空。说明m = 1,从第一个节点开始逆置
			result = new_head;//结果即为逆置后的头节点
		}
		return result;
	}
};

int main()
{
	ListNode a(1), b(2), c(3), d(4), e(5);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	Solution solve;
	ListNode *head = solve.reverseBetween(&a, 2, 4);
	while (head)
	{
		printf("%d\n", head->val);
		head = head->next;
	}
	system("pause");
	return 0;
}

效果图：

---