算法题解之链表

Copy List with Random Pointers

复制带随机指针的链表

思路1：使用哈希表，需要消耗O(N)的额外空间。

public class Solution {
    /**
     * @param head: The head of linked list with a random pointer.
     * @return: A new head of a deep copy of the list.
     */
    public RandomListNode copyRandomList(RandomListNode head) {
        // write your code here
        
        Map<RandomListNode, RandomListNode> map = new HashMap<RandomListNode, RandomListNode>();
        RandomListNode cur = head;
        RandomListNode copyDummy = new RandomListNode(0);
        RandomListNode copyCur = copyDummy;
        
        while (cur != null) {
            copyCur.next = new RandomListNode(cur.label);
            copyCur = copyCur.next;
            map.put(cur, copyCur);
            cur = cur.next;
        }
        
        cur = head;
        while (cur != null) {
            copyCur = map.get(cur);
            copyCur.random = map.get(cur.random);
            cur = cur.next;
        }       
        return copyDummy.next;
    }
}

思路2：第一遍扫的时候巧妙运用next指针， 开始数组是1->2->3->4 。 然后扫描过程中 先建立copy节点 1->1`->2->2`->3->3`->4->4`, 然后第二遍copy的时候去建立边的copy， 拆分节点, 一边扫描一边拆成两个链表，这里用到两个dummy node。第一个链表变回 1->2->3 , 然后第二变成 1`->2`->3` 。消耗额外空间O(1)。

public class Solution {
    /**
     * @param head: The head of linked list with a random pointer.
     * @return: A new head of a deep copy of the list.
     */
    public RandomListNode copyRandomList(RandomListNode head) {
        // write your code here
        copyNext(head);
        copyRandom(head);
        return split(head);
        
    }
    
    public RandomListNode split(RandomListNode head) {
        RandomListNode dummy = new RandomListNode(0);
        RandomListNode cur = dummy;
        
        while (head != null) {
            cur.next = head.next;
            cur = cur.next;
            head.next = head.next.next;
            head = head.next;
        }
        return dummy.next;
        
    }
    
    public void copyRandom(RandomListNode head) {
        
        while (head != null) {
            RandomListNode copy = head.next;
            if (copy.random != null) {
                copy.random = copy.random.next;
            }
            head = head.next.next;
        }
        
    }
    
    public void copyNext(RandomListNode head) {
      
        while (head != null) {
            RandomListNode copy = new RandomListNode(head.label);
            copy.next = head.next;
            copy.random = head.random;
            head.next = copy;
            head = head.next.next;
        }

    }
}

 

Convert Binary Search Tree to Doubly Linked List

将二叉查找树转换成双链表

思路：用分治法做，分治函数要返回该子树对应的双链表的头节点和尾节点。

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 * Definition for Doubly-ListNode.
 * public class DoublyListNode {
 *     int val;
 *     DoublyListNode next, prev;
 *     DoublyListNode(int val) {
 *         this.val = val;
 *         this.next = this.prev = null;
 *     }
 * }
 */ 
public class Solution {
    /**
     * @param root: The root of tree
     * @return: the head of doubly list node
     */
    public DoublyListNode bstToDoublyList(TreeNode root) {  
        // Write your code here
        return helper(root).head;
    }
    
    public Pair helper(TreeNode root) {
        if (root == null) {
            return new Pair(null, null);
        }
        Pair leftPair = helper(root.left);
        Pair rightPair = helper(root.right);
        DoublyListNode rootNode = new DoublyListNode(root.val);
        rootNode.next = rightPair.head;
        rootNode.prev = leftPair.tail;
        
        if (leftPair.head == null && rightPair.head == null) {
            return new Pair(rootNode, rootNode);
        } else if (leftPair.head == null) {
            rightPair.head.prev = rootNode;
            return new Pair(rootNode, rightPair.tail);
        } else if (rightPair.head == null) {
            leftPair.tail.next = rootNode;
            return new Pair(leftPair.head, rootNode);
        } else {
            rightPair.head.prev = rootNode;
            leftPair.tail.next = rootNode;
            return new Pair(leftPair.head, rightPair.tail);
        }
        
    }
}

class Pair {
    DoublyListNode head;
    DoublyListNode tail;
    Pair(DoublyListNode head, DoublyListNode tail) {
        this.head = head;
        this.tail = tail;
    }
}

 

Convert Sorted List to Balanced BST

排序列表转换为二分查找树

思路：分治法。找到链表中点，中点作为根节点，左半段构造一个BST作为左子树，右半段构造一个BST作为右子树。

/**
 * Definition for ListNode.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int val) {
 *         this.val = val;
 *         this.next = null;
 *     }
 * }
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */ 
public class Solution {
    /**
     * @param head: The first node of linked list.
     * @return: a tree node
     */
    public TreeNode sortedListToBST(ListNode head) {  
        // write your code here
        if (head == null) {
            return null; 
        }
        
        if (head.next == null) {
            return new TreeNode(head.val);
        }
        
        if (head.next.next == null) {
            TreeNode root = new TreeNode(head.val);
            root.right = new TreeNode(head.next.val);
            return root;
        }
        
        ListNode befMid = beforeMid(head);
        TreeNode root = new TreeNode(befMid.next.val);
        root.right = sortedListToBST(befMid.next.next);
        befMid.next = null;
        root.left = sortedListToBST(head);
        
        return root;
        
    }
    
    public ListNode beforeMid(ListNode head) {
        ListNode cur = head;
        int length = 0;
        while (cur != null) {
            cur = cur.next;
            length++;
        }
        
        int mid = (length + 1) / 2;
        for(int i = 2; i <= mid -1; i++){
            head = head.next;
        }
        
        return head;
    }
}

Intersection of Two Linked Lists

两条链表的交点

思路：这道题还做了半天。。分别求出两条链表的长度，得出差值。再用两个指针分别指向两个链表头，将较长链表的指针移动差值个节点后，两个指针开始同时移动，并比较当前链表节点是否相等。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        int sizeA = 0;
        ListNode curA = headA;
        while (curA != null) {
            curA = curA.next;
            sizeA++;
        }
        
        int sizeB = 0;
        ListNode curB = headB;
        while (curB != null) {
            curB = curB.next;
            sizeB++;
        }
        
        int diff = Math.abs(sizeA - sizeB);
        if (sizeA > sizeB) {
            while (diff-- != 0) {
                headA = headA.next;
            }
        } else {
            while (diff-- != 0) {
                headB = headB.next;
            }
        }
        
        while (headA != null) {
            if (headA == headB) {
                return headA;
            } else {
                headA = headA.next;
                headB = headB.next;
            }
        }
        return null;
    }
}

 

Linked List Cycle

带环链表

思路：先起一个快指针和一个慢指针，如果快慢指针能相遇，说明带环。

/**
 * Definition for ListNode.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int val) {
 *         this.val = val;
 *         this.next = null;
 *     }
 * }
 */ 
public class Solution {
    /**
     * @param head: The first node of linked list.
     * @return: True if it has a cycle, or false
     */
    public boolean hasCycle(ListNode head) {  
        // write your code here
        if (head == null || head.next == null) {
            return false;
        }
        ListNode slow = head;
        ListNode fast = head.next;
        while (fast != null && fast.next != null) {
            if (slow == fast) {
                return true;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        return false;
    }
}

Linked List Cycle II

带环链表II

思路：先起一个快指针和一个慢指针，快指针和慢指针重合时，从表头再起一个慢指针，两个慢指针继续走，相遇的地方就是环的入口。

/**
 * Definition for ListNode.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int val) {
 *         this.val = val;
 *         this.next = null;
 *     }
 * }
 */ 
public class Solution {
    /**
     * @param head: The first node of linked list.
     * @return: The node where the cycle begins. 
     *           if there is no cycle, return null
     */
    public ListNode detectCycle(ListNode head) {  
        // write your code here
        if (head == null || head.next == null) {
            return null;
        }
        ListNode slow = head;
        ListNode fast = head.next;
        
        while (slow != fast) {
            if (fast == null || fast.next == null) {
                return null;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        
        while (head != slow.next) {
            head = head.next;
            slow = slow.next;
        }
        return head;
        
    }
}

merge k sorted lists

合并k个排序链表

思路1：分治法。

　　时间复杂度分析：

T(N,k) = T(N1, k/2) + T(N2, k/2) + N1 + N2

　　　  = T(N1, k/2) + T(N2, k/2) + N

　　　  = T(N11, k/4)  + T(N12, k/4) + N11 + N12 + T(N21, k/4) + T(N22, k/4)   + N21 + N22 + N

　　　  = T(N11, k/4)  + T(N12, k/4) + N1 + T(N21, k/4) + T(N22, k/4) + N2 + N

　　　  = T(N11, k/4)  + T(N12, k/4) + T(N21, k/4) + T(N22, k/4) + 2N

　　　  ......

　　　  = T(n1, 1) + T(n2, 1) +...+ T(nk, 1) + Nlgk = O(Nlgk)
            

public class Solution {
    /**
     * @param lists: a list of ListNode
     * @return: The head of one sorted list.
     */
    public ListNode mergeKLists(List<ListNode> lists) {
        if (lists.size() == 0) {
            return null;
        }
        return mergeHelper(lists, 0, lists.size() - 1);
    }
    
    private ListNode mergeHelper(List<ListNode> lists, int start, int end) {
        if (start == end) {
            return lists.get(start);
        }
        
        int mid = start + (end - start) / 2;
        ListNode left = mergeHelper(lists, start, mid);
        ListNode right = mergeHelper(lists, mid + 1, end);
        return mergeTwoLists(left, right);
    }
    
    private ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        while (list1 != null && list2 != null) {
            if (list1.val < list2.val) {
                tail.next = list1;
                tail = list1;
                list1 = list1.next;
            } else {
                tail.next = list2;
                tail = list2;
                list2 = list2.next;
            }
        }
        if (list1 != null) {
            tail.next = list1;
        } else {
            tail.next = list2;
        }
        
        return dummy.next;
    }
}

 思路2：最小堆

时间复杂度分析：T(N, k) = N * lgk = O(Nlgk)

public class Solution {
    /**
     * @param lists: a list of ListNode
     * @return: The head of one sorted list.
     */
    public ListNode mergeKLists(List<ListNode> lists) {  
        // write your code here
        if (lists == null || lists.size()==0) {
            return null;
        }
        Comparator<ListNode> listNodeComparator = new Comparator<ListNode>() {
            public int compare(ListNode l1, ListNode l2) {
                if (l1 == null && l2 == null) {
                    return 1;
                } else if (l1 == null) {
                    return 1;
                } else if (l2 == null) {
                    return -1;
                } else {
                    return l1.val - l2.val;
                }
            }
        };
        
        ListNode dummy = new ListNode(0);
        ListNode cur = dummy;
        
        PriorityQueue<ListNode> minHeap = new PriorityQueue<ListNode>(lists.size(), listNodeComparator);
        for (ListNode l : lists) {
            if (l != null) {
                minHeap.offer(l);
            }
        }
        
        while (minHeap.peek() != null) {
            cur.next = minHeap.poll();
            cur = cur.next;
            if (cur.next != null) {
                minHeap.offer(cur.next);
            }
        }
        cur.next = null;
        return dummy.next;  
    } 
}

 思路3：两两合并。

时间复杂度分析：

T(N, k) = N + T(N, k/2)

　　　　　　= 2N + T(N, k/4)

　　　　　　= 3N + T(N, k/8)

  　　　　　......

　　　　　　= Nlgk + T(N, 1) = O(Nlgk)

public class Solution {
    /**
     * @param lists: a list of ListNode
     * @return: The head of one sorted list.
     */
    public ListNode mergeKLists(List<ListNode> lists) {  
        // write your code here
        if (lists.size() == 0) {
            return null;
        }
        if (lists.size() == 1) {
            return lists.get(0);
        }
        int size = lists.size();
        List<ListNode> nextLists = new ArrayList<ListNode>();
        for (int i = 0; i<=size-1; i+=2) {
            if (i == size-1) {
                nextLists.add(lists.get(i));
                break;
            }
            ListNode afterMerge = mergeTwoLists(lists.get(i), lists.get(i+1));
            nextLists.add(afterMerge);
        }
        return mergeKLists(nextLists);
    }
    
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(0);
        ListNode cur = dummy;
        
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                cur.next = l1;
                cur = cur.next;
                l1 = l1.next;
            } else {
                cur.next = l2;
                cur = cur.next;
                l2 = l2.next;
            }
        }
        
        if (l1 != null) {
            cur.next = l1;
        }
        
        if (l2 != null) {
            cur.next = l2;
        }
        
        return dummy.next;
    }
}

Partition List 

链表划分

思路：用两个dummy接，最后再把两段合起来。

/**
 * Definition for ListNode.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int val) {
 *         this.val = val;
 *         this.next = null;
 *     }
 * }
 */ 
public class Solution {
    /**
     * @param head: The first node of linked list.
     * @param x: an integer
     * @return: a ListNode 
     */
    public ListNode partition(ListNode head, int x) {
        // write your code here
        ListNode leftDummy = new ListNode(0);
        ListNode rightDummy = new ListNode(0);
        ListNode left = leftDummy;
        ListNode right = rightDummy;
        ListNode cur = head;
        
        while (cur != null) {
            if (cur.val >= x) {
                right.next = cur;
                right = cur;
            } else {
                left.next = cur;
                left = cur;
            }
            cur = cur.next;
        }
        
        right.next = null;
        left.next = rightDummy.next;
        return leftDummy.next;
    }
}

Palindrome Linked List

回文链表

思路：从链表中间切开，对第二段链表做反转，然后看两段链表是否一 一对应。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    /**
     * @param head a ListNode
     * @return a boolean
     */
    public boolean isPalindrome(ListNode head) {
        // Write your code here
        if (head == null || head.next == null) {
            return true;
        }
        ListNode mid = findMid(head);
        ListNode aftermid = reverse(mid.next);
        while (aftermid != null) {
            if (aftermid.val != head.val) {
                return false;
            }
            aftermid = aftermid.next;
            head = head.next;
        }
        return true;
        
    }
    
    public ListNode findMid(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode slow = head;
        ListNode fast = head.next;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
    
    public ListNode reverse(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode pre = head;
        ListNode cur = head.next;
        while (cur != null) {
            ListNode tmp = cur;
            cur = cur.next;
            tmp.next = pre;
            pre = tmp;
        }
        head.next = null;
        return pre;
    }
}

Reverse Nodes in k-Group

k组翻转链表

思路：先判断能否翻转，如果能，先翻转第一段，后面的递归地进行翻转。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    /**
     * @param head a ListNode
     * @param k an integer
     * @return a ListNode
     */
    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null || head.next == null) {
            return head;
        }
        
        ListNode cur = head;
        int count = 0;
        while (cur != null && count < k) {
            cur = cur.next;
            count++;
        }
        if (count < k) {
            return head;
        }
        ListNode pre = head;
        cur = head.next;
        count = 1;
        while (count < k) {
            ListNode tmp = cur;
            cur = cur.next;
            tmp.next = pre;
            pre = tmp;
            count++;
        }
        head.next = reverseKGroup(cur, k);
        return pre;
    }
}

Swap Two Nodes in Linked List

交换链表中两个节点

思路：先查找这两个节点，如果存在就有两种情况：两个节点相邻，两个节点不相邻。要分开讨论。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    /**
     * @param head a ListNode
     * @oaram v1 an integer
     * @param v2 an integer
     * @return a new head of singly-linked list
     */
    public ListNode swapNodes(ListNode head, int v1, int v2) {
        // Write your code here
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode pre1 = null;
        ListNode pre2 = null;
        ListNode cur = dummy;
        while (cur.next != null) {
            if (cur.next.val == v1) {
                pre1 = cur;
            } 
            if (cur.next.val == v2) {
                pre2 = cur;
            } 
            cur = cur.next;
        }
        
        if (pre1 == null || pre2 == null) {
            return dummy.next;
        }
        if (pre1.val == v2) {
            ListNode tmp = pre1.next;
            pre2.next = tmp;
            pre1.next = tmp.next;
            tmp.next = pre1;
        } else if (pre2.val == v1) {
            ListNode tmp = pre2.next;
            pre1.next = tmp;
            pre2.next = tmp.next;
            tmp.next = pre2;
        } else {
            ListNode n1 = pre1.next;
            ListNode n2 = pre2.next;
            pre1.next = n2;
            pre2.next = n1;
            ListNode tmp = n1.next;
            n1.next = n2.next;
            n2.next = tmp;
        }
        
        return dummy.next;
    }
}

 

 Sort List

链表排序

思路1：快速排序。

/**
 * Definition for ListNode.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int val) {
 *         this.val = val;
 *         this.next = null;
 *     }
 * }
 */ 
public class Solution {
    /**
     * @param head: The head of linked list.
     * @return: You should return the head of the sorted linked list,
                    using constant space complexity.
     */
    public ListNode sortList(ListNode head) {  
        // write your code here
        if (head == null || head.next == null) {
            return head;
        }
        resultType pair = partition(head, head.val);
        ListNode left = sortList(pair.l1);
        ListNode right = sortList(pair.l2);
        ListNode equal = pair.l3;
        
        ListNode dummy = new ListNode(0);
        dummy.next = left;
        ListNode leftTail = dummy;
        
        
        while (leftTail.next != null) {
            leftTail = leftTail.next;
        }
        
        if (equal != null) {
            leftTail.next = equal;
            while (equal.next != null) {
                equal = equal.next;
            }

            equal.next = right;
        } else {
            leftTail.next = right;
        }
        return dummy.next;
    }
    
    public resultType partition(ListNode head, int x) {
        ListNode leftDummy = new ListNode(0);
        ListNode rightDummy = new ListNode(0);
        ListNode equalDummy = new ListNode(0);
        ListNode leftTail = leftDummy;
        ListNode rightTail = rightDummy;
        ListNode equalTail = equalDummy;
        
        while (head != null) {
            if (head.val < x) {
                leftTail.next = head;
                head = head.next;
                leftTail = leftTail.next;
            } else if (head.val > x) {
                rightTail.next = head;
                head = head.next;
                rightTail = rightTail.next;
            } else {
                equalTail.next = head;
                head = head.next;
                equalTail = equalTail.next;
            }
        }
        leftTail.next = null;
        rightTail.next = null;
        equalTail.next = null;
        
        return new resultType(leftDummy.next, rightDummy.next, equalDummy.next);
        
    }
    
}

class resultType {
    ListNode l1;
    ListNode l2;
    ListNode l3;
    resultType(ListNode l1, ListNode l2, ListNode l3) {
        this.l1 = l1;
        this.l2 = l2;
        this.l3 = l3;
    }
}

思路2：归并排序也是可以的，因为链表的merge操作不需要额外的空间。