2. 程式人生 > 其它 >基礎演算法面試題---連結串列

基礎演算法面試題---連結串列

阿新 • • 發佈：2021-02-12

技術標籤：面試基礎演算法題連結串列演算法

前言

一般連結串列的基礎題演算法都很簡單，但卻是常見的面試題，因為連結串列能夠考察面試者的編碼能力，往往很容易想到解題方式，卻寫不出來。

下面總結了幾道常見的初級題，可以反覆練習，提高自己的編碼能力。

先準備兩個物件，一個單鏈表，一個雙鏈表

單鏈表

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;
    }

    @Override
    public String toString() {
        return "ListNode{" +
                "val=" + val +
                ", next=" + next +
                '}';
    }
}

雙鏈表

public class DoubleListNode
 
<T> {
    public T data;
    public DoubleListNode<T> last;
    public DoubleListNode<T> next;

    public DoubleListNode(T data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "DoubleListNode{" +
                "data="
 
 + data +
                ", next=" + next +
                '}';
    }
}

1、單鏈表反轉

單鏈表反轉，經典且基礎的連結串列題。

舉例：
原連結串列：1-2-3-4-5
反轉後：5-4-3-2-1

public class Code_01 {
    public static void main(String[] args) {
        ListNode n = new ListNode();
        ListNode head = n;
        for (int i = 1; i <= 5; i++) {
            n.next = new ListNode(i);
            n = n.next;
        }
        System.out.println("原連結串列：" + head);
        ListNode listNode = reverseList(head);
        System.out.println("反轉後：" + listNode);
    }

    private static ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode next;
        while (head != null) {
            next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }
        return pre;
    }
}

在這裡插入圖片描述

2、雙鏈表反轉

public class Code_02 {
    public static void main(String[] args) {
        DoubleListNode n1 = new DoubleListNode(1);
        DoubleListNode n2 = new DoubleListNode(2);
        n1.next = n2;
        n2.last = n1;
        DoubleListNode n3 = new DoubleListNode(3);
        n2.next = n3;
        n3.last = n2;
        System.out.println("原連結串列：" + n1);
        DoubleListNode listNode = reverseDoubleList(n1);
        System.out.println("反轉後：" + listNode);
    }

    private static DoubleListNode reverseDoubleList(DoubleListNode head) {
        DoubleListNode pre = null;
        DoubleListNode next;
        while (head != null) {
            next = head.next;
            head.next = pre;
            head.last = next;
            pre = head;
            head = next;
        }
        return pre;
    }
}

在這裡插入圖片描述

3、刪除連結串列中的某類節點

舉例：
原連結串列：1-2-3-4-5
刪除value=2的節點
結果：1-3-4-5

原連結串列：1-2-3-3-3-4-5
刪除value=3的節點
結果：1-2-4-5

原連結串列：1-1-2-3-4-5
刪除value=1的節點
結果：2-3-4-5

public class Code_03 {
    public static void main(String[] args) {
        ListNode n = new ListNode();
        ListNode head = n;
        for (int i = 1; i <= 5; i++) {
            n.next = new ListNode(i);
            n = n.next;
        }
        System.out.println("原連結串列：" + head);
        ListNode node = deleteNode(head, 3);
        System.out.println("刪除後：" + node);
    }

    private static ListNode deleteNode(ListNode head, int value) {
        //處理head本身就是要刪除的節點
        while (head != null) {
            if (head.val != value) {
                break;
            }
            head = head.next;
        }
        //始終記錄前一個節點，和當前節點的指標，如果當前節點就是要刪除的節點時，則讓前一個節點指向當前節點的下一個節點，即完成了刪除
        ListNode cur = head;
        ListNode pre = null;
        while (cur != null) {
            if (cur.val == value) {
                pre.next = cur.next;
            } else {
                pre = cur;
            }
            cur = cur.next;
        }
        return head;
    }
}

在這裡插入圖片描述

4、刪除重複元素1

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

舉例：
原連結串列: 1->1->2->3->3
刪除後: 1->2->3

public class Code_05 {
    public static void main(String[] args) {
        Code_05 c = new Code_05();
        ListNode n = new ListNode();
        ListNode head = n;
        for (int i = 1; i <= 5; i++) {
            n.next = new ListNode(i);
            n = n.next;
            if (i % 2 == 0) {
                n.next = new ListNode(i);
                n = n.next;
            }
        }
        System.out.println("原連結串列：" + head);
        System.out.println("刪除後：" + c.deleteDuplicates(head));
    }

    /**
     * 通過不斷移動cur，判斷當前cur的值與cur.next的值是否相等，如果相等，則只改變cur.next，並讓其指向下一個節點，就等於跳過了cur.next的節點
     * 如果不相等，則移動cur節點位置到cur.next上。
     * @param head
     * @return
     */
    public ListNode deleteDuplicates(ListNode head) {
        ListNode cur = head;
        while (cur != null && cur.next != null) {
            if (cur.val != cur.next.val) {
                cur = cur.next;
            } else {
                cur.next = cur.next.next;
            }
        }
        return head;
    }
}

5、刪除重複元素2

給定一個排序連結串列，刪除所有含有重複數字的節點，只保留原始連結串列中沒有重複出現的數字。

舉例：
原連結串列: 1->2->3->3->4->4->5
刪除後: 1->2->5

這是在前一道題目上的延伸。

解法一：

結合前兩題的方式，可以拆分處理，先用第4題的方式刪除重複的數字並記錄下來，再第3題的方式刪除指定數字。

public class Code_06 {

    public static void main(String[] args) {
        Code_06 c = new Code_06();
        ListNode n = new ListNode();
        ListNode head = n;
        for (int i = 1; i <= 5; i++) {
            n.next = new ListNode(i);
            n = n.next;
            if (i % 2 == 0) {
                n.next = new ListNode(i);
                n = n.next;
            }
        }
        System.out.println(head);
        System.out.println(c.deleteDuplicates(head));
    }

    public ListNode deleteDuplicates(ListNode head) {
        ListNode cur = head;
        Set<Integer> dupSet = new HashSet<>();
        while (cur != null && cur.next != null) {
            if (cur.val != cur.next.val) {
                cur = cur.next;
            } else {
                dupSet.add(cur.val);
                cur.next = cur.next.next;
            }
        }
        for (Integer val : dupSet) {
            head = deleteNode(head, val);
        }
        return head;
    }

    private ListNode deleteNode(ListNode head, int val) {
        while (head != null) {
            if (head.val != val) {
                break;
            }
            head = head.next;
        }
        ListNode pre = null;
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == val) {
                pre.next = cur.next;
            } else {
                pre = cur;
            }
            cur = cur.next;
        }
        return head;
    }

}

在這裡插入圖片描述

當然第一種解法只能當做是編碼的練習，出題者肯定不是希望你用這種方式處理。

解法二：

啞節點+雙指標

public class Code_06_01 {
    public static void main(String[] args) {
        Code_06_01 c = new Code_06_01();
        ListNode n = new ListNode();
        ListNode head = n;
        for (int i = 1; i <= 5; i++) {
            n.next = new ListNode(i);
            n = n.next;
            if (i % 2 == 0) {
                n.next = new ListNode(i);
                n = n.next;
            }
        }
        System.out.println(head);
        System.out.println(c.deleteDuplicates(head));
    }

    /**
     * 啞節點+雙指標
     * <p>
     * 構建一個啞節點，讓其next指向頭位置。
     * 再利用雙指標，n1,n2,初始都指向head位置，如果n1.next.val==n2.next.val，則讓n2向前移動一位，否則n1，n2一起向前移動一位
     *
     * @param head
     * @return
     */
    public ListNode deleteDuplicates(ListNode head) {
        ListNode dummy = new ListNode();
        dummy.next = head;
        ListNode n1 = dummy;
        ListNode n2 = head;
        while (n2 != null && n2.next != null) {
            if (n1.next.val != n2.next.val) {
                n1 = n1.next;
            } else {
                //n2一直移動，直到不等於n1為止
                while (n2 != null && n2.next != null && n1.next.val == n2.next.val) {
                    n2 = n2.next;
                }
                n1.next = n2.next;
            }
            n2 = n2.next;
        }
        return dummy.next;
    }
}

在這裡插入圖片描述

6、合併有序連結串列

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

原連結串列：l1 = [1,2,4]，l2 = [1,3,4]
合併後：[1,1,2,3,4,4]

public class Code_04 {

    public static void main(String[] args) {
        ListNode n = new ListNode(1);
        ListNode l1 = n;
        for (int i = 3; i <= 5; i = i + 2) {
            n.next = new ListNode(i);
            n = n.next;
        }
        ListNode n2 = new ListNode(2);
        ListNode l2 = n2;
        for (int i = 4; i <= 6; i = i + 2) {
            n2.next = new ListNode(i);
            n2 = n2.next;
        }
        Code_04 c = new Code_04();

        System.out.println("原連結串列1：" + l1);
        System.out.println("原連結串列2：" + l2);

        System.out.println("合併後：" + c.mergeTwoLists(l1, l2));

    }

    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        }
        if (l2 == null) {
            return l1;
        }
        ListNode mergeNode = new ListNode();
        ListNode pre = mergeNode;
        //比較兩個連結串列當前的值，值小的連結串列就把引用賦給mergeNode，並向後移動一位重新賦值給自己，同時pre指向值小的那個節點
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                pre.next = l1;
                l1 = l1.next;
            } else {
                pre.next = l2;
                l2 = l2.next;
            }
            pre = pre.next;
        }
        pre.next = l1 == null ? l2 : l1;

        return mergeNode.next;
    }
}

在這裡插入圖片描述

7、雙向連結串列實現棧、佇列

佇列：先進先出

棧：先進後出

分別用雙向連結串列實現，從頭進，從頭出，從尾進，從尾出即可模擬出佇列和棧的資料結構。

public class NodeUtils<T> {

    DoubleListNode<T> head;
    DoubleListNode<T> tail;

    /**
     * 從頭進
     * @param data
     */
    public void addHead(T data) {
        DoubleListNode<T> node = new DoubleListNode(data);
        if (head == null) {
            head = node;
            tail = node;
        } else {
            node.next = head;
            head.last = node;
            head = node;
        }
    }

    /**
     * 從尾進
     * @param data
     */
    public void addTail(T data) {
        DoubleListNode<T> node = new DoubleListNode(data);
        if (head == null) {
            head = node;
        } else {
            tail.next = node;
            node.last = tail;
        }
        tail = node;
    }

    /**
     * 從頭出
     * @return
     */
    public T popHead() {
        if (head == null) {
            return null;
        }
        DoubleListNode<T> h = head;
        if (head == tail) {
            head = null;
            tail = null;
        } else {
            head = head.next;
            head.last = null;
        }
        return h.data;
    }

    /**
     * 從尾出
     * @return
     */
    public T popTail() {
        if (tail == null) {
            return null;
        }
        DoubleListNode<T> t = tail;
        if (head == tail) {
            head = null;
            tail = null;
        } else {
            tail = tail.last;
            tail.next = null;
        }
        return t.data;

    }

}

佇列

/**
 * 佇列（先進先出）：從連結串列頭進，從連結串列尾出
 * @param <T>
 */
public class ListNodeQueue<T> {

    NodeUtils<T> nodeUtils = new NodeUtils();

    public void push(T data) {
        nodeUtils.addHead(data);
    }

    public T pop() {
        return nodeUtils.popTail();
    }

}

棧

/**
 * 佇列（先進先出）：從連結串列頭進，從連結串列尾出
 *
 * @param <T>
 */
public class ListNodeQueue<T> {

    NodeUtils<T> nodeUtils = new NodeUtils();

    public void push(T data) {
        nodeUtils.addHead(data);
    }

    public T pop() {
        return nodeUtils.popTail();
    }

}

驗證

public class Code_07 {
    public static void main(String[] args) {
        ListNodeStack stack = new ListNodeStack();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        System.out.println("棧：壓進去1,2,3");
        System.out.println("彈出" + stack.pop() + "," + stack.pop() + "," + stack.pop());

        ListNodeQueue queue = new ListNodeQueue();
        queue.push(1);
        queue.push(2);
        queue.push(3);
        System.out.println("佇列：壓進去1,2,3");
        System.out.println("彈出" + queue.pop() + "," + queue.pop() + "," + queue.pop());
    }
}

在這裡插入圖片描述

相關推薦

基礎演算法面試題---連結串列

技術標籤：面試基礎演算法題連結串列演算法 前言 一般連結串列的基礎題演算法都很簡單，但卻是常見的面試題，因為連結串列能夠考察面試者的編碼能力，往往很容易想到解題方式，卻寫不出來。

面試題--連結串列實現插入排序

題目連結 程式碼： /** * Definition for singly-linked list. * struct ListNode { *int val; *ListNode *next;

基礎演算法面試題---異或運算

技術標籤：面試基礎演算法題演算法java 異或運算 異或是一個數學運算子，應用於邏輯運算，計算機符號為“eor”。

leetcode 最常見的前端基礎演算法面試題（上）

把這些基礎演算法題掌握好，基礎不牢地動山搖，後面中級題很多都是在這些基礎題的基礎上的。

TypeScript資料結構與演算法（5）最基礎的資料結構-連結串列-LinkedList

連結串列的概念，使用文字描述過於蒼白，用一張圖解釋： 從圖中可以看出連結串列的特性：

TypeScript資料結構與演算法（7）最基礎的資料結構-連結串列佇列-LinkedListQueue

使用連結串列來實現佇列，原始碼如下： import { Interface_Queue } from \"../Interface_Queue\";

2020年Java基礎高頻面試題彙總（1.4W字詳細解析，你能遇到的都在這了）

1、 Java語言有哪些特點 （1）簡單易學、有豐富的類庫 （2）面向物件（Java最重要的特性，讓程式耦合度更低，內聚性更高）

Python-[--001--]-Python涉及的演算法面試題

第一題：將 a = [1,1,1,2,2,3,3,3,4,5,6,6,6,7,8,8]轉化為c = [1,1,2,2,3,3,4,5,6,6,7,8] 分析：對出現相同元素次數大於2的進行處理

演算法面試題：一個List<Student>，要求刪除裡面的男生，不用Linq和Lamda，求各種解，並說明優缺點！

演算法面試題：一個List，要求刪除裡面的男生，不用Linq和Lamda，求各種解，並說明優缺點！

java資料結構與演算法三： 連結串列（雙向連結串列）

連結串列：雙鏈表 一、 雙向連結串列的操作分析和實現 （使用帶head頭的雙向連結串列實現 —— 水滸英雄排行榜）

ACwing（基礎）--- 陣列模擬連結串列、棧、佇列

單鏈表 適用於鄰接表：儲存圖和樹 //head 表示頭結點的下標 // e[i] 表示節點i的值

資料結構和演算法_單向連結串列

連結串列是有序的列表，在記憶體中不一定是連續的 連結串列是樹，森林，圖的基礎

資料結構與演算法_雙向連結串列

package chapter02 import util.control.Breaks._ object test05 { def main(args:Array[String]):Unit={ val DoubleLinkedList = new DoubleLinkedList()

演算法千萬不能硬學，大廠演算法面試題其實很簡單

什麼是演算法？ 有一個很著名的公式 “程式=資料結構+演算法”。 曾經跟朋友吃飯的時候我問他什麼是演算法，他說演算法嘛，就是一套方法，需要的時候拿過來，套用就可以，我吐槽他，他說的是小學數學題的演

高頻演算法面試題：快慢指標

​ 前提 今天（2019-05-10）中午吃飯的時候刷了下技術型別的公眾號，看到有前輩過了Ant的高P面試，其中有一道題考查了單鏈表搜尋位於中間的節點的演算法。看著演算法就飯，覺得解決方案很有趣，於是這裡嘗試重現一下

牛客經典筆刷演算法題-LC5-連結串列的插入排序

技術標籤：演算法排序演算法連結串列 牛客經典筆刷演算法題-LC5-連結串列的插入排序

JAVA基礎階段面試題

技術標籤：java 一.JAVA基礎 1.continue和break的區別 break和continue都是用來控制迴圈結構的

經典演算法題-判斷連結串列中是否有環

源自LeetCode-141 給定一個連結串列，判斷連結串列中是否有環。 如果連結串列中有某個節點，可以通過連續跟蹤 next 指標再次到達，則連結串列中存在環。 為了表示給定連結串列中的環，我們使用整數 pos 來表示連結串

常用演算法的總結——連結串列

連結串列常用演算法：快慢指標、利用HashMap、棧 如： 1 快慢指標 1) 輸入連結串列頭節點，奇數長度返回中點，偶數長度返回上中點2) 輸入連結串列頭節點，奇數長度返回中點，偶數長度返回下中點3) 輸入連結串列頭節點

演算法：環形連結串列

技術標籤：資料結構與演算法 題目：判斷連結串列是否有環 //環形連結串列 //雜湊表