leetcode 链表题总结

按照frequency来排序，总共27题

1、2. Add Two Numbers　　https://leetcode.com/problems/add-two-numbers/#/description

两个链表相加，注意就是进位问题。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int flag = 0;
        ListNode result = new ListNode(0);
        ListNode node = result;
        while (l1 != null || l2 != null){
            int val = flag;
            if (l1 != null){
                val += l1.val;
                l1 = l1.next;
            }
            if (l2 != null){
                val += l2.val;
                l2 = l2.next;
            }
            if (val > 9){
                val -= 10;
                flag = 1;
            } else {
                flag = 0;
            }
            node.next = new ListNode(val);
            node = node.next;
        }
        if (flag == 1){
            node.next = new ListNode(1);
        }
        return result.next;
    }
}

2、237. Delete Node in a Linked List　　https://leetcode.com/problems/delete-node-in-a-linked-list/#/description

删除链表中的节点。只给需要删除的节点。很简单，两行代码就搞定了。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

3、206. Reverse Linked List　　https://leetcode.com/problems/reverse-linked-list/#/description

反转链表。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        ListNode pre = head;
        ListNode node = head.next;
        head.next = null;
        while (node.next != null){
            ListNode flag = node.next;
            node.next = head;
            head = node;
            node = flag;
        }
        node.next = head;
        return node;
    }
}

4、148. Sort List　　https://leetcode.com/problems/sort-list/#/description

链表排序。要求nlogn的时间复杂度和常数的空间复杂度。那么应用归并排序。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        ListNode pre = null;
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null){
            pre = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        pre.next = null;
        ListNode l1 = sortList(head);
        ListNode l2 = sortList(slow);
        
        return sortList(l1, l2);
        
    }
    public ListNode sortList(ListNode node1, ListNode node2){
        ListNode node = new ListNode(0);
        ListNode nn = node;
        while (node1 != null && node2 != null){
            if (node1.val < node2.val){
                nn.next = node1;
                node1 = node1.next;
            } else {
                nn.next = node2;
                node2 = node2.next;
            }
            nn = nn.next;
        }
        while (node1 != null){
            nn.next = node1;
            nn = nn.next;
            node1 = node1.next;
        }
        while (node2 != null){
            nn.next = node2;
            nn = nn.next;
            node2 = node2.next;
        }
        return node.next;
    }
}

5、141. Linked List Cycle　　　　https://leetcode.com/problems/linked-list-cycle/#/description

判断链表是否有环。

一个快，一个慢，判断是否会走到一起（如果成环一定可以走到一起）。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null){
            return false;
        }
        ListNode slow = head.next;
        ListNode fast = head.next.next;
        while (fast != null && fast.next != null && slow != fast){
            fast = fast.next.next;
            slow = slow.next;
        }
        return (fast == null || fast.next == null) ? false : true;
    }
}

6、328. Odd Even Linked List　　　　https://leetcode.com/problems/odd-even-linked-list/#/description

将链表分为偶数和奇数两块，奇数放在前面，偶数放在后面。

刚开始看错题目，说的是将第偶数个放在一起，第奇数个放在一起，并非链表中的数值。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode oddEvenList(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        ListNode odd = head, even = head.next, evenhead = even;
        while (even != null && even.next != null){
            odd.next = odd.next.next;
            even.next = even.next.next;
            odd = odd.next;
            even = even.next;
        }
        odd.next = evenhead;
        return head;
    }
}

7、21. Merge Two Sorted Lists　　链表合并　　https://leetcode.com/problems/merge-two-sorted-lists/#

 简单的两路归并。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode head = new ListNode(0), node = head;;
        while (l1 != null && l2 != null){
            if (l1.val > l2.val){
                node.next = l2;
                l2 = l2.next;
            } else {
                node.next = l1;
                l1 = l1.next;
            }
            node = node.next;
        }
        if (l1 != null){
            node.next = l1;
        } else if (l2 != null){
            node.next = l2;
        }
        return head.next;
    }
}

8、160. Intersection of Two Linked Lists返回两个链表的第一个交点。　　https://leetcode.com/problems/intersection-of-two-linked-lists/#/description

a、找出长度差，然后长的链表先行长度差个，然后依次比较，找出交点（没有就是null）。

b、用hash

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int len1 = 0, len2 = 0;
        ListNode node = headA;
        while (node != null){
            node = node.next;
            len1++;
        }
        node = headB;
        while (node != null){
            node = node.next;
            len2++;
        }
        if (len1 > len2){
            for (int i = 0; i < len1 - len2; i++){
                headA = headA.next;
            }
        } else {
            for (int i = 0; i < len2 - len1; i++){
                headB = headB.next;
            }
        }
        while (headA != headB){
            headA = headA.next;
            headB = headB.next;
        }
        return headA;
    }
}

另外，可以这样解。

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    //boundary check
    if(headA == null || headB == null) return null;
    
    ListNode a = headA;
    ListNode b = headB;
    
    //if a & b have different len, then we will stop the loop after second iteration
    while( a != b){
        //for the end of first iteration, we just reset the pointer to the head of another linkedlist
        a = a == null? headB : a.next;
        b = b == null? headA : b.next;    
    }
    
    return a;
}

9、138. Copy List with Random Pointer　拷贝随机链表　　https://leetcode.com/problems/copy-list-with-random-pointer/#/description

a、hash

b、在每一个链表后面添加一个链表。

/**
 * Definition for singly-linked list with a random pointer.
 * class RandomListNode {
 *     int label;
 *     RandomListNode next, random;
 *     RandomListNode(int x) { this.label = x; }
 * };
 */
public class Solution {
    public RandomListNode copyRandomList(RandomListNode head) {
        if (head == null){
            return null;
        }
        RandomListNode node = head, next;
        while (node != null){
            next = node.next;
            node.next = new RandomListNode(node.label);
            node.next.next = next;
            node = next;
        }
        node = head;
        while (node != null){
            if (node.random != null){
                node.next.random = node.random.next;
            }
            node = node.next.next;
        }
        RandomListNode newHead = new RandomListNode(0), result = newHead;
        node = head;
        while (node != null){
            next = node.next.next;
            newHead.next = node.next;
            newHead = newHead.next;
            node.next = next;
            node = node.next;
        }
        return result.next;
    }
}

10、23. Merge k Sorted Lists　　k个链表的合并。　　　　https://leetcode.com/problems/merge-k-sorted-lists/#/description

k路归并，利用优先级队列PriorityQueue

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        ListNode head = new ListNode(0), node = head;
        int size = lists.length;
        if (size == 0){
            return null;
        }
        Comparator<ListNode> comparator = new Comparator<ListNode>(){
          public int compare(ListNode o1, ListNode o2){
              if (o1.val > o2.val){
                  return 1;
              } else if (o1.val < o2.val){
                  return -1;
              } else {
                  return 0;
              }
          }  
        };
        PriorityQueue<ListNode> queue = new PriorityQueue(size, comparator);
        for (int i = 0; i < size; i++){
            if (lists[i] != null)
                queue.add(lists[i]);
        }
        while (!queue.isEmpty()){
            node.next = queue.poll();
            node = node.next;
            if (node.next != null){
                queue.add(node.next);
            }
        }
        return head.next;
    }
}

11、234. Palindrome Linked List　　判断是否是回文链表　　https://leetcode.com/problems/palindrome-linked-list/#/solutions

（123，123）是回文，（123，321）不是。　　

由于没有时间了，写上思路：a、利用栈，时间O(n),空间O(N);

　　　　　　　　　　　　　b、找到中点（fast、slow一快一慢来判断），后半部分反转。然后判断。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public boolean isPalindrome(ListNode head) {
        if (head == null || head.next == null){
            return true;
        }   
        ListNode slow = head, fast = head.next;
        while (fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        if (fast != null){
            slow = slow.next;
        }
        ListNode head2 = slow;
        slow = reseverList(slow);
        
        while (slow != null && head != null){
            if (slow.val != head.val){
                return false;
            }
            slow = slow.next;
            head = head.next;
        }
        return true;
        
    }
    public ListNode reseverList(ListNode head){
        if (head == null || head.next == null){
            return head;
        }
        ListNode node = head.next;
        head.next = null;
        while (node != null){
            ListNode flag = node.next;
            node.next = head;
            head = node;
            node = flag;
        }
        
        
        return head;
    }
    
    
}

12、147. Insertion Sort List　　链表插入排序　　https://leetcode.com/problems/insertion-sort-list/#/description

没什么技巧和难点。

13、142. Linked List Cycle II　　找出链表循环的起点　　https://leetcode.com/problems/linked-list-cycle-ii/#/description

与第五题也就是141相同，相遇的点就是循环的起点（数学方法证明）。

14、19. Remove Nth Node From End of List　　删除倒数第n个节点　　　　https://leetcode.com/problems/remove-nth-node-from-end-of-list/#/description

fast先走n个节点，然后slow再走，直到 fast == null为止，跳过slow.next即可。

这里需要了解n的范围，会不会超过长度，如果超过了长度要怎么办。

15、143. Reorder List　　将链表按照固定方式改写。　　　　https://leetcode.com/problems/reorder-list/#/description

Given a singly linked list L: L0→L1→…→Ln-1→Ln,
reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…

1、用list或者数组记录

2、用双向队列（Deque）

3、链表分成两半，然后后一半反转，然后合并两个链表。

16、24. Swap Nodes in Pairs　　节点两两交换　　　　https://leetcode.com/problems/swap-nodes-in-pairs/#/description

a、递归实现

b、非递归

17、203. Remove Linked List Elements　　删除某个值　　　　https://leetcode.com/problems/remove-linked-list-elements/#/description

遍历直接删除就行了

18、83. Remove Duplicates from Sorted List　　删除重复的数　　　　https://leetcode.com/problems/remove-duplicates-from-sorted-list/#/description

也是递归、非递归实现。

19、109. Convert Sorted List to Binary Search Tree　　排序好的链表建树　　　　https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/#/description

递归实现，二分查找。

20、92. Reverse Linked List II　　　链表的部分反转　　　　https://leetcode.com/problems/reverse-linked-list-ii/#/description

21、86. Partition List　　　划分链表的值　　　　https://leetcode.com/problems/partition-list/#/description

给定一个值，把小于x的值放在左边，大于等于x的值放在右边，保持相对顺序。

没什么难点。

22、25. Reverse Nodes in k-Group　　　　部分反转　　　　https://leetcode.com/problems/reverse-nodes-in-k-group/#/description

也是递归和非递归的实现。

23、61. Rotate List　　　　旋转链表　　　　https://leetcode.com/problems/rotate-list/#/description

从倒数第k个位置开始旋转一下链表。

需要判断k是否大于len。

24、82. Remove Duplicates from Sorted List II　　　　去掉重复的数字（一个都不留）　　　　https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/#/description

没什么难点。遍历一次就行了

25、445. Add Two Numbers II　　　　链表相加（与之前一体的区别是反过来了，而且不允许反转链表）

1、首先想到的应该是反转链表，然后求出答案，这样空间复杂度是O(n);

2、借助辅助空间，stack。

3、日常递归实现。 

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        Stack<Integer> l1_stack = new Stack();
        Stack<Integer> l2_stack = new Stack();
        while (l1 != null){
            l1_stack.add(l1.val);
            l1 = l1.next;
        }
        while (l2 != null){
            l2_stack.add(l2.val);
            l2 = l2.next;
        }
        ListNode head = new ListNode(0), curr = null;
        int flag = 0;
        while (!l1_stack.isEmpty() || !l2_stack.isEmpty() || flag == 1){
            int num = flag;
            if (!l1_stack.isEmpty()){
                num += l1_stack.pop();
            }
            if (!l2_stack.isEmpty()){
                num += l2_stack.pop();
            }
            if (num > 9){
                num -= 10;
                flag = 1;
            } else {
                flag = 0;
            }
            ListNode node = new ListNode(num);
            node.next = curr;
            curr = node;
            head.next = node;
        }
        return head.next;
    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int len1 = getLen(l1);
        int len2 = getLen(l2);
        ListNode head = new ListNode(1);
        head.next = len1 > len2 ? helper(l1, l2, len1 - len2) : helper(l2, l1, len2 - len1);
        if (head.next.val > 9){
            head.next.val -= 10;
            return head;
        }
        return head.next;
    }
    
    public ListNode helper(ListNode l1, ListNode l2, int offset){
        if (l1 == null){
            return null;
        }
        ListNode node = offset == 0 ? new ListNode(l1.val + l2.val) : new ListNode(l1.val);
        ListNode next = offset == 0 ? helper(l1.next, l2.next, 0) : helper(l1.next, l2, offset - 1);
        
        if (next != null && next.val > 9){
            next.val -= 10;
            node.val += 1;
        }
        node.next = next;
        
        return node;
    }
    
    public int getLen(ListNode node){
        int len = 0;
        while (node != null){
            node = node.next;
            len++;
        }
        return len;
    }
}

26、379. Design Phone Directory　　设计电话字典。设计题。并不知道哪里用到了链表。　　　　https://leetcode.com/problems/design-phone-directory/#/description

 a、直接用数组就可以实现。

b、用队列 + set可以实现（更快一些，数组每次get需要遍历）。

这里用了数组实现。

public class PhoneDirectory {

    /** Initialize your data structure here
        @param maxNumbers - The maximum numbers that can be stored in the phone directory. */
    private int[] phone;
    public PhoneDirectory(int maxNumbers) {
        phone = new int[maxNumbers];
        for (int i = 0; i < maxNumbers; i++){
            phone[i] = 1;
        }
    }
    
    /** Provide a number which is not assigned to anyone.
        @return - Return an available number. Return -1 if none is available. */
    public int get() {
        for (int i = 0; i < phone.length; i++){
            if (phone[i] == 1){
                phone[i] = 0;
                return i;
            }
        }
        return -1;
    }
    
    /** Check if a number is available or not. */
    public boolean check(int number) {
        if (number < 0 || number > phone.length){
            return false;
        }
        return phone[number] == 1;
    }
    
    /** Recycle or release a number. */
    public void release(int number) {
        phone[number] = 1;
    }
}

/**
 * Your PhoneDirectory object will be instantiated and called as such:
 * PhoneDirectory obj = new PhoneDirectory(maxNumbers);
 * int param_1 = obj.get();
 * boolean param_2 = obj.check(number);
 * obj.release(number);
 */

27、369. Plus One Linked List　　链表+1　　　　https://leetcode.com/problems/plus-one-linked-list/#/description

 1、递归。、

2、判断末尾有多少个连续的9即可。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode plusOne(ListNode head) {
        ListNode node = new ListNode(1);
        node.next = head;
        plusOneHelper(head);
        if (node.next.val > 9){
            node.next.val -= 10;
            return node;
        }
        return node.next;
    }
    
    public void plusOneHelper(ListNode node){
        if (node.next == null){
            node.val += 1;
            return ;
        } else {
            plusOneHelper(node.next);
            if (node.next.val > 9){
                node.next.val -= 10;
                node.val += 1;
            }
        }
        return ;
    }
    
}