【算法】链表

链表倒序输出

这个比较简单，不加赘述，直接用递归就好，当然，你也可以用栈

 public static void  inorderTraverseList(ListNode head){
        if (head==null){
            return ;
        }
        inorderTraverseList(head.next);
        System.out.println(head.val);
    }
    public static void main(String[] args) {
        ListNode head = new ListNode(1, new ListNode(2, new ListNode(5, null)));
        inorderTraverseList(head);
    }

有序链表合并

合并两个有序链表有两种方式，一种方式是直接遍历两个链表，然后每次都把较小的那个值插入到链表中，不断迭代判断，直到某一条或者两条链表都为空，那么此时，数据已经有序，如果说两条链表长度不同，那么还没有遍历到链表尾的那一条链表的元素肯定比当前新链表的最大的节点还大，所以直接拼接到新链表的尾巴即可。

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummyNode = new ListNode(-1);
        ListNode pre = dummyNode;
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                pre.next = l1;
                pre = pre.next;
                l1 = l1.next;
            } else {
                pre.next = l2;
                pre = pre.next;
                l2 = l2.next;
            }
        }
        pre.next = l1 == null ? l2 : l1;
        return dummyNode.next;
    }

还有一种就是递归了，我们直到递归操作可以不断的遍历链表，遍历到链表最后的节点之后，在回退，因此，如果我们可以遍历到最大值，然后携带着每次的最大值再进行回退，是不是就可以做到每次拼接的下一个节点都是更大的值呢？
我们先简单的来一段链表递归倒叙遍历的代码

 public static void  inorderTraverseList(ListNode head){
        if (head==null){
            return ;
        }
        inorderTraverseList(head.next);
        System.out.println(head.val);
    }
    public static void main(String[] args) {
        ListNode head = new ListNode(1, new ListNode(2, new ListNode(5, null)));
        inorderTraverseList(head);
    }

因此，我们的终结条件其实就是，节点为空，那么直接代表着这个节点没有值了，但是另一个节点不一定，我们可以返回另一个节点。
同时我们不断比较大小的方式来判断当前节点的后面一个节点应该连接的是谁。
如果l1小，那么我们就让l1后移，而如果l2小，则l2后移。

    public static ListNode mergeTwoLists2(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        } else if (l2 == null) {
            return l1;
        } else if (l1.val < l2.val) {
            l1.next = mergeTwoLists2(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists2(l1, l2.next);
            return l2;
        }
    }

    public static void main(String[] args) {
        mergeTwoLists2(new ListNode(1,new ListNode(2,new ListNode(5,null))),
                new ListNode(2,new ListNode(4,new ListNode(5,null))) );
    }

链表反转

一个链表想要进行反转，那么就意味着， 原本的前驱节点，现在需要变为后继节点。
那么明显的，我们就需要保存一个pre作为原前驱节点，cur表示当前需要交换的节点。

  public static ListNode reverseList(ListNode head) {
  //开始时没有前驱节点
        ListNode prev = null;
 //头节点就是第一个要交换的节点
 //因为我们直到如果反转，那么头节点最后指向的是空
        ListNode curr = head;
        while (curr != null) {
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }

部分链表反转

同样的，如果我们已经得到了反转全部链表的代码，我们想要反转部分的链表内容，我们只需要截断完整链表，然后对这部分内容进行反转，在进行拼接即可。

  public ListNode reverseBetween(ListNode head, int left, int right) {
        // 因为头节点有可能发生变化，使用虚拟头节点可以避免复杂的分类讨论
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;

        ListNode pre = dummyNode;
        // 第 1 步：从虚拟头节点走 left - 1 步，来到 left 节点的前一个节点
        // 建议写在 for 循环里，语义清晰
        for (int i = 0; i < left - 1; i++) {
            pre = pre.next;
        }

        // 第 2 步：从 pre 再走 right - left + 1 步，来到 right 节点
        ListNode rightNode = pre;
        for (int i = 0; i < right - left + 1; i++) {
            rightNode = rightNode.next;
        }

        // 第 3 步：切断出一个子链表（截取链表）
        ListNode leftNode = pre.next;
        ListNode curr = rightNode.next;

        // 注意：切断链接
        pre.next = null;
        rightNode.next = null;

        // 第 4 步：同第 206 题，反转链表的子区间
        reverseLinkedList(leftNode);

        // 第 5 步：接回到原来的链表中
        pre.next = rightNode;
        leftNode.next = curr;
        return dummyNode.next;
    }

    private void reverseLinkedList(ListNode head) {
        // 也可以使用递归反转一个链表
        ListNode pre = null;
        ListNode cur = head;

        while (cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
    }

删除链表中间节点

给你一个链表，要求删除链表正中间的节点，比如链表为1，2，3，4，5，那么你需要删除3这个节点，如果链表为1，2，3，4，那么你需要删除3这个节点，也就是每次删除的节点的索引（从0开始）为list.length/2，向下取整。
对于这种刚刚好删除中间节点的方法，我们有两种解决思路，一种是暴力求链表长度，然后删除中间节点，另一种是使用快慢指针，快指针一次跳两个位置，慢指针一次跳一个位置，当快指针到链表尾后，慢指针刚刚好在链表中间。
代码如下：

package offer.list;

/**
 * @author: 张锦标
 * @date: 2023/7/3 9:55
 * DeleteMiddleNode类
 */
public class DeleteMiddleNode {
    //快慢指针删除中间节点
    //快指针一次性移动两个位置
    //慢指针一次一个位置
    public ListNode deleteMiddle1(ListNode head) {
        ListNode myHeader = new ListNode(0, head); // 哨兵
        ListNode p1 = myHeader;
        ListNode p2 = myHeader.next;
        while (p2 != null && p2.next != null) {
            p1 = p1.next;
            p2 = p2.next.next;
        }
        p1.next = p1.next.next;
        return myHeader.next;
    }
    //暴力
    public ListNode deleteMiddle(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode dummyNode = head;
        int length = getLength(dummyNode) / 2;
        if (length==0){
            return null;
        }
        while (--length > 0) { //1 2 3 4 5
            dummyNode = dummyNode.next;
        }
        if (dummyNode.next != null) {
            dummyNode.next = dummyNode.next.next;
        }
        return head;
    }

    public int getLength(ListNode head) {
        int count = 0;
        while (head != null) {
            count++;
            head = head.next;
        }
        return count;
    }
}