本文源自本人的学习记录整理与理解，其中参考阅读了部分优秀的博客和书籍，尽量以通俗简单的语句转述。引用到的地方如有遗漏或未能一一列举原文出处还望见谅与指出，另文章内容如有不妥之处还望指教，万分感谢。
链表（Linked List）
- 链表是一种
链式存储的线性表，所有元素的内存地址不一定是连续的
链表.png
为什么内存地址不一定是连续的 ？
- 因为链表每添加一个元素就会新申请一个内存空间给这个元素使用。而不是像数组一样一次申请一段内存空间出来
链表的设计
接口设计.png
简单的链表实现：
typedef struct Nodes{
int itme;
struct Nodes *next;
}Node;
//创建链表
Node* create_list_head(void);
//创建新节点
Node* create_new_node(int node_data);
//头插法
int add_node_head(Node* head, Node* new_node);
//输出链表
void display_list(Node* head);
//创建链表
Node* create_list_head()
{
Node* head = (Node*)malloc(sizeof(Node));
if(NULL != head)
{
head->itme= -1;
head->next= NULL;
}
return head;
}
//创建新节点
Node* create_new_node(int node_data)
{
Node* new_node = (Node*)malloc(sizeof(Node));
if(NULL != new_node)
{
new_node->itme= node_data;
new_node->next= NULL;
}
return new_node;
}
//头插法
int add_node_head(Node* head, Node* new_node)
{
if(NULL == head || NULL == new_node)
return -1;
new_node->next = head->next;
head->next = new_node;
return 0;
}
//打印链表数据
void display_list(Node* head)
{
if(NULL == head)
return;
Node* tmp = head;
printf("list data:");
while(NULL !=(tmp=tmp->next))
{
printf("%d ", tmp->itme);
}
printf("\n");
}
清空元素.png
添加元素，就需要先找到添加位置前面的节点
添加之前.png
添加之后.png
添加元素注意点：
注意点.png
删除元素：
- 方式一：将指向下一个节点的指针指向下一个节点的后继节点即可
- 方式二：直接覆盖掉要删除的节点
覆盖.png
//节点定义
public class ListNode{
int val; //节点中存储的值
ListNode next;//next指针指向下一个节点
ListNode(int x){
val = x;
}
}
237.删除链表中的节点
/**
https://leetcode-cn.com/problems/delete-node-in-a-linked-list/
请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。
现有一个链表 -- head = [4,5,1,9]，它可以表示为:
示例 1:
输入: head = [4,5,1,9], node = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:
输入: head = [4,5,1,9], node = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
说明:
链表至少包含两个节点。
链表中所有节点的值都是唯一的。
给定的节点为非末尾节点并且一定是链表中的一个有效节点。
不要从你的函数中返回任何结果。
*/
// 传入一个要删除节点
public void deleteNode(ListNode node) {
node.val = node.next.val; //后继节点的值覆盖要删除节点的值
node.next = node.next.next; //让要删除节点的next指向后继的后继
}
反转链表
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
反转链表逻辑.png
Java实现
迭代法：
public ListNode reverseList(ListNode head) {
ListNode prev = null;
ListNode curr = head;
while (curr != null) {
ListNode nextTemp = curr.next;
curr.next = prev;
prev = curr;
curr = nextTemp;
}
return prev;
}
-------------------------------
递归法：
public ListNode reverseList(ListNode head) {
//如果是空节点，或者是只有一个节点就返回本身
if (head == null || head.next == null) return head;
//递归拿到传入节点的下一个节点
ListNode newHead = reverseList(head.next);
//让传入节点的下一个节点的下一个节点指向传入节点
head.next.next = head;
//让传入节点的下一个节点的下一个节点指向null
head.next = null;
//返回传入节点的下一个节点
return newHead;
}
C语言实现：
Node *reverse_list(Node *head){
if (NULL == head) {
return nil;
}
Node *p = head->next;
Node *q = NULL;
while ((q = p->next)) {
p->next = q->next; //分离q
add_node_head(head, q);//将q插入到首元素位置
}
return head;
}
---------------------
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
Node *head = create_list_head();
if(NULL == head)
{
printf("create_list_head failed!\n");
return -1;
}
//填充数据（添加节点）
int i;
for(i=1; i<8; i++){
add_node_head(head, create_new_node(i));
}
//打印原来链表数据
printf("befor ");
display_list(head);
//反转链表
reverse_list(head);
printf("after ");
// 输出链表
display_list(head);
}
return 0;
}
判断一个链表是否有环
141. 环形链表
给定一个链表，判断链表中是否有环。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
示例 1
示例 2：
输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。
示例 2
示例 3：
输入：head = [1], pos = -1
输出：false
解释：链表中没有环。
示例 3
结题思路：快慢指针
快慢指针原理：快指针每次走两步，慢指针每次走一步；如果最终快指针和慢指针相遇就说明就有环；如果快指针先指向空节点，就说明链表没有环
生活中的例子：有环的链表就相当于是一个环形跑道，跑的慢的人最终肯定会被跑的快的同学追上哦
public boolean hasCycle(ListNode head) {
//头节点为空或头节点的后继节点为空，肯定不会有环；直接返回false
if (head == null || head.next == null) return false;
//慢指针指向头节点
ListNode slow = head;
//快指针指向头节点的后继
ListNode fast = head.next;
//开始循环跑圈
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
//快慢节点相同就返回true
if (slow == fast) return true;
}
//循环结束还是没有返回，就说明没有环咯
return false;
}
虚拟头结点
有时候为了让代码更加精简，统一所有节点处理逻辑，可以在最前面增加一个虚拟头节点(该节点是不存储数据的)，一般不怎么使用
虚拟头结点.png
