203. 移除链表元素（简单）
给你一个链表的头节点
head和一个整数val，请你删除链表中所有满足Node.val == val的节点，并返回 新的头节点 。
解法一、递归
见代码
链表的定义具有递归的性质，所以遍历也可以以递归的方式进行
class Solution {
public ListNode removeElements(ListNode head, int val) {
if(head == null){
return head;
}
head.next = removeElements(head.next,val);
return head.val == val ? head.next:head;
}
}
解法二、迭代
具体实现方面，由于链表的头节点 head 有可能需要被删除，因此创建哑节点 dummyHead，令 dummyHead.next=head，初始化 temp=dummyHead，然后遍历链表进行删除操作。最终返回 dummyHead.next 即为删除操作后的头节点。
——出自力扣官方题解
通过dummyHead的形式，使所有链表元素都不再是链表首，很聪明便捷的形式
也可以头节点另做考虑，先遍历所有之后的，最后判断头结点是不是，是则删除
class Solution {
public ListNode removeElements(ListNode head, int val) {
ListNode dummyHead = new ListNode(0);
dummyHead.next = head;
ListNode temp = dummyHead;
while (temp.next != null) {
if (temp.next.val == val) {
temp.next = temp.next.next;
} else {
temp = temp.next;
}
}
return dummyHead.next;
}
}
作者：力扣官方题解
链接：https://leetcode.cn/problems/remove-linked-list-elements/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。237. 删除链表中的节点（中等）
有一个单链表的
head，我们想删除它其中的一个节点node。给你一个需要删除的节点
node。你将 无法访问 第一个节点head。链表的所有值都是 唯一的，并且保证给定的节点
node不是链表中的最后一个节点。删除给定的节点。注意，删除节点并不是指从内存中删除它。这里的意思是：
- 给定节点的值不应该存在于链表中。
- 链表中的节点数应该减少 1。
node前面的所有值顺序相同。node后面的所有值顺序相同。
解法一、复制删除
脑筋急转弯题，把这个节点的值变成下一个节点，删掉下一个节点
class Solution {
public void deleteNode(ListNode node) {
ListNode temp = node.next;
node.val = temp.val;
node.next = temp.next;
}
}
19. 删除链表的倒数第 N 个结点（中等）
给你一个链表，删除链表的倒数第
n个结点，并且返回链表的头结点。进阶：你能尝试使用一趟扫描实现吗？
解法一、哈希
一遍扫描分别放入哈希，最后根据总数减n的关系直接取。注意倒数第n个是len-n+1,这里改的是它前一个节点的next，所以取len-n
写完才发现真没人用哈希。。感觉其实是栈的低配版本。
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
int num = 0;
HashMap<Integer,ListNode> hash = new HashMap<>();
ListNode temp = head;
while(temp != null){
num++;
hash.put(num,temp);
temp = temp.next;
}
if(n != num){
ListNode pre = hash.get(num - n);
pre.next = pre.next == null ? null : pre.next.next;
}else{
head = head.next;
}
return head;
}
}解法二、双次遍历
就常规意义的扫两次
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode dummy = new ListNode(0, head);
int length = getLength(head);
ListNode cur = dummy;
for (int i = 1; i < length - n + 1; ++i) {
cur = cur.next;
}
cur.next = cur.next.next;
ListNode ans = dummy.next;
return ans;
}
public int getLength(ListNode head) {
int length = 0;
while (head != null) {
++length;
head = head.next;
}
return length;
}
}
作者：力扣官方题解
链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/solutions/450350/shan-chu-lian-biao-de-dao-shu-di-nge-jie-dian-b-61/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。解法三、栈
pop开始计数弹出倒数
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode dummy = new ListNode(0, head);
Deque<ListNode> stack = new LinkedList<ListNode>();
ListNode cur = dummy;
while (cur != null) {
stack.push(cur);
cur = cur.next;
}
for (int i = 0; i < n; ++i) {
stack.pop();
}
ListNode prev = stack.peek();
prev.next = prev.next.next;
ListNode ans = dummy.next;
return ans;
}
}
作者：力扣官方题解
链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/solutions/450350/shan-chu-lian-biao-de-dao-shu-di-nge-jie-dian-b-61/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。解法四、双指针
一个指针快，一个指针慢，相距n格。处理逻辑比较复杂，既可以添加dummy，也可以全扫一遍 最后判断头是不是
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode dummy = new ListNode(0, head);
ListNode first = head;
ListNode second = dummy;
for (int i = 0; i < n; ++i) {
first = first.next;
}
while (first != null) {
first = first.next;
second = second.next;
}
second.next = second.next.next;
ListNode ans = dummy.next;
return ans;
}
}
作者：力扣官方题解
链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/solutions/450350/shan-chu-lian-biao-de-dao-shu-di-nge-jie-dian-b-61/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。430. 扁平化多级双向链表 （中等）
你会得到一个双链表，其中包含的节点有一个下一个指针、一个前一个指针和一个额外的 子指针 。这个子指针可能指向一个单独的双向链表，也包含这些特殊的节点。这些子列表可以有一个或多个自己的子列表，以此类推，以生成如下面的示例所示的 多层数据结构 。
给定链表的头节点 head ，将链表 扁平化 ，以便所有节点都出现在单层双链表中。让
curr是一个带有子列表的节点。子列表中的节点应该出现在扁平化列表中的curr之后 和curr.next之前 。返回 扁平列表的
head。列表中的节点必须将其 所有 子指针设置为null。
解法一、栈+递归
每次拼接有不必要的多次扫描
对于每个遍历到的i，如果有子节点，把next进栈，递归并返回子节点的头，然后一路推到尾；如果是这一行最后一个，且栈不为空，则出栈然后拼接。
class Solution {
static Deque<Node> st = new ArrayDeque<>();
public static Node flatten(Node head) {
Node i = head;
while(i != null){
if(i.child != null){
if(i.next != null){
st.push(i.next);
}
i.next = flatten(i.child);
i.next.prev = i;
i.child = null;
while(i!=null){
i = i.next;
}
}
if(i != null && i.next == null && !st.isEmpty()){
i.next = st.pop();
i.next.prev = i;
}
if(i != null)i = i.next;
}
return head;
}
}
解法二、栈
遇子节点则next入栈，遍历结束子节点后，把栈pop出来拼接。
class Solution {
public Node flatten(Node head) {
Node node = head;
Node prev = null;
Deque<Node> stack = new ArrayDeque<>();
while (node != null || !stack.isEmpty()) {
if (node == null) {
node = stack.pop();
node.prev = prev;
prev.next = node;
}
if (node.child != null) {
if (node.next != null) stack.push(node.next);
node.child.prev = node;
node.next = node.child;
node.child = null;
}
prev = node;
node = node.next;
}
return head;
}
}解法三、递归（DFS）
见注释。解法一之所以会对末尾进行重复的多次遍历，是因为返回的是头，则另外写一个dfs函数、返回尾即可。
class Solution {
public Node flatten(Node head) {
dfs(head);
return head;
}
public Node dfs(Node node) {
Node cur = node;
// 记录链表的最后一个节点
Node last = null;
while (cur != null) {
Node next = cur.next;
// 如果有子节点，那么首先处理子节点
if (cur.child != null) {
Node childLast = dfs(cur.child);
next = cur.next;
// 将 node 与 child 相连
cur.next = cur.child;
cur.child.prev = cur;
// 如果 next 不为空，就将 last 与 next 相连
if (next != null) {
childLast.next = next;
next.prev = childLast;
}
// 将 child 置为空
cur.child = null;
last = childLast;
} else {
last = cur;
}
cur = next;
}
return last;
}
}
作者：力扣官方题解
链接：https://leetcode.cn/problems/flatten-a-multilevel-doubly-linked-list/solutions/1013884/bian-ping-hua-duo-ji-shuang-xiang-lian-b-383h/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。碎碎念
- 还是不熟悉DFS···203只要学习到dummyHead即可（或者其他处理方式）237很巧妙，属于会就半分钟，不会就是不会，对见过的要求很大。19是多元化处理，430暴露了我学艺不精，两个方法分拆都很容易，合在一起就很没必要了，反而复杂。
- 感觉链表的重要方式：栈,DFS，dummy
