2. 程式人生 > >劍指offer題解（十一）：c++&java

劍指offer題解（十一）：c++&java

阿新 • • 發佈：2019-01-29

序列化二叉樹

題目描述

請實現兩個函式，分別用來序列化和反序列化二叉樹

  1. 對於序列化：使用前序遍歷，遞迴的將二叉樹的值轉化為字元，並且在每次二叉樹的結點不為空時，在轉化val所得的字元之後新增一個’ ， ‘作為分割。對於空節點則以 ‘#’ 代替。
    1. 對於反序列化：按照前序順序，遞迴的使用字串中的字元建立一個二叉樹(特別注意：在遞迴時，遞迴函式的引數一定要是char ** ，這樣才能保證每次遞迴後指向字串的指標會隨著遞迴的進行而移動！！！)

java

public class Solution {
    String Serialize(TreeNode root)
    {
        if
 
(root==null)
            return "";
        StringBuilder sb = new StringBuilder();
        Serialize2(root,sb);
        return sb.toString();
    }
    void Serialize2(TreeNode root, StringBuilder sb)
    {
        if(root==null)
        {
            sb.append("#,");
            return;
        }
        sb.append(root.val);
        sb.append(','
 
);
        Serialize2(root.left,sb);
        Serialize2(root.right,sb);
    }
    int index = -1;
    TreeNode Deserialize(String str)
    {
        if(str.length()==0)
            return null;

        String [] strs = str.split(",");
        return Deserialize2(strs);


    }

    TreeNode Deserialize2(String[] strs)
    {
        index
 
++;
        if(!strs[index].equals("#"))
        {
            TreeNode root = new TreeNode(0);
            root.val = Integer.parseInt(strs[index]);
            root.left = Deserialize2(strs);
            root.right = Deserialize2(strs);
            return root;
        }
        return null;
    }
}

c++

class Solution {
public:
    vector<int> buf;
    void dfs1(TreeNode *root) {
        if(!root) buf.push_back(0xFFFFFFFF);
        else {
            buf.push_back(root->val);
            dfs1(root->left);
            dfs1(root->right);
        }
    }
    TreeNode* dfs2(int* &p) {
        if(*p==0xFFFFFFFF) {
            p++;
            return NULL;
        }
        TreeNode* res=new TreeNode(*p);
        p++;
        res->left=dfs2(p);
        res->right=dfs2(p);
        return res;
    }
    char* Serialize(TreeNode *root) {
        buf.clear();
        dfs1(root);
        int bufSize=buf.size();
        int *res=new int[bufSize];
        for(int i=0;i<bufSize;i++) res[i]=buf[i];
        return (char*)res;
    }
    TreeNode* Deserialize(char *str) {
        int *p=(int*)str;
        return dfs2(p);
    }
};

字串的排列

題目描述

輸入一個字串，按字典序打印出該字串中字元的所有排列。例如輸入字串 abc，則打印出由字元 a, b, c 所能排列出來的所有字串 abc, acb, bac, bca, cab 和 cba。
ps:輸入一個字串,長度不超過9(可能有字元重複),字元只包括大小寫字母。

解題思路

c++

class Solution {
public:
    vector<string> Permutation(string str) {
        //可以用遞迴來做
        vector<string> array;
        if(str.size()==0)
            return array;
        Permutation(array, str, 0);
        sort(array.begin(), array.end());
        return array;
    }

    void Permutation(vector<string> &array, string str, int begin)//遍歷第begin位的所有可能性
    {
        if(begin==str.size()-1)
            array.push_back(str);
        for(int i=begin; i<=str.size()-1;i++)
        {
            if(i!=begin && str[i]==str[begin])//有重複字元時，跳過
                continue;
            swap(str[i], str[begin]);//當i==begin時，也要遍歷其後面的所有字元；
                                    //當i!=begin時，先交換，使第begin位取到不同的可能字元，再遍歷後面的字元
            Permutation(array, str, begin+1);//遍歷其後面的所有字元；

            swap(str[i], str[begin]);//為了防止重複的情況，還需要將begin處的元素重新換回來

            /*舉例來說“abca”，為什麼使用了兩次swap函式
                交換時是a與b交換，遍歷；
                交換時是a與c交換，遍歷；（使用一次swap時，是b與c交換）
                交換時是a與a不交換；
                */
        }
    }
};

java

import java.util.*;

public class Solution {

    public ArrayList<String> Permutation(String str) {
        ArrayList<String> result = new ArrayList<String>() ;
        if(str==null || str.length()==0) { return result ; }

        char[] chars = str.toCharArray() ;
        TreeSet<String> temp = new TreeSet<>() ;
        Permutation(chars, 0, temp);
        result.addAll(temp) ;
        return result ;
    }

    public void Permutation(char[] chars, int begin, TreeSet<String> result) {
        if(chars==null || chars.length==0 || begin<0 || begin>chars.length-1) { return ; }

        if(begin == chars.length-1) {
            result.add(String.valueOf(chars)) ;
        }else {
            for(int i=begin ; i<=chars.length-1 ; i++) {
                swap(chars, begin, i) ;

                Permutation(chars, begin+1, result);

                swap(chars, begin, i) ;
            }
        }
    }

    public void swap(char[] x, int a, int b) {
        char t = x[a];
        x[a] = x[b];
        x[b] = t;
    }

}

陣列中出現次數超過一半的數字

題目描述

陣列中有一個數字出現的次數超過陣列長度的一半，請找出這個數字。例如輸入一個長度為9的陣列{1,2,3,2,2,2,5,4,2}。由於數字2在陣列中出現了5次，超過陣列長度的一半，因此輸出2。如果不存在則輸出0。

解題思路

多數投票問題，可以利用 Boyer-Moore Majority Vote Algorithm 來解決這個問題，使得時間複雜度為 O(N)。

使用 cnt 來統計一個元素出現的次數，當遍歷到的元素和統計元素不相等時，令 cnt–。如果前面查找了 i 個元素，且 cnt == 0 ，說明前 i 個元素沒有 majority，或者有 majority，但是出現的次數少於 i / 2 ，因為如果多於 i / 2 的話 cnt 就一定不會為 0 。此時剩下的 n - i 個元素中，majority 的數目依然多於 (n - i) / 2，因此繼續查詢就能找出 majority。

java

public int MoreThanHalfNum_Solution(int[] nums) {
    int majority = nums[0];
    for (int i = 1, cnt = 1; i < nums.length; i++) {
        cnt = nums[i] == majority ? cnt + 1 : cnt - 1;
        if (cnt == 0) {
            majority = nums[i];
            cnt = 1;
        }
    }
    int cnt = 0;
    for (int val : nums)
        if (val == majority)
            cnt++;
    return cnt > nums.length / 2 ? majority : 0;
}

c++

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers)
    {
        if(numbers.empty()) return 0;

        // 遍歷每個元素，並記錄次數；若與前一個元素相同，則次數加1，否則次數減1
        int result = numbers[0];
        int times = 1; // 次數

        for(int i=1;i<numbers.size();++i)
        {
            if(times == 0)
            {
                // 更新result的值為當前元素，並置次數為1
                result = numbers[i];
                times = 1;
            }
            else if(numbers[i] == result)
            {
                ++times; // 相同則加1
            }
            else
            {
                --times; // 不同則減1               
            }
        }

        // 判斷result是否符合條件，即出現次數大於陣列長度的一半
        times = 0;
        for(int i=0;i<numbers.size();++i)
        {
            if(numbers[i] == result) ++times;
        }

        return (times > numbers.size()/2) ? result : 0;
    }
};

最小的 K 個數

題目描述

輸入n個整數，找出其中最小的K個數。例如輸入4,5,1,6,2,7,3,8這8個數字，則最小的4個數字是1,2,3,4,。

python

先皮一下

import heapq
class Solution:
    def GetLeastNumbers_Solution(self, tinput, k):
        if k> len(tinput):
            return []
        return list(heapq.nsmallest(k,tinput))

用api也可以通過相應的測試

解題思路

快速選擇
複雜度：O(N) + O(1)
只有當允許修改陣列元素時才可以使用
快速排序的 partition() 方法，會返回一個整數 j 使得 a[l..j-1] 小於等於 a[j]，且 a[j+1..h] 大於等於 a[j]，此時 a[j] 就是陣列的第 j 大元素。可以利用這個特性找出陣列的第 K 個元素，這種找第 K 個元素的演算法稱為快速選擇演算法。

public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
    ArrayList<Integer> ret = new ArrayList<>();
    if (k > nums.length || k <= 0)
        return ret;
    int kthSmallest = findKthSmallest(nums, k - 1);
    // findKthSmallest 會改變陣列，使得前 k 個數都是最小的 k 個數
    for (int i = 0; i < k; i++)
        ret.add(nums[i]);
    return ret;
}

public int findKthSmallest(int[] nums, int k) {
    int l = 0, h = nums.length - 1;
    while (l < h) {
        int j = partition(nums, l, h);
        if (j == k)
            break;
        if (j > k)
            h = j - 1;
        else
            l = j + 1;
    }
    return nums[k];
}

private int partition(int[] nums, int l, int h) {
    // 切分元素
    int parti = nums[l];
    int i = l, j = h + 1;
    while (true) {
        while (i != h && nums[++i] < parti) ;
        while (j != l && nums[--j] > parti) ;
        if (i >= j)
            break;
        swap(nums, i, j);
    }
    swap(nums, l, j);
    return j;
}

private void swap(int[] nums, int i, int j) {
    int t = nums[i];
    nums[i] = nums[j];
    nums[j] = t;
}

最小堆的方法

複雜度：O(NlogK) + O(K)
特別適合處理海量資料
應該使用大頂堆來維護最小堆，而不能直接建立一個小頂堆並設定一個大小，企圖讓小頂堆中的元素都是最小元素。

維護一個大小為 K 的最小堆過程如下：在新增一個元素之後，如果大頂堆的大小大於 K，那麼需要將大頂堆的堆頂元素去除。

public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
    if (k > nums.length || k <= 0)
        return new ArrayList<>();
    PriorityQueue<Integer> maxHeap = new PriorityQueue<>((o1, o2) -> o2 - o1);
    for (int num : nums) {
        maxHeap.add(num);
        if (maxHeap.size() > k)
            maxHeap.poll();
    }
    ArrayList<Integer> ret = new ArrayList<>(maxHeap);
    return ret;
}

相關推薦

劍指offer題解（十一）：c++&java

序列化二叉樹 題目描述 請實現兩個函式，分別用來序列化和反序列化二叉樹 對於序列化：使用前序遍歷，遞迴的將二叉樹的值轉化為字元，並且在每次二叉樹的結點不為空時，在轉化val所得的字元之後新增一個’ ， ‘作為分割。對於空節點則以 ‘#’ 代替。 對

劍指offer系列（十一）二叉搜尋樹與雙向連結串列， 字串的排序

二叉搜尋樹與雙向連結串列 題目描述 輸入一棵二叉搜尋樹，將該二叉搜尋樹轉換成一個排序的雙向連結串列。要求不能建立任何新的結點，只能調整樹中結點指標的指向。 解題思路： 由於輸入的一個二叉搜尋樹，其左子樹小於右子樹的值，這位後面的排序做了準備，因為只需要中序遍歷即可，將所有 的節點儲存

劍指offer系列（十四）二叉樹的深度，平衡二叉樹，陣列中只出現一次的數字

二叉樹的深度 題目描述 輸入一棵二叉樹，求該樹的深度。從根結點到葉結點依次經過的結點（含根、葉結點）形成樹的一條路徑，最長路徑的長度為樹的深度。 解題思路： 利用遞迴實現。如果一棵樹只有一個結點，那麼它的深度為1。遞迴的時候無需判斷左右子樹是否存在，因為如果該節點 為葉節點，它的左右

劍指offer第三十一題：整數中1出現的次數（從1到n整數中1出現的次數）

題目描述 求出1~13的整數中1出現的次數,並算出100~1300的整數中1出現的次數？為此他特別數了一下1~13中包含1的數字有1、10、11、12、13因此共出現6次,但是對於後面問題他就沒轍了。ACMer希望你們幫幫他,並把問題更加普遍化,可以很快的求出任意非負整數區

劍指offer題解（十）：C++&java

二叉搜尋樹的後序遍歷序列 題目描述 輸入一個整數陣列，判斷該陣列是不是某二叉搜尋樹的後序遍歷的結果。假設輸入的陣列的任意兩個數字都互不相同。 例如，下圖是後序遍歷序列 3,1,2 所對應的二叉搜尋樹。 解題思路 BST的後序序列的合法序列是

劍指offer系列（十二）最小的k個數， 連續子陣列的最大和，整數中1出現的個數

最小的k個數 題目描述 輸入n個整數，找出其中最小的K個數。例如輸入4,5,1,6,2,7,3,8這8個數字，則最小的4個數字是1,2,3,4,。 解題思路： 思路1，這一題應用堆排序演算法複雜度只有O(nlog k)，堆是完全二叉樹的一種，最大堆就是最上面的數是最大的，該方法基於二

劍指offer系列（十六）翻轉單詞順序列，撲克牌順子，孩子們的遊戲（圓圈中最後剩下的數）

翻轉單詞順序列 題目描述 牛客最近來了一個新員工Fish，每天早晨總是會拿著一本英文雜誌，寫些句子在本子上。同事Cat對Fish寫的內容頗感興趣，有一天他向Fish借來翻看，但卻讀不懂它的意思。例如，“student. a am I”。後來才意識到，這傢伙原來把句子單詞的順序翻轉了，正確的句

劍指offer系列（十五）和為S的連續正數序列，和為s的兩個數字，左旋轉字串

和為S的連續正數序列 題目描述 小明很喜歡數學,有一天他在做數學作業時,要求計算出9~16的和,他馬上就寫出了正確答案是100。但是他並不滿足於此,他在想究竟有多少種連續的正數序列的和為100(至少包括兩個數)。沒多久,他就得到另一組連續正數和為100的序列:18,19,20,21,22。現

劍指offer系列（十七）求1+2+3+...+n，不用加減乘除做加法，把字串轉換成整數

求1+2+3+...+n 題目描述 求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等關鍵字及條件判斷語句（A?B:C）。 解題思路： 法一：利用python的特性 法二：用兩個函式，一個遞迴，另一個終止遞迴。如果對n連續進

劍指Offer題解（Python版）

二叉樹的映象 連結串列中環的入口結點 刪除連結串列中重複的結點 從尾到頭列印連結串列 斐波那契數列 跳臺階 變態跳臺階 矩形覆蓋 把字串轉換成整數 平衡二叉樹 和為S的連續正數序列 左旋轉字串 數字在排序陣列中出現的次數 陣列中只出現一次的數字 翻轉單詞順序列

《劍指offer》第二十一題（調整數組順序使奇數位於偶數前面）

有意 argv 條件 copy 判斷 \n str 方法 class // 面試題21：調整數組順序使奇數位於偶數前面 // 題目：輸入一個整數數組，實現一個函數來調整該數組中數字的順序，使得所有 // 奇數位於數組的前半部分，所有偶數位於數組的後半部分。 #

劍指offer題解（連續子陣列的最大和）

題目描述 HZ偶爾會拿些專業問題來忽悠那些非計算機專業的同學。今天測試組開完會後,他又發話了:在古老的一維模式識別中,常常需要計算連續子向量的最大和,當向量全為正數的時候,問題很好解決。但是,如果向量中包含負數,是否應該包含某個負數,並期望旁邊的正數會彌補它呢？例如:{6,-3,-2,7,-

劍指offer題解（陣列中出現次數超過一半的數字）

題目描述 陣列中有一個數字出現的次數超過陣列長度的一半，請找出這個數字。例如輸入一個長度為9的陣列{1,2,3,2,2,2,5,4,2}。由於數字2在陣列中出現了5次，超過陣列長度的一半，因此輸出2。如果不存在則輸出0。   解題思路   先找到出現次數最多

劍指offer題解（二叉樹與雙向連結串列）

題目描述 輸入一棵二叉搜尋樹，將該二叉搜尋樹轉換成一個排序的雙向連結串列。要求不能建立任何新的結點，只能調整樹中結點指標的指向。   解題思路   中序遍歷搜尋二叉樹，用pre儲存中序遍歷的前一個節點，cur為當前節點，然後使pre->right=cu

劍指offer題解（複雜連結串列的複製）

題目描述 輸入一個複雜連結串列（每個節點中有節點值，以及兩個指標，一個指向下一個節點，另一個特殊指標指向任意一個節點），返回結果為複製後複雜連結串列的head。（注意，輸出結果中請不要返回引數中的節點引用，否則判題程式會直接返回空） 思路 新建一個連結串列，先不管random指標，根據n

劍指Offer題解（二）陣列問題

#include<vector> using namespace std; #pragma region 二維陣列中的查詢 二維陣列 //在一個二維陣列中（每個一維陣列的長度相同），每一行都按照從左到右遞增的順序排序， //每一列都按照從上到下

劍指Offer題解（三）字串問題

#include<vector> using namespace std; // getline(cin, str); //一行一行輸入可輸入空格 #pragma region 替換空格 字串 //請實現一個函式，將一個字串中的每個空格替換成“

劍指offer題解（四）：java&c++

矩陣中的路徑 題目描述 請設計一個函式，用來判斷在一個矩陣中是否存在一條包含某字串所有字元的路徑。路徑可以從矩陣中的任意一個格子開始，每一步可以在矩陣中向左，向右，向上，向下移動一個格子。如果一條路徑經過了矩陣中的某一個格子，則該路徑不能再進入該格子。

劍指offer題解（八）：c++&java

二叉樹的映象 題目描述 操作給定的二叉樹，將其變換為源二叉樹的映象。 解題思路 c++ class Solution { private: void swapfun(TreeNode *root) { T

劍指offer題解（十三）

開篇 十幾天沒有刷題了，今天又可以開始刷題啦 連續子陣列的最大和 題目描述 HZ偶爾會拿些專業問題來忽悠那些非計算機專業的同學。今天測試組開完會後,他又發話了:在古老的一維模式識別中,常常需要計算連續子向量的最大和,當向量全為正數的時候,問題很好