代码随想录算法训练营第3天 | 链表1

链表

链表：链表是一种通过指针串联在一起的线性结构。
1. 单链表
每一个节点由两部分组成，一个是数据域，一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向空指针。
2. 双链表
每一个节点有一个数据域、两个指针域。指针域，一个指向下一个节点，一个指向上一个节点。
双链表既可以向前查询也可以向后查询。
3. 循环链表
链表首尾相连，最后一个节点的指针指向第一个节点。
链表存储方式：链表在内存中不是连续分布的，散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理想，通过指针域的指针链接在内存中的各个节点。

	插入/删除	查询	适用场景
数组	O(n)	O(1)	数据量固定，频繁查询，较少增删
链表	O(1)	O(n)	数据量不固定，频繁增删，较少查询

链表定义

struct ListNode{
	int val;//节点上存储的元素
	ListNode* next;//指向下一个节点的指针
	ListNode(int x) : val(x), next(NULL){}//节点构造函数
};

通过自己定义的构造函数初始化节点：

ListNode* node = new ListNode(5);

使用默认构造函数初始化节点：

ListNode* node = new ListNode();
node->val = 5;

206.反转链表

题目： 给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点。
链接： https://leetcode.cn/problems/UHnkqh/
思路： 双指针法

1. 反转链表记住两个要点
   ①暂存下一个节点
   ②改变指针指向
2. 涉及到的一直记不住的点
   ①节点初始化：节点curr初始化为head，沿着链表从head节点开始往后遍历；节点prev初始化为nullptr，在while循环的过程中不断被赋值为curr刚刚走过的节点。
   ②返回谁：要时刻清楚curr和prev走到哪里了，链表的指向是啥样的。

class Solution {
public:
	ListNode* reverseList(ListNode* head) {
		ListNode* prev = nullptr;
		ListNode* curr = head;
		while(curr != nullptr){
			//暂存下一个节点
			ListNode* next = curr->next;
			//改变指针指向
			curr->next = prev;
			prev = curr;
			curr = next;
		}
		return prev;
	}
};

203.移除链表元素

题目： 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
链接： https://leetcode.cn/problems/remove-linked-list-elements/
思路： 沿着链表从head开始往后遍历，遇到val就把前一个的next指向后一个节点。
①如果删除的是头结点又该怎么办呢？

• 直接使用原来的链表来进行删除操作： 只要将头结点向后移动一位就可以，这样就从链表中移除了一个头结点。
• 设置一个虚拟头结点在进行删除操作： 原链表的所有节点就都可以按照统一的方式进行移除。
  ②记得从内存中删除这两个移除的节点！！！

//设置虚拟头
class Solution {
public:
	ListNode* removeElements(ListNode* head, int val) {
		ListNode* dummyHead = new ListNode(0);
		dummyHead->next = head;
		ListNode* curr = dummyHead;
		while(curr->next != nullptr){
			if(curr->next->val == val){
				ListNode* temp = curr->next;
				curr->next = curr->next->next;
				delete temp;
			}
			else{
				curr = curr->next;
			}
		}
		head = dummyHead->next;
		delete dummyHead;
		return head;
	}
};

707.设计链表

class MyLinkedList {
public:
struct LinkedNode{
		//定义链表
		int val;
		LinkedNode* next;
		LinkedNode(int x): val(x), next(nullptr){}
	};
	MyLinkedList() {
		_dummyHead = new LinkedNode(0);//定义一个虚拟头节点
		_size = 0;//计算链表长度
	}
	//获取链表中第index个节点的值
	int get(int index) {
	if (index > _size - 1 || index < 0) {
		return -1;
	}
	LinkedNode* curr = _dummyHead->next;
	while(index--){
		curr = curr->next;
	}
	return curr->val;
}

//在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新头节点
void addAtHead(int val) {
	LinkedNode* head = new LinkedNode(val);
	head->next = _dummyHead->next;
	_dummyHead->next = head;
	_size++;
}

//在链表最后面添加一个节点
void addAtTail(int val) {
	LinkedNode* tail = new LinkedNode(val);
	LinkedNode* curr = _dummyHead;
	while(curr->next != nullptr){
		curr = curr->next;//遍历整个链表找到原来的尾节点
	}
	curr->next = tail;
	_size++;
}

//在链表中第index个节点之前添加值为val的节点，根据index的值做一个区分
void addAtIndex(int index, int val) {
	if(index > _size){
		return;
	}
	if(index < 0){
		addAtHead(val);
	}
	LinkedNode* newNode = new LinkedNode(val);
	LinkedNode* curr = _dummyHead;
	while(index--){
		curr = curr->next;
	}
	LinkedNode* temp = curr->next; //暂存后面的节点
	curr->next = newNode;
	newNode->next = temp;
	_size++;
}

void deleteAtIndex(int index) {
	if(index >= _size || index < 0){
		return;
	}
	LinkedNode* curr = _dummyHead;
	while(index--){
		curr = curr->next;
	}
	LinkedNode* temp = curr->next; //暂存后面的节点
	curr->next = curr->next->next;
	delete temp;
	_size--;
}

private:
	int _size;
	LinkedNode* _dummyHead;
};