day02

1. 合并两个有序链表

public class Task01 {

    public static void main(String[] args) {
        ListNode node01 = new ListNode(1);
        ListNode node02 = new ListNode(1);
        ListNode node03 = new ListNode(2);
        ListNode node04 = new ListNode(3);
        ListNode node05 = new ListNode(4);
        ListNode node06 = new ListNode(4);

        node01.next = node03;
        node03.next = node05;

        node02.next = node04;
        node04.next = node06;


        ListNode node = mergeTwoLists(node01, node02);


        transverse(node);
    }

    public static ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) return l2;
        if (l2 == null) return l1;

        ListNode head = null;
        if (l1.val <= l2.val) {
            head = l1;
            head.next = mergeTwoLists(l1.next, l2);
        } else {
            head = l2;
            head.next = mergeTwoLists(l1, l2.next);
        }
        return head;
    }

    public static void transverse(ListNode node){

        ListNode curr = node;

        while (curr != null){
            System.out.println(curr.val);
            curr = curr.next;
        }
    }
}

class ListNode {
    int val;
    ListNode next;

    public ListNode(int x) {
        val = x;
    }
}

2. 删除链表的倒数第N个节点

/**
     * 数据结构里面首先给定两个指针p和q分别都指向这个链表的头节点，
     * 然后若想求出这个链表的倒数第N个节点，方法就是先让p向后挪N个位置，q不动。
     *
     * 因为N总是可达的，所以会有俩种情况，
     *
     * 1、这个链表就只有N个节点
     *
     * 2、这个链表有大于N个节点
     *
     * 如果是第一种情况，则需要删除的倒数第N个节点就是头结点，所以head=head.next；删除头结点；
     *
     * 如果是第二种情况，则p继续向后挪动，q也紧跟着向后挪动，
     * 此时当p向后挪动到链表尾部时停止，此时q指的位置就是该链表的倒数第N个节点，
     * 所以q.next=q.next.next;即删除了该节点，
     *
     * @param head
     * @param n
     * @return
     */
    public ListNode removeNthFromEnd(ListNode head, int n) {

        ListNode p = head;
        ListNode q = head;

        for (int i = 0; i < n; i++) {
            p = p.next;
        }

        if(p == null){
            head = head.next;
        }

        while (p.next != null){

            p = p.next;
            q = q.next;
        }
        q.next = q.next.next;

        return head;
    }

3. 旋转链表

public ListNode rotate(ListNode head, int n){
        ListNode curr = head;
        int num = 0;
        ListNode end = null; //找到最后节点
        while (curr != null){
            if(curr.next == null){
                end = curr;
            }
            curr = curr.next;
            num ++;
        }
        end.next = head;//最后节点的下一个节点为首节点
        //6个元素，向右移动4步和向左移动2步效果一样
        for (int i = 0; i <(num - n%num); i++){
            head = head.next;
        }
        
        return head;
    }