【算法篇】鏈表專題

時間  2019-11-20
標籤 算法篇 鏈表 專題 简体版
原文   原文鏈接

　　前言：

　　從今天開始要攻克算法專題了，今天是鏈表篇，關於鏈表相關的考題，不會太多涉及時間複雜度，而主要考察鏈表和指針操做；爲啥大廠喜歡考察數據結構和算法？由於這些是對基本功的昇華，不會考察數組指針、函數指針等，考一個鏈表，就能考察對指針的理解，我相信不理解指針，鏈表學起來很費勁！ios

　　1、簡介

　　我會一個模塊一個模塊進行學習和練習，練習時我會從leetcode上選題，都知道leetcode吧？是OJ中最權威的平臺了，在上面能夠找算法題和練習，很好的一個網站，每個題都會說明leetcode的第幾題，方便你們查找和練習。web

　　2、反轉鏈表

　　LeetCode上第206題：Reverse Linked List，官網是英文，但鑑於英文對一些人看起來比較費勁，翻譯成中文，以下：算法

反轉單鏈表。
例子:
輸入:1 - > 2 - > 3 - > 4 - > 5 - > NULL
輸出:5 - > 4 - > 3 - > 2 - > 1 - > NULL
跟進:
鏈表能夠迭代或遞歸地反轉。你能實現這兩個嗎?

　　可能有人會想到直接去改鏈表節點裏的值，這是不容許，通常都是操做next指針，去改變指針指向；畫圖進行講解，以下：數組

 　　

　　須要三個指針pre/cur/next去反轉，將2位置指向pre位置，pre指向1號位置，1號位置指向3號位置，這樣就能夠進行反轉了。代碼以下：數據結構

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

// 206. Reverse Linked List
// https://leetcode.com/problems/reverse-linked-list/description/
// 時間複雜度: O(n)
// 空間複雜度: O(1)
class Solution {
public:
    ListNode* reverseList(ListNode* head) {

        ListNode* pre = NULL;
        ListNode* cur = head;
        while(cur != NULL){
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }

        return pre;
    }
};

　　我是按照LeetCode的格式進行編寫的，而後去LeetCode上去試一下，鑑於可能有人不知道怎麼使用LeetCode，我簡單進行演示一下怎麼使用：數據結構和算法

　　第一步：百度leetcode，以下：ide

　　

　　

　　　　第二步：點擊「Create Account」，建立本身的用戶，須要填寫郵箱，須要點擊連接進行激活，不然刷題沒法提交；剛開始寫的郵箱沒給我發郵件，又在我的資料裏從新換了郵箱，就能夠收到了；函數

　　　　第三步：在首頁找題，若是能記住題目，能夠輸入題目進行搜索；也能夠搜索題號，如206，也能夠搜索到，以下圖：學習

　

　　

第四步：提交代碼，我將上面寫的代碼放到leetcode，點擊右下角的「Submit Solution」,就能夠看到下面的「Submission Solution：Accepted」，就表示經過了，以下圖：測試

　　

   這樣就OK了。

　　3、測試程序

　　這部分主要說明一下怎麼去本身測試程序的運行？主要實現鏈表的建立、遍歷、銷燬（C++堆上內存要本身管理）。

　　一、建立鏈表

　　將數組傳給函數，根據數組實現鏈表賦值；還會傳入n建立多大的鏈表，代碼以下:

// 根據n個元素的數組arr建立一個鏈表, 並返回鏈表的頭
ListNode* createLinkedList(int arr[], int n){

    if(n == 0)
        return NULL;

    ListNode* head = new ListNode(arr[0]);
    ListNode* curNode = head;
    for(int i = 1 ; i < n ; i ++){
        curNode->next = new ListNode(arr[i]);
        curNode = curNode->next;
    }

    return head;
}

　　注意：建立的鏈表，沒有真實的「頭結點」，就是隻存一個開始指針的節點，因此刪除第一個節點要注意！

　　二、遍歷鏈表

　　經過頭結點進行遍歷鏈表，代碼以下：

// 打印以head爲頭結點的鏈表信息內容
void printLinkedList(ListNode* head){

    ListNode* curNode = head;
    while(curNode != NULL){
        cout << curNode->val << " -> ";
        curNode = curNode->next;
    }

    cout << "NULL" << endl;

    return;
}

　　三、銷燬鏈表

　　將建立時分配的內存釋放，代碼以下：

// 釋放以head爲頭結點的鏈表空間
void deleteLinkedList(ListNode* head){

    ListNode* curNode = head;
    while(curNode != NULL){
        ListNode* delNode = curNode;
        curNode = curNode->next;
        delete delNode;
    }

    return;
}

　　四、測試程序

　　對反轉鏈表代碼進行測試，總體代碼以下：

#include <iostream>

using namespace std;

/**
 * Definition for singly-linked list.
 */
struct ListNode {
     int val;
     ListNode *next;
     ListNode(int x) : val(x), next(NULL) {}
};

/// LinkedList 測試輔助函數

// 根據n個元素的數組arr建立一個鏈表, 並返回鏈表的頭
ListNode* createLinkedList(int arr[], int n){

    if(n == 0)
        return NULL;

    ListNode* head = new ListNode(arr[0]);
    ListNode* curNode = head;
    for(int i = 1 ; i < n ; i ++){
        curNode->next = new ListNode(arr[i]);
        curNode = curNode->next;
    }

    return head;
}

// 打印以head爲頭結點的鏈表信息內容
void printLinkedList(ListNode* head){

    ListNode* curNode = head;
    while(curNode != NULL){
        cout << curNode->val << " -> ";
        curNode = curNode->next;
    }

    cout << "NULL" << endl;

    return;
}

// 釋放以head爲頭結點的鏈表空間
void deleteLinkedList(ListNode* head){

    ListNode* curNode = head;
    while(curNode != NULL){
        ListNode* delNode = curNode;
        curNode = curNode->next;
        delete delNode;
    }

    return;
}


// 206. Reverse Linked List
// https://leetcode.com/problems/reverse-linked-list/description/
// 時間複雜度: O(n)
// 空間複雜度: O(1)
class Solution {
public:
    ListNode* reverseList(ListNode* head) {

        ListNode* pre = NULL;
        ListNode* cur = head;
        while(cur != NULL){
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }

        return pre;
    }
};

int main(){

    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr)/sizeof(int);

    ListNode* head = createLinkedList(arr, n);
    printLinkedList(head);

    ListNode* head2 = Solution().reverseList(head);
    printLinkedList(head2);

    deleteLinkedList(head2);

    return 0;
}
View Code

　　運行結果以下：

　　

　　進行了反轉，沒有問題；

　　4、刪除鏈表元素

 　　一、題目

　　LeetCode上第203題目：Remove Linked List Elements，題目以下：

從具備值val的整數鏈表中刪除全部元素。
例子:
輸入:1->2->6->3->4->5->6,val = 6
輸出:1 - > 2 - > 3 - > 4 - > 5

　　二、分析題目

　　先來分析一下題目，用圖來解釋以下：

　　

　　假如刪除值爲4的節點，先把4的next指針保存，在3號位置指向5，這徹底沒有問題；但問題會發生在第一個節點位置，它沒有前一個節點，那怎麼辦呢？在前面建立鏈表時也說過：沒有頭結點，因此使用虛擬頭結點！

　　代碼以下：

// 203. Remove Linked List Elements
// https://leetcode.com/problems/remove-linked-list-elements/description/
// 使用虛擬頭結點
// 時間複雜度: O(n)
// 空間複雜度: O(1)
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {

        // 建立虛擬頭結點
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;

        ListNode* cur = dummyHead;
        while(cur->next != NULL){
            if(cur->next->val == val){
                ListNode* delNode = cur->next;
                cur->next = delNode->next;
                delete delNode;
            }
            else
                cur = cur->next;
        }

        ListNode* retNode = dummyHead->next;
        delete dummyHead;

        return retNode;
    }
};

　　三、測試

　　測試程序也是上面的鏈表建立和遍歷，程序以下：

 

#include <iostream>

using namespace std;

///Definition for singly-linked list.
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

/// LinkedList Test Helper Functions
ListNode* createLinkedList(int arr[], int n){

    if(n == 0)
        return NULL;

    ListNode* head = new ListNode(arr[0]);
    ListNode* curNode = head;
    for(int i = 1 ; i < n ; i ++){
        curNode->next = new ListNode(arr[i]);
        curNode = curNode->next;
    }

    return head;
}

void printLinkedList(ListNode* head){

    if(head == NULL){
        cout << "NULL" << endl;
        return;
    }

    ListNode* curNode = head;
    while(curNode != NULL){
        cout << curNode->val;
        if(curNode->next != NULL)
            cout << " -> ";
        curNode = curNode->next;
    }

    cout << endl;

    return;
}

void deleteLinkedList(ListNode* head){

    ListNode* curNode = head;
    while(curNode != NULL){
        ListNode* delNode = curNode;
        curNode = curNode->next;
        delete delNode;
    }

    return;
}

// 203. Remove Linked List Elements
// https://leetcode.com/problems/remove-linked-list-elements/description/
// 使用虛擬頭結點
// 時間複雜度: O(n)
// 空間複雜度: O(1)
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {

        // 建立虛擬頭結點
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;

        ListNode* cur = dummyHead;
        while(cur->next != NULL){
            if(cur->next->val == val){
                ListNode* delNode = cur->next;
                cur->next = delNode->next;
                delete delNode;
            }
            else
                cur = cur->next;
        }

        ListNode* retNode = dummyHead->next;
        delete dummyHead;

        return retNode;
    }
};

int main() {

    int arr[] = {1, 2, 6, 3, 4, 5, 6};
    int n = sizeof(arr) / sizeof(int);

    ListNode* head = createLinkedList(arr, n);
    printLinkedList(head);

    Solution().removeElements(head, 6);
    printLinkedList(head);

    deleteLinkedList(head);

    return 0;
}
View Code

　　運行結果以下：

　　

 　　總結：

　　但願經過這篇博客，你們能對基本的鏈表算法題能輕鬆應對；歡迎點贊，不懂的歡迎隨時評論!多多支持，謝謝！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程