Leetcode easy ListNode

Leetcode 簡單鏈表題目

21 合併兩個有序連結串列

題目：將兩個升序連結串列合併為一個新的 升序 連結串列並返回。新連結串列是通過拼接給定的兩個連結串列的所有節點組成的。

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

83 刪除排序連結串列中的重複元素

題目：給定一個排序連結串列，刪除所有重複的元素，使得每個元素只出現一次。

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

    }
}
 

141 環形連結串列

題目：給定一個連結串列，判斷連結串列中是否有環。

/**
 * 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 fast = head;
        ListNode slow = head;
        while(fast!=null && fast.next !=null && slow!=null){
            // 一定要把if(fast == slow) return 放在移動過指標的下面，不然的話初始狀態肯定是相等的
            slow = slow.next;
            fast = fast.next.next;
            if(fast == slow) return true;
        }
        return false;

    }
}
 

160 相交連結串列

題目：編寫一個程式，找到兩個單鏈表相交的起始節點。

/**
 * 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 l1 = 0;
        int l2 = 0;
        ListNode p = headA;
        ListNode q = headB;
        while(p!=null){
            l1++;
            p = p.next;
        }
        while(q!=null){
            l2++;
            q = q.next;
        }
        p = headA;
        q = headB;
        int m = l1 - l2;
        System.out.println(m);
        if(m<0){
            m=-m;
            while(m-->0) q=q.next;
        }else{
            while(m-->0) p= p.next;
        }
        while(p!=null && q!=null){
            if(p == q) return p;
            p = p .next;
            q = q.next;
        }
        return null;
    }
}

203 移除連結串列元素

題目：刪除連結串列中等於給定值 val 的所有節點。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null) return head;
        ListNode dummy = new ListNode(0);
        ListNode h = dummy;
        ListNode pre = head;
        while(pre!=null){
            while(pre != null && pre.val == val) pre = pre.next;
            h.next = pre;
            if(pre!=null) pre = pre.next;
            h=h.next;
        }
        return dummy.next;
    }
}

206 反轉連結串列

題目 : 反轉一個單鏈表。

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

234 迴文連結串列

題目：請判斷一個連結串列是否為迴文連結串列。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head == null || head.next == null) return true;
        ListNode pre = head;
        ListNode cur = head;
        int len = 0;
        while(pre != null){
            pre=pre.next;
            len++;
        }
        pre = head;
        int mid = (len%2)==1?(len/2+2):(len/2+1);
        while(mid-- >1) cur = cur.next;
        cur = reverse(cur);
        while(cur != null && pre != null){
            if(pre.val != cur.val) return false;
            pre = pre.next;
            cur = cur.next;
        }
        return true;

    }
    // 將連結串列翻轉，並返回翻轉之後的頭結點
    public ListNode reverse(ListNode root){
        if(root == null || root.next == null) return root;
        ListNode dummy = new ListNode(0);
        dummy.next = null;
        ListNode pre = root;
        ListNode cur = root.next;
        while(pre != null){
            pre.next = dummy.next;
            dummy.next = pre;
            pre = cur;
            if(cur!=null) cur = cur.next;
        }

        return dummy.next;
    }
}

237. 刪除連結串列中的節點

題目：請編寫一個函式，使其可以刪除某個連結串列中給定的（非末尾）節點。傳入函式的唯一引數為 要被刪除的節點 。

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

876. 連結串列的中間結點

題目： 給定一個帶有頭結點 head 的非空單鏈表，返回連結串列的中間結點。如果有兩個中間結點，則返回第二個中間結點。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode middleNode(ListNode head) {
        if(head == null || head.next == null) return head;
        ListNode p = head;
        int len = 0;
        int half = 0;
        while(p!=null){
            len++;
            p=p.next;
        }
        half = len/2+1;
        p=head;
        while(half>1){
            p=p.next;
            half--;
        }
        return p;
    }
}

1290. 二進位制連結串列轉整數

題目：給你一個單鏈表的引用結點 head。連結串列中每個結點的值不是 0 就是 1。已知此連結串列是一個整數數字的二進位制表示形式。請你返回該連結串列所表示數字的 十進位制值 。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int getDecimalValue(ListNode head) {
        int flag = 0;
        int res = 0;
        int len = 0;
        ListNode pre = head;
        while(pre!=null){
            len++;
            pre=pre.next;
        }
        pre = head;
        while(pre!=null){
            if(pre.val == 1) res+=Math.pow(2,len-flag-1);
            flag++;
            pre=pre.next;
        }
        return res;
    }
}

劍指 Offer 06. 從尾到頭列印連結串列

題目：輸入一個連結串列的頭節點，從尾到頭反過來返回每個節點的值（用陣列返回）。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        int len = 0;
        ListNode pre = head;
        while(pre != null){
            len++;
            pre=pre.next;
        }
        pre = head;
        int[] res = new int[len];
        int index = len-1;
        while(pre != null){
            res[index] = pre.val;
            pre = pre.next;
            index--;
        }
        return res;
    }
}

劍指 Offer 18. 刪除連結串列的節點

同上

劍指 Offer 22. 連結串列中倒數第k個節點

題目：輸入一個連結串列，輸出該連結串列中倒數第k個節點。為了符合大多數人的習慣，本題從1開始計數，即連結串列的尾節點是倒數第1個節點。例如，一個連結串列有6個節點，從頭節點開始，它們的值依次是1、2、3、4、5、6。這個連結串列的倒數第3個節點是值為4的節點。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        int len = 0;
        ListNode pre =head;
        while(pre != null){
            pre = pre.next;
            len++;
        }
        ListNode slow = head;
        ListNode fast = head;
        while(k>0){
            fast = fast.next;
            k--;
        }
        while(fast!=null){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}

劍指 Offer 24. 反轉連結串列

同上

劍指 Offer 52. 兩個連結串列的第一個公共節點

同上

面試題 02.01. 移除重複節點

同上

面試題 02.02. 返回倒數第 k 個節點

同上

面試題 02.03. 刪除中間節點

題目 實現一種演算法，刪除單向連結串列中間的某個節點（即不是第一個或最後一個節點），假定你只能訪問該節點。

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

面試題 02.06 迴文連結串列

同上

面試題 02.07. 連結串列相交

同上