链表相关算法题详解

1、(LeetCode21)合并两个有序链表

　　链接：https://leetcode.cn/problems/merge-two-sorted-lists/

　　题目：将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

　　思路：这道题可以用递归来做，首先判断两个链表的首节点哪个比较小，小的作为新节点，然后剩余的部分重复这个函数实现。

　　代码实现：

 1 class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null) return l2;
        if(l2 == null) return l1;
        if(l1.val < l2.val){
            l1.next = mergeTwoLists(l1.next,l2);
            return l1;
        }
        l2.next = mergeTwoLists(l1,l2.next);
        return l2;
    }
}

2、(LeetCode83)删除排序链表中的重复元素

　　链接：https://leetcode.cn/problems/remove-duplicates-from-sorted-list/

　　题目：给定一个已排序的链表的头head， 删除所有重复的元素，使每个元素只出现一次 。返回已排序的链表。

　　思路：同样地用递归，如果首节点和第二个节点的值相等，那么就返回第二个节点，剩余的部分操作相同。

　　代码实现：

1 class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null || head.next == null) return head;
        head.next = deleteDuplicates(head.next);
        return head.val == head.next.val?head.next:head;
    }
}

3、(LeetCode141)环形链表

　　链接：https://leetcode.cn/problems/linked-list-cycle/

　　题目：给你一个链表的头节点head，判断链表中是否有环。

　　思路：定义两个指针，一个快指针，一个慢指针，快指针一次移动两个节点，慢指针一次移动一个节点，如果存在环的话，那么这两个指针肯定会相遇，如果不存在环的话，那么就会走到结尾的null。

　　代码实现：

 1 public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null) return false;
        ListNode slowPtr = head,fastPtr = head;
        while(fastPtr.next != null && fastPtr.next.next != null){
            slowPtr = slowPtr.next;
            fastPtr = fastPtr.next.next;
            if(slowPtr == fastPtr){
                return true;
            }
        }
        return false;
    }
}

4、(LeetCode142)环形链表II

　　链接：https://leetcode.cn/problems/linked-list-cycle-ii/

　　题目：给定一个链表的头节点head，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

　　思路：这道题算是上道题的升级版了，只需要将上道题的代码简单做下改动就可以了。首先开始的时候添加一个标志位来判断链表是否有环，当快慢指针相遇时，标志位置为true，代表存在环。当环存在时，慢指针指向头结点，快指针速度和慢指针相同，那么两指针相遇的位置就是环的起始位置。可能有的人理解不了为什么两指针相遇就是起始位置，这里我跳出题目，举个例子就懂了。

 　　像左图那样在一个环形链表定义两个指针，一个快指针一个慢指针，在一个位置出发，那么肯定还会在这个位置相遇，如果说我要是像右图那样，起点提前了n个节点，那么相遇的位置也会离上次相遇的位置距离n个节点，这个时候我要是把慢指针放到开始的位置上，并且快指针的速度也和慢指针一样，那么他们肯定会在环的入环位置相遇。

　　代码实现：

 1 public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head == null) return null;
        ListNode slowPtr = head,fastPtr = head;
        boolean loopExists = false;
        while(fastPtr.next != null && fastPtr.next.next != null){
            slowPtr = slowPtr.next;
            fastPtr = fastPtr.next.next;
            if(slowPtr == fastPtr){
                loopExists = true;
                break;
            }
        }
        if(loopExists){
            slowPtr = head;
            while(slowPtr != fastPtr){
                fastPtr = fastPtr.next;
                slowPtr = slowPtr.next;
            }
            return slowPtr;
        }
        return null;
    }
}

5、(LeetCode160)相交链表

　　链接：https://leetcode.cn/problems/intersection-of-two-linked-lists/comments/

　　题目：给你两个单链表的头节点headA和headB，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回null。

　　思路：分别在两个表头定义两个指针，对链表进行遍历，遍历结束移向另一个表的表头，直到两交点相等。看过代码的话，可能会有这样一个疑问，如果两个链表长度一样并且还无交点，会不会死循环？当然这个也是不会的，因为遍历到最后，两个指针都指向了null，这时候就会把null返回出去，也是符合条件的。

　　代码实现：

 1 public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null){
            return null;
        }
        ListNode pA = headA,pB = headB;
        while(pA != pB){
            pA = pA == null ? headB : pA.next;
            pB = pB == null ? headA : pB.next;
        }
        return pA;
    }
}

6、(LeetCode206)反转链表

　　链接：https://leetcode.cn/problems/reverse-linked-list/

　　题目：给你单链表的头节点head，请你反转链表，并返回反转后的链表。

　　思路：这道题只需要循环将当前节点的next指向前一个节点就OK了，注意在第一个节点之前加null.

　　代码实现：

 1 class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode preNode = null;
        ListNode curr = head;
        while(curr != null){
            ListNode next = curr.next;
            curr.next = preNode;
            preNode = curr;
            curr = next;
        }
        return preNode;
    }
}

7、(LeetCode234)回文链表

　　链接：https://leetcode.cn/problems/palindrome-linked-list/

　　题目：给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

　　思路：先定义一个栈，将链表的节点值存入到栈中，存好了之后，用pop()方法弹出末项来和头结点的值进行比较，若不相等，则返回false，若遍历完成，返回true。

　　代码实现：

 1 class Solution {
    public boolean isPalindrome(ListNode head) {
        Stack<Integer> stack = new Stack<Integer>();
        ListNode cur = head;
        while(cur != null){
            stack.push(cur.val);
            cur = cur.next;
        }
        while(head != null){
            if(stack.pop() != head.val){
                return false;
            }
            head = head.next;
        }
        return true;
    }
}

 

__EOF__

本文作者：向阳最优秀
本文链接：https://www.cnblogs.com/xiangyangboke/p/16388699.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！