备战Java后端【Day2】

备战Java后端【Day2】

数据结构1-1

链表2

---

单链表的基本操作：

• 合并两个有序链表
• 合并k个有序链表
• 寻找单链表的中点
• 寻找单链表中的第k个节点
• 判断单链表是否包含环并找出环起点
• 判断两个单链表是否相交并找出交点

---

学习目标

• 复习Day1内容
• 寻找单链表的中点
• 寻找单链表中的第k个节点

---

学习内容

单链表操作

• 1. 创建链表类及节点： 在单链表中，我们首先要定义链表中最基础的节点元素。如上图所示，节点中包括两个属性，指针next和数据data。同时，我们可以在创建时定义链表的头节点、尾节点和链表长度。

//创建一个链表的类
class ListNode{
	int val;	//数值 data
	ListNode next;	// 结点 node
	ListNode(int x){//可以定义一个有参构造方法，也可以定义一个无参构造方法
		val = x;
	}
}

---

• 2. 判断链表是否为空： 判断链表为空的三种条件分别为：

• 带头节点的单链表：head->next==NULL
• 带头节点的循环链表：head->next==head
• 不带头节点的单链表：head==NULL

 public boolean isEmpty() {
        return isEmpty(first);
    }
    public static <E> boolean isEmpty(Node<E> head) {
        return head == null;
    }

---

• 3. 返回链表的长度： 遍历链表，直至它为空

public int size() {
        return size(first);
    }
    public static <E> int size(Node<E> head) {
        Node<E> temp = head;
        int size = 0;
        while (temp != null) {
            size++;
            temp = temp.next;
        }
        return size;
    }

---

• 4. 正向遍历链表： 正向遍历链表，直至链表为空

    public void printList() {
        Node<E> temp = first;
        while (temp != null) {
            System.out.println(temp.item);
            temp = temp.next;
        }
    }

---

• 5. 反向遍历链表： 反向遍历链表，直至到第一个节点的head

    /**
     * 因为要反向遍历链表，考虑使用递归，因为递归调用栈既是一个天然的先入后出的队列
     */
    public void printListReverse() {
        Node<E> temp = first;
        printListReverse(temp);
    }
    private void printListReverse(Node<E> e) {
        if (e != null) {
            printListReverse(e.next);
            System.out.println(e.item);
        }
    }

---

• 6. 链表头部添加节点： 如果头部节点为空，新加节点就是头节点；弱国头部节点不为空，则新加节点的next就是头节点，并且将头节点设置为新加节点。

public void addFirst(E e) {
        Node<E> temp = first;
        final Node<E> newNode = new Node<E>(e, null);
        if (temp == null) {
            first = newNode;
        }
        else {
            newNode.next = temp;
            first = newNode;
        }
    }

---

• 7. 链表尾部添加节点： 直接找到最后一个节点，添加到最后一个节点的next。如果链表长度为0，直接令first为新插入节点。

 public void addLast(E e) {
        Node<E> temp = first;
        Node<E> newNode = new Node<E>(e, null);
        if (temp == null) {
            first = newNode;
        }
        else {
            while (temp.next != null) {
                temp = temp.next;
            }
            temp.next = newNode;
        }
    }

---

• 8. 指定值的后面添加节点： 如果链表中已经有了重复的值，以排在最前面的为准。如果插入成功，则返回true；如果插入失败，则返回false；如果链表是空的，直接返回false。

    public boolean addBefore(E aimValue, E insertValue) {
        Node<E> temp = first;
        if (temp == null) {
            return false;
        }
        else {
            while (temp != null) {
                if (temp.item.equals(insertValue)) {
                    Node<E> newNode = new Node<E>(aimValue, null);
                    newNode.next = temp.next;
                    temp.next = newNode;
                    return true;
                }
                else {
                    temp = temp.next;
                }
            }
            return false;
        }
    }

---

• 9. 所有指定值的后面添加节点： 如果头节点为空，直接返回0；如果头节点不为空，那么链表中所有指定值的后面都添加节点，并返回插入值的个数。

    public int addBeforeAll(E aimValue, E insertValue) {
        // 插入值的个数
        int count = 0;
        if (first == null) {
            return 0;
        }
        else {
            Node<E> temp = first;
            while (temp != null) {
                if (temp.item.equals(aimValue)) {
                    Node<E> newNode = new Node<>(insertValue, null);
                    newNode.next = temp.next;
                    temp.next = newNode;
                    count++;
                    // 由于是在temp后面加了一个指定值，所以，要令temp = temp.next.next;
                    temp = temp.next.next;
                }
                else {
                    temp = temp.next;
                }
            }
        }
        return count;
    }

---

学习时间

2022年5月25日

• 下午3点-下午5点
• 晚上8点-晚上9点

---

学习产出

• 本文档链表基础知识和基础操作
• 力扣19题，删除链表的倒数第N个节点
• 力扣876题，链表的中间节点

---

今日刷题

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

• 从前往后寻找单链表的第 k 个节点很简单，一个 for 循环遍历过去就找到了，但是如何寻找从后往前数的第 k 个节点呢？那你可能说，假设链表有 n 个节点，倒数第 k 个节点就是正数第 n - k + 1 个节点，不也是一个 for 循环的事儿吗？

• 是的，但是算法题一般只给你一个 ListNode 头结点代表一条单链表，你不能直接得出这条链表的长度 n，而需要先遍历一遍链表算出 n 的值，然后再遍历链表计算第 n - k + 1 个节点。也就是说，这个解法需要遍历两次链表才能得到出倒数第 k 个节点。那么，我们能不能只遍历一次链表，就算出倒数第 k 个节点？可以做到的，如果是面试问到这道题，面试官肯定也是希望你给出只需遍历一次链表的解法。

• 这个解法就比较巧妙了，假设 k = 2，思路如下：
  首先，我们先让一个指针 p1 指向链表的头节点 head，然后走 k 步：
  
  现在的 p1，只要再走 n - k 步，就能走到链表末尾的空指针了对吧？
  趁这个时候，再用一个指针 p2 指向链表头节点 head：
  
  接下来就很显然了，让 p1 和 p2 同时向前走，p1 走到链表末尾的空指针时前进了 n - k 步，p2 也从 head 开始前进了 n - k 步，停留在第 n - k + 1 个节点上，即恰好停链表的倒数第 k 个节点上：
  
  这样，只遍历了一次链表，就获得了倒数第 k 个节点 p2。
  上述逻辑的代码如下

// 返回链表的倒数第 k 个节点
ListNode findFromEnd(ListNode head, int k) {
    ListNode p1 = head;
    // p1 先走 k 步
    for (int i = 0; i < k; i++) {
        p1 = p1.next;
    }
    ListNode p2 = head;
    // p1 和 p2 同时走 n - k 步
    while (p1 != null) {
        p2 = p2.next;
        p1 = p1.next;
    }
    // p2 现在指向第 n - k 个节点
    return p2;
}

当然，如果用 big O 表示法来计算时间复杂度，无论遍历一次链表和遍历两次链表的时间复杂度都是 O(N)，但上述这个算法更有技巧性。

---

接下来，正式看第19题。

• tips: 这个逻辑就很简单了，要删除倒数第 n 个节点，就得获得倒数第 n + 1 个节点的引用，可以用我们实现的 findFromEnd 来操作。
• tips: 不过注意我们又使用了虚拟头结点的技巧，也是为了防止出现空指针的情况，比如说链表总共有 5 个节点，题目就让你删除倒数第 5 个节点，也就是第一个节点，那按照算法逻辑，应该首先找到倒数第 6 个节点。但第一个节点前面已经没有节点了，这就会出错。
• tips: 但有了我们虚拟节点 dummy 的存在，就避免了这个问题，能够对这种情况进行正确的删除。

class Solution {
    // 主函数
    public ListNode removeNthFromEnd(ListNode head, int n) {
        // 虚拟头结点
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        // 删除倒数第 n 个，要先找倒数第 n + 1 个节点
        ListNode x = findFromEnd(dummy, n + 1);
        // 删掉倒数第 n 个节点
        x.next = x.next.next;
        return dummy.next;
    }

    // 返回链表的倒数第 k 个节点
    ListNode findFromEnd(ListNode head, int k) {
        ListNode p1 = head;
        // p1 先走 k 步
        for (int i = 0; i < k; i++) {
            p1 = p1.next;
        }
        ListNode p2 = head;
        // p1 和 p2 同时走 n - k 步
        while (p1 != null) {
            p2 = p2.next;
            p1 = p1.next;
        }
        // p2 现在指向第 n - k 个节点
        return p2;
    }
}

---

876.链表的中间节点

• 问题的关键也在于我们无法直接得到单链表的长度 n，常规方法也是先遍历链表计算 n，再遍历一次得到第 n / 2 个节点，也就是中间节点。
• 如果想一次遍历就得到中间节点，也需要耍点小聪明，使用「快慢指针」的技巧：我们让两个指针 slow 和 fast 分别指向链表头结点 head。每当慢指针 slow 前进一步，快指针 fast 就前进两步，这样，当 fast 走到链表末尾时，slow 就指向了链表中点。
• 需要注意的是，如果链表长度为偶数，也就是说中点有两个的时候，我们这个解法返回的节点是靠后的那个节点。

class Solution {
    public ListNode middleNode(ListNode head) {
        // 快慢指针初始化指向 head
        ListNode slow = head, fast = head;
        // 快指针走到末尾时停止
        while (fast != null && fast.next != null) {
            // 慢指针走一步，快指针走两步
            slow = slow.next;
            fast = fast.next.next;
        }
        // 慢指针指向中点
        return slow;
    }
}

---