- 前言
- 面試題4 二維數組的查找
- 面試題5：替換空格
- 面試題6：從尾到頭打印鏈表
- 面試題7：重建二叉樹
- 面試題8：二叉樹的下一個節點
- 面試題9：用兩個棧實現隊列
- 面試題10：斐波那契數列
- 面試題11：旋轉數組的最小數字
- 面試題12：矩陣中的路徑
- 面試題13：機器人的運動范圍
- 面試題14：剪繩子
- 面試題15：二進制中1的個數
- 面試題16：數值的整數次方
- 面試題17：打印從1到最大的n位數
- 面試題18：刪除鏈表的節點
- 面試題19：正則表達式匹配
- 面試題20：表示數值的字符串
- 面試題21：調整數組順序使奇數位於偶數前面
- 面試題22：鏈表中倒數第k個節點
- 面試題23：鏈表中環的入口節點
- 面試題24：反轉鏈表
- 面試題25：合並兩個排序的鏈表
- 面試題26：樹的子結構
- 面試題27：二叉樹的鏡像
- 面試題28：對稱的二叉樹
- 面試題29：順時針打印矩陣
- 面試題30：包含min函數的棧
- 面試題31：棧的壓入、彈出序列
- 面試題32：從上到下打印二叉樹
- 面試題33：二叉搜索樹的后序遍歷序列
- 面試題34：二叉樹中和為某一值的路徑
- 面試題35：復雜鏈表的復制
- 面試題36：二叉搜索樹與雙向鏈表
- 面試題37：序列化二叉樹
- 面試題38：字符串的排列
- 面試題39：數組中出現次數超過一半的數字
- 面試題40：最小的k個數
- 面試題41：數據流中的中位數
- 面試題42：連續子數組的最大和
- <--------To be continued
前言
找工作必刷書，每次學習其他內容前先刷一兩題熱熱身，相對於ACM來說簡單了很多，就當復習下學過的知識，順便划划水，疫情期間還是太閑的。
題目在牛客網上都有，不過牛客網似乎沒有非法輸入樣例，例如空指針作為測試數據啥的，為節省時間，所以一切從簡，無視非法輸入數據，給出的代碼均在牛客網上AC就算了。
牛客網地址：https://www.nowcoder.com/ta/coding-interviews?page=1
面試題4 二維數組的查找
題目：在一個二維數組中（每個一維數組的長度相同），每一行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。請完成一個函數，輸入這樣的一個二維數組和一個整數，判斷數組中是否含有該整數。
一維二分法
顯然，每行或每列都是順序排序，所以可以遍歷每行，然后對每列進行二分查找，反之亦可。
時間復雜度O(nlogn)，空間復雜度O(1)
二維查找法
這是書上的方法，只要將右上角的數字作為重點即可。
顯然，對於右上角的數字X來說，其左邊的必然小於X，其下面的必然大於X。
那么，當所需查找的數字小於X時，顯然可以排除掉X所在的列，因為該列的數字大小均 >=X，反之則排出行即可。
時間復雜度O(n)，空間復雜度O(1)
class Solution {
public:
bool Find(int target, vector<vector<int> > array) {
int max_row = array.size();
int row = 0;
int column = array[0].size()-1;
while(row < max_row && column >= 0){
if (target == array[row][column]) return true;
else if (target < array[row][column]) column--;
else row++;
}
return false;
}
};
面試題5：替換空格
題目：請實現一個函數，將一個字符串中的每個空格替換成“%20”。例如，當字符串為We Are Happy.則經過替換之后的字符串為We%20Are%20Happy。要求只能在原來的數組中替換，保證輸入后的字符串有足夠多的空余內存。
偽新建數組法
雖然題目要求了不能在原來數組替換，但是原來數組內存足夠多啊，完全可以把原來數組的后面當作一個新數組即可，替換完后再將原來數組的起始地址再+原來數組的長度+1，這方法有點取巧，雖然符合題目要求，這里就懶得敲代碼了。
從后往前法
先找出所有空格數，顯然替換后的數組長度 = 舊數組長度 + 空個數*2，然后從后往前依次替換即可。
class Solution {
public:
void replaceSpace(char *str,int length) {
int num = 0;//空格數
for(int i = 0;str[i];i++)
num += (str[i] == ' ');
int index_old = length;
int index_new = length+num*2;
while(index_old >= 0){
if(str[index_old] != ' ') str[index_new--] = str[index_old--];
else{
str[index_new--] = '0';
str[index_new--] = '2';
str[index_new--] = '%';
index_old--;
}
}
return ;
}
};
面試題6：從尾到頭打印鏈表
簡單遞歸即可，略。
面試題7：重建二叉樹
題目：輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建出該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重復的數字。例如輸入前序遍歷序列{1,2,4,7,3,5,6,8}和中序遍歷序列{4,7,2,1,5,3,8,6}，則重建二叉樹並返回。
題解
較為簡單，僅給出代碼
/**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution
{
public:
TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
if(pre.empty()) return nullptr;
TreeNode *root = new TreeNode(pre[0]);
auto it = find(vin.begin(),vin.end(),pre[0]);
root->left = reConstructBinaryTree(
vector<int>(pre.begin()+1,pre.begin()+1+(it-vin.begin())),vector<int>(vin.begin(),it));
root->right = reConstructBinaryTree(
vector<int>(pre.begin()+1+(it-vin.begin()),pre.end()),vector<int>(it+1,vin.end()));
return root;
}
};
面試題8：二叉樹的下一個節點
題目：給定一個二叉樹和其中的一個結點，請找出中序遍歷順序的下一個結點並且返回。注意，樹中的結點不僅包含左右子結點，同時包含指向父結點的指針。
題解
較為簡單，兩種情況：
1、若有右節點，則找出右節點的最左節點
2、若無右節點，則循環找出父節點，當一個父節點的左節點等於子節點時，返回父節點
/*
struct TreeLinkNode {
int val;
struct TreeLinkNode *left;
struct TreeLinkNode *right;
struct TreeLinkNode *next;
TreeLinkNode(int x) :val(x), left(NULL), right(NULL), next(NULL) {
}
};
*/
class Solution {
public:
TreeLinkNode* GetNext(TreeLinkNode* pNode){
if (pNode->right != nullptr){
pNode = pNode->right;
while(pNode->left != nullptr)
pNode = pNode->left;
return pNode;
}
while(true){
TreeLinkNode *father = pNode->next;
if(father == nullptr||father->left == pNode) return father;
pNode = father;
}
}
};
面試題9：用兩個棧實現隊列
題目：用兩個棧來實現一個隊列，完成隊列的Push和Pop操作。 隊列中的元素為int類型。
題解
較為簡單，棧是先進后出，隊列是先進先出，棧和隊列正好相反，兩個棧之間可以實現元素的反序。
舉個例子，第一個棧依次放入{1,2,3,4}，將第一個棧依次排除放入第二個棧中，第二個棧則變成了{4,3,2,1}，此時pop出第二個棧便是隊列的順序。
注意：當第二個棧為空時才能進行此操作。
class Solution
{
public:
void push(int node) {
stack1.push(node);
}
int pop() {//懶得考慮隊列為空的情況
if(stack2.empty()){
while(!stack1.empty()){
stack2.push(stack1.top());
stack1.pop();
}
}
int ans = stack2.top();
stack2.pop();
return ans;
}
private:
stack<int> stack1;
stack<int> stack2;
};
面試題10：斐波那契數列
題目：大家都知道斐波那契數列，現在要求輸入一個整數n，請你輸出斐波那契數列的第n項（從0開始，第0項為0）
矩陣快速冪
遞歸效率太低，時間復雜度應該是\(O(2^n)\)，如果使用記憶化搜索或循環的話，可以降到\(O(n)\)，不過這兩個都是常規操作，使用矩陣快速冪的話可以達到\(O(logn)\)。
詳見博文：https://www.cnblogs.com/MMMMMMMW/p/12300262.html
面試題11：旋轉數組的最小數字
題目：把一個數組最開始的若干個元素搬到數組的末尾，我們稱之為數組的旋轉。
輸入一個非遞減排序的數組的一個旋轉，輸出旋轉數組的最小元素。
例如數組{3,4,5,1,2}為{1,2,3,4,5}的一個旋轉，該數組的最小值為1。
NOTE：給出的所有元素都大於0，若數組大小為0，請返回0。
二分查找
書上寫的是遞增，牛客的是非遞減，所以需要注意的是可能會有相同元素。
對於牛客的非遞減而言，就會出現{1,2,1,1,1,1,1}和{1,1,1,1,1,2,1}的情況，顯然難以二分，這里就有坑了，只能一格一格移動，所以即使用二分，最壞情況下還是\(O(n)\)，而書上的遞增數組則可以\(O(logn)\)，直接跳過這題了。
面試題12：矩陣中的路徑
請設計一個函數，用來判斷在一個矩陣中是否存在一條包含某字符串所有字符的路徑。路徑可以從矩陣中的任意一個格子開始，每一步可以在矩陣中向左，向右，向上，向下移動一個格子。如果一條路徑經過了矩陣中的某一個格子，則該路徑不能再進入該格子。 例如\(\begin{bmatrix} a & b & c &e \\ s & f & c & s \\ a & d & e& e\end{bmatrix}\)矩陣中包含一條字符串"bcced"的路徑，但是矩陣中不包含"abcb"路徑，因為字符串的第一個字符b占據了矩陣中的第一行第二個格子之后，路徑不能再次進入該格子。
思路
dfs和bfs都行吧，水題跳過。
面試題13：機器人的運動范圍
地上有一個m行和n列的方格。一個機器人從坐標0,0的格子開始移動，每一次只能向左，右，上，下四個方向移動一格，但是不能進入行坐標和列坐標的數位之和大於k的格子。 例如，當k為18時，機器人能夠進入方格（35,37），因為3+5+3+7 = 18。但是，它不能進入方格（35,38），因為3+5+3+8 = 19。請問該機器人能夠達到多少個格子？
思路
dfs或bfs，水題跳過
面試題14：剪繩子
給你一根長度為n的繩子，請把繩子剪成整數長的m段（m、n都是整數，n>1並且m>1），每段繩子的長度記為k[0],k[1],...,k[m]。請問k[0]xk[1]x...xk[m]可能的最大乘積是多少？例如，當繩子的長度是8時，我們把它剪成長度分別為2、3、3的三段，此時得到的最大乘積是18。
貪心
書上題解很詳細，略，只貼出代碼
class Solution {
public:
int cutRope(int number) {
return number <= 3?number-1:((int)pow(3,number/3-(number%3==1))*(number%3?(number%3==1?4:2):1));
}
};
動態規划
如式：\(f(n)=max[f(i)*f(n-i),f(n)]\)，然而本題dp效果不如貪心，故略。
面試題15：二進制中1的個數
輸入一個整數，輸出該數二進制表示中1的個數。其中負數用補碼表示。
思路
基礎做法自然是先轉化成二進制，再求解，但鑒於負數的存在（負數用二進制表示時，最高位表示負數，其他位表示正數，其值為和），可以考慮下其他解決方法，將一個數n最后一個1置0的方法為\(n &= n-1\)，很好理解，一個數減1后，最后一個1變為0，后面的數變為1，再&原來的數，這部分就全變成0了。
int NumberOf1(int n) {
int count = 0;
while(n) count++, n&=n-1;
return count;
}
面試題16：數值的整數次方
給定一個double類型的浮點數base和int類型的整數exponent。求base的exponent次方。
保證base和exponent不同時為0
思路
考慮各種特殊情況即可，可使用快速冪，略。
面試題17：打印從1到最大的n位數
這題牛客居然沒有，沒題目復制，看書吧。
思路
顯然需要用到大數，java就舒服了，自帶大數，C/C++就需要自己用字符串模擬，但並不算難，ACM准大一新生賽必出題，話說int達到1e9，long long則1e18，正常范圍內都幾乎不可能打印完的，代碼略。
面試題18：刪除鏈表的節點
題目一
給定單向鏈表的頭指針和一個節點指針，O(1)內刪除該節點。
思路
這題目簡直在逗我，交換數據后刪除下一個節點，雖說達到了功能，但准確來講還是刪除了下一個節點而不是該節點，不過正常操作下單向鏈表O(1)刪除指定節點是不存在的，因為找不到前面的節點。
題目二
在一個排序的鏈表中，存在重復的結點，請刪除該鏈表中重復的結點，重復的結點不保留，返回鏈表頭指針。 例如，鏈表1->2->3->3->4->4->5 處理后為 1->2->5
思路
思路不難，就是鏈表和指針有點惡心，還需要考慮各種特殊情況，比較麻煩。
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};
*/
class Solution {
public:
ListNode* deleteDuplication(ListNode* pHead){
ListNode *NewHead = new ListNode(0);//頭部可能重復，因此頭指針可能會刪除，需自定義一個偽頭指針
ListNode *Now = pHead;
ListNode *Pre = NewHead;
while(Now != nullptr){
bool need_delete = false;
while(Now->next != nullptr && Now->val == Now->next->val){
need_delete = true;
Now = Now->next;
}
ListNode *pNext = Now->next;
if(!need_delete){
Pre->next = Now;
Pre = Now;
Pre->next = nullptr;
}
Now = pNext;
}
return NewHead->next;
}
};
面試題19：正則表達式匹配
請實現一個函數用來匹配包括'.'和'*'的正則表達式。模式中的字符'.'表示任意一個字符，而'*'表示它前面的字符可以出現任意次（包含0次）。 在本題中，匹配是指字符串的所有字符匹配整個模式。例如，字符串"aaa"與模式"a.a"和"ab*ac*a"匹配，但是與"aa.a"和"ab*a"均不匹配
思路
簡單模擬，模擬題思路都比較簡單，就是考慮各種亂七八糟的情況，所以比較麻煩，需要考慮全，漏一個都不行，所以寫起來比較惡心。
class Solution {
public:
bool match(char* str, char* pattern){
if (str == nullptr || pattern == nullptr)
return false;
if (*str == '\0' && *pattern == '\0')
return true;
if (*pattern == '\0' )
return false;
if (*(pattern+1) == '*' )
return match(str,pattern+2) || ((((*pattern == '.' && *str != '\0') || *str == *pattern) &&(match(str+1,pattern))));
if ((*pattern == '.' && *str != '\0') || *str == *pattern )
return match(str+1,pattern+1);
return false;
}
};
面試題20：表示數值的字符串
請實現一個函數用來判斷字符串是否表示數值（包括整數和小數）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示數值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。
思路
模擬水題，需考慮各種情況，寫起來惡心但思路很水，跳過
面試題21：調整數組順序使奇數位於偶數前面
輸入一個整數數組，實現一個函數來調整該數組中數字的順序，使得所有的奇數位於數組的前半部分，所有的偶數位於數組的后半部分，並保證奇數和奇數，偶數和偶數之間的相對位置不變。
思路
兩個指針，當前面指針指向偶數，后面指針指向奇數時，交換兩個值即可，水題略，可通過函數指針實現其他功能。
面試題22：鏈表中倒數第k個節點
輸入一個鏈表，輸出該鏈表中倒數第k個結點。
常規解法
題解思路挺水的，需要遍歷兩遍，當然也可以用兩個指針遍歷，指針相距k-1后同時遍歷，然而事實上這種解法遍歷次數和前者一樣，都是需要一個指針遍歷到終點，一個指針遍歷到答案點，本質上並無區別，水題略。
遞歸法
跳過兩題了，還是得敲敲代碼，然而遍歷兩遍的解法太常規了，這時候我覺得，如果要求鏈表的每個節點只能經過一次呢？也就是真正意義上遍歷一遍，此時便可以使用遞歸法，遍歷到終點時返回終點指針和計數1，此后遞歸返回時計數+1，這時候相當於從終點開始遍歷了。
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
pair<ListNode*,int> FindKthToTail_pair(ListNode* pListHead,unsigned int k){
if (pListHead->next == nullptr) return make_pair(pListHead,1);
pair<ListNode*,int> pre = FindKthToTail_pair(pListHead->next,k);
if(pre.second == k) return pre;
return make_pair(pListHead,pre.second+1);
}
ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
if(pListHead == nullptr || k == 0)
return nullptr;
pair<ListNode*,int> ans = FindKthToTail_pair(pListHead,k);
return ans.second == k?ans.first: nullptr; //不等於說明整個鏈表長度不足
}
};
面試題23：鏈表中環的入口節點
給一個鏈表，若其中包含環，請找出該鏈表的環的入口結點，否則，輸出null。
書上題解有關快指針追上慢指針的證明
隨便寫寫，並不規范
證明追上時必定在環上
顯然，當快指針追上慢指針時，快指針顯然已經循環過了，那么快指針必然在環上。
證明快指針必然會與慢指針在同一位置
快指針行走2t，慢指針行走t，慢指針進入環內后，開始時兩者相距m，環的大小為n，相遇時快指針循環了x圈，慢指針循環了y圈，則必有\(2a + m = x*n\)和\(a = y*n\)，相減並整理得\(x - y = (a+m)/n\)，其中m，n均固定，a每次加1，所以\((a+m)/n\)必然會出現整數的情況，即上式必然有解。
不過其實不用這么麻煩，考慮各種情況即可。
- 慢指針在快指針前一格
- 慢先走一格，快再走兩格，相遇
- 快先走兩各，慢再走一個，相遇
- 慢指針在快指針前兩格
- 慢先走一格，快再走兩格，就變成上面的情況【慢指針在快指針前一格】
- 快先走兩個，直接相遇
所以，快指針一定能和慢指針相遇。
set標記
一個寫起來輕松但並非高效的做法，使用set記錄下經過的節點，只需要遍歷一遍即可，不過使用set的時間復雜度為\(O(logn)\)，故總時間復雜度為\(O(logn*n)\)，再加上set所需的空間復雜度，效果肯定沒題解好，但敲起來輕松點，書上的題解就懶得敲了。
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};
*/
class Solution {
public:
ListNode* EntryNodeOfLoop(ListNode* pHead){
set<ListNode*> set_node;
while(pHead != nullptr){
if(set_node.count(pHead)) return pHead;
set_node.insert(pHead);
pHead = pHead->next;
}
return nullptr;
}
};
面試題24：反轉鏈表
輸入一個鏈表，反轉鏈表后，輸出新鏈表的表頭。
思路
略，僅提供代碼
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
ListNode* ReverseList(ListNode* pHead) {
ListNode* pPre = nullptr;
while(pHead != nullptr){
ListNode* temp = pHead->next;
pHead->next = pPre;
pPre = pHead;
pHead = temp;
}
return pPre;
}
};
面試題25：合並兩個排序的鏈表
輸入兩個單調遞增的鏈表，輸出兩個鏈表合成后的鏈表，當然我們需要合成后的鏈表滿足單調不減規則。
思路
略
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
ListNode* Merge(ListNode* pHead1, ListNode* pHead2){
if(pHead1 == nullptr || pHead2 == nullptr) return pHead1 == nullptr?pHead2:pHead1;
ListNode* pNewHead = (pHead1->val < pHead2->val)?pHead1:pHead2;
pNewHead->next = (pHead1->val < pHead2->val)? Merge(pHead1->next,pHead2):Merge(pHead1,pHead2->next);
return pNewHead;
}
};
面試題26：樹的子結構
輸入兩棵二叉樹A，B，判斷B是不是A的子結構。（ps：我們約定空樹不是任意一個樹的子結構）。
思路
遞歸水題，僅給出代碼
class Solution {
public:
bool IsSubtree(TreeNode* pRoot1, TreeNode* pRoot2){
if (pRoot2 == nullptr) return true;
if (pRoot1 == nullptr) return false;
return abs(pRoot1->val - pRoot2->val)< 1e-6
&&IsSubtree(pRoot1->left,pRoot2->left)
&&IsSubtree(pRoot1->right,pRoot2->right);
}
bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2){
return (pRoot1 == nullptr || pRoot2 == nullptr)?false
:(IsSubtree(pRoot1,pRoot2) || HasSubtree(pRoot1->left,pRoot2) || HasSubtree(pRoot1->right,pRoot2));
}
};
面試題27：二叉樹的鏡像
操作給定的二叉樹，將其變換為源二叉樹的鏡像。
思路
遞歸，每次交換左右節點，水題略
面試題28：對稱的二叉樹
請實現一個函數，用來判斷一顆二叉樹是不是對稱的。注意，如果一個二叉樹同此二叉樹的鏡像是同樣的，定義其為對稱的。
思路
中左右和中右左同時遍歷。
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};
*/
class Solution {
public:
bool isSymmetrical(TreeNode* pNode1,TreeNode* pNode2){
return (pNode1 == nullptr && pNode2 == nullptr)?true:
(pNode1 != nullptr && pNode2 != nullptr
&&pNode1->val == pNode2->val
&&isSymmetrical(pNode1->left,pNode2->right)
&&isSymmetrical(pNode2->right,pNode1->left));
}
bool isSymmetrical(TreeNode* pRoot){
return isSymmetrical(pRoot,pRoot);
}
};
面試題29：順時針打印矩陣
輸入一個矩陣，按照從外向里以順時針的順序依次打印出每一個數字，例如，如果輸入如下4 X 4矩陣： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 則依次打印出數字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.
思路
找規律，例如題目給出的例子，其位置變化為y+3 x+3 y-3 x-2 y+2 x+1 y-1 ，規律很明顯，代碼能省就省，但面試千萬別這么寫
class Solution {
public:
vector<int> printMatrix(vector<vector<int> > matrix) {
vector<int> ans;
if (matrix.empty() || matrix[0].empty()) return ans;
int matrix_num_x = matrix.size(),matrix_num_y = matrix[0].size();
int sum = matrix_num_x*matrix_num_y,check = 1,x = 0,y = matrix_num_y-1;
for(int i = 0;i < matrix_num_y;ans.push_back(matrix[0][i++]));
while(ans.size() < sum ){
for(int i = --matrix_num_x;i;i--,ans.push_back(matrix[x+= check][y]));
check *= -1;
for(int i = --matrix_num_y;i;i--,ans.push_back(matrix[x][y+= check]));
}
return ans;
}
};
面試題30：包含min函數的棧
定義棧的數據結構，請在該類型中實現一個能夠得到棧中所含最小元素的min函數（時間復雜度應為O（1））。
注意：保證測試中不會當棧為空的時候，對棧調用pop()或者min()或者top()方法。
思路
再定義一個輔助棧，其棧頂為最小值，每次壓入新值時與輔助棧的棧頂比較，若大於等於，則在輔助棧繼續壓入棧頂的值，若小於，則在輔助棧壓入新值，代碼略。
面試題31：棧的壓入、彈出序列
輸入兩個整數序列，第一個序列表示棧的壓入順序，請判斷第二個序列是否可能為該棧的彈出順序。假設壓入棧的所有數字均不相等。例如序列1,2,3,4,5是某棧的壓入順序，序列4,5,3,2,1是該壓棧序列對應的一個彈出序列，但4,3,5,1,2就不可能是該壓棧序列的彈出序列。（注意：這兩個序列的長度是相等的）
思路
按順序壓入棧，當棧頂等於彈出序列首個元素時，彈出棧頂並刪除彈出序列的首個元素，當壓入結束后棧中仍有元素時，則返回false。
class Solution {
public:
bool IsPopOrder(vector<int> pushV,vector<int> popV) {
stack<int> st;
int point_push = 0,point_pop = 0;
while(point_push < pushV.size()){
st.push(pushV[point_push++]);
while(!st.empty()&&popV[point_pop] == st.top()){
point_pop++;
st.pop();
}
}
return st.empty();
}
};
面試題32：從上到下打印二叉樹
從上往下打印出二叉樹的每個節點，同層節點從左至右打印。
思路
隊列先進先出，題目二可以使用pair<TreeNode,int>存儲該節點第幾層，題目三則是按層數奇偶判斷即可，二三代碼略。
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
vector<int> PrintFromTopToBottom(TreeNode* root) {
vector<int> ans;
queue<TreeNode*> que_print;
if (root != nullptr) que_print.push(root);
while(!que_print.empty()){
TreeNode* front_que = que_print.front();
que_print.pop();
ans.push_back(front_que->val);
if(front_que->left != nullptr) que_print.push(front_que->left);
if(front_que->right != nullptr) que_print.push(front_que->right);
}
return ans;
}
};
面試題33：二叉搜索樹的后序遍歷序列
輸入一個整數數組，判斷該數組是不是某二叉搜索樹的后序遍歷的結果。如果是則輸出Yes,否則輸出No。假設輸入的數組的任意兩個數字都互不相同。
思路
二叉搜索樹，值的大小左<中<右，后續遍歷順序左右中，顯然最后一個為根，前面連續小於根的元素均為左子樹部分，其他的為右子樹，當右子樹部分有小於根的情況，則不是二叉搜索樹，返回false，否則對左右子樹繼續遞歸判斷。
class Solution {
public:
bool VerifySquenceOfBST(vector<int> sequence) {
int len = sequence.size(),i = 0,j = 0;
if (len == 0 || len == 1) return len;//數組只剩一個節點時，可生成二叉搜索樹
while(sequence[i] < sequence[len-1]) j=++i;
while(j < len-1) if (sequence[j++] <sequence[len-1]) return false;
return (!i?true:VerifySquenceOfBST(vector<int>(sequence.begin(),sequence.begin()+i)))
&&(!(len-i-1)?true:VerifySquenceOfBST(vector<int>(sequence.begin()+i,sequence.end()-1)));
}
};
面試題34：二叉樹中和為某一值的路徑
輸入一顆二叉樹的根節點和一個整數，打印出二叉樹中結點值的和為輸入整數的所有路徑。路徑定義為從樹的根結點開始往下一直到葉結點所經過的結點形成一條路徑。(注意: 在返回值的list中，數組長度大的數組靠前)。
思路
bfs或遞歸均可，遞歸為fuc(左右子樹，k=值-當前節點值)，當到葉節點時判斷當前值與k是否相等即可，代碼略。
需要注意的是，題目要求數組長度大的數組靠前，而bfs是從短到長，因此每次加入新數組時可以從頭加，而遞歸則無序，需要重新排序。
面試題35：復雜鏈表的復制
輸入一個復雜鏈表（每個節點中有節點值，以及兩個指針，一個指向下一個節點，另一個特殊指針指向任意一個節點），返回結果為復制后復雜鏈表的head。（注意，輸出結果中請不要返回參數中的節點引用，否則判題程序會直接返回空）
思路
難點在於另個一特殊指針，它指向的是原來鏈表的位置，但復制的話就需要指向新鏈表的位置，方法很多，例如兩重循環\(O(n^2)\)，用map將特殊節點對應\(O(logn*n)/O(n)\)，map也可用unorded_map，即哈希來使得時間復雜度\(O(n)\)，但這些的空間復雜度都較高，於是最好的肯定就是時間\(O(n)\)，空間\(O(1)\)的做法了，做法看書即可，還算明了，就是寫代碼的時候有些大坑，例如特殊指針可能為空，可能從空指針取值而導致崩潰，此外還有牛客上提交的代碼千萬不能改變原來的鏈表結構，因此拆分時需要還原舊鏈表，不然會顯示輸出結果為空，我之前拆分的時候就只管拆出新鏈表，而不管舊鏈表，坑了好久百度后才發現必須將舊鏈表還原。
/*
struct RandomListNode {
int label;
struct RandomListNode *next, *random;
RandomListNode(int x) :
label(x), next(NULL), random(NULL) {
}
};
*/
class Solution {
public:
RandomListNode* Clone(RandomListNode* pHead){
RandomListNode* pNewHead = nullptr;//無需判斷頭指針為空情況，因為運行過程中已經判斷了
for(RandomListNode *pNewTemp,*pOldTemp = pHead;pOldTemp!= nullptr;pOldTemp = pNewTemp->next){
pNewTemp = new RandomListNode(pOldTemp->label);
if (pNewHead == nullptr) pNewHead = pNewTemp;
pNewTemp->next = pOldTemp->next;
pOldTemp->next = pNewTemp;
}
for(RandomListNode* pTemp = pHead;pTemp != nullptr;pTemp = pTemp->next->next)
pTemp->next->random = (pTemp->random== nullptr? nullptr:pTemp->random->next);//注意：特殊節點可能為空
for(RandomListNode* pTemp = pHead;pTemp != nullptr;pTemp = pTemp->next) {
RandomListNode* pNext = pTemp->next->next;
if (pNext != nullptr) pTemp->next->next = pNext->next;//空指針取值會崩潰
pTemp->next = pNext;
}
return pNewHead;
}
};
面試題36：二叉搜索樹與雙向鏈表
輸入一棵二叉搜索樹，將該二叉搜索樹轉換成一個排序的雙向鏈表。要求不能創建任何新的結點，只能調整樹中結點指針的指向。
遞歸
對於一個節點來說，其左邊連接左子樹的最右（大）節點，其右邊連接右子樹的最左（小）節點，如此便是排序的雙向鏈表。
TreeNode* Convert_(TreeNode* pRootOfTree,bool is_left){
if (pRootOfTree == nullptr) return nullptr;
if (pRootOfTree->left != nullptr) {
pRootOfTree->left = Convert_(pRootOfTree->left,true);
pRootOfTree->left->right = pRootOfTree;
}
if (pRootOfTree->right != nullptr) {
pRootOfTree->right = Convert_(pRootOfTree->right,false);
pRootOfTree->right->left = pRootOfTree;
}
if (is_left) return pRootOfTree->right == nullptr?pRootOfTree:pRootOfTree->right;
else return pRootOfTree->left == nullptr?pRootOfTree:pRootOfTree->left;
}
TreeNode* Convert(TreeNode* pRootOfTree){
TreeNode* ans = Convert_(pRootOfTree,true);
while(ans != nullptr && ans->left != nullptr)
ans = ans->left;
return ans;
}
面試題37：序列化二叉樹
請實現兩個函數，分別用來序列化和反序列化二叉樹。
思路
前中后序均可，將空指針用特殊字符替代，代碼略。
面試題38：字符串的排列
輸入一個字符串,按字典序打印出該字符串中字符的所有排列。例如輸入字符串abc,則打印出由字符a,b,c所能排列出來的所有字符串abc,acb,bac,bca,cab和cba。(可能有字符重復)
思路
我記得當時准大一，在暑假的ACM新生賽時遇到過這題，花了挺長時間找規律解決的，沒用遞歸（初學C語言），當時的方法也忘了，不過印象挺深的。
遞歸，需要注意的是，可能有字符重復，所以需要去重，例如"aaa"，就只能輸出一個結果，不過，其實C/C++自帶實現排列的函數，但是面試的時候肯定不能用的，不過機試的時候只要AC就行，如果不查代碼的話倒是可以用用。
//正常面試寫法
class Solution {
public:
void Permutation(vector<string> &ans,string &str,int begin){
if (!str[begin]) ans.push_back(str);
for(int i = begin;str[i];i++){
swap(str[begin],str[i]);
Permutation(ans,str,begin+1);
swap(str[begin],str[i]);
}
}
vector<string> Permutation(string &str) {
vector<string> ans;
if (str.empty()) return ans;
Permutation(ans,str,0);
sort(ans.begin(),ans.end());
ans.erase(unique(ans.begin(),ans.end()),ans.end());
return ans;
}
};
//機試寫法
class Solution {
public:
vector<string> Permutation(string &str) {
vector<string> ans;
if (str.empty()) return ans;
sort(str.begin(),str.end());
do{
ans.push_back(str);
}while(next_permutation(str.begin(),str.end()));
return ans;
}
};
面試題39：數組中出現次數超過一半的數字
數組中有一個數字出現的次數超過數組長度的一半，請找出這個數字。例如輸入一個長度為9的數組{1,2,3,2,2,2,5,4,2}。由於數字2在數組中出現了5次，超過數組長度的一半，因此輸出2。如果不存在則輸出0。
思路
劍指題解二，僅提供代碼
class Solution {
public:
int MoreThanHalfNum_Solution(vector<int> numbers) {
if (numbers.empty()) return 0;
int cent = 1,pre = numbers[0],times = 0;
for(int i = 1;i < numbers.size();i++)
if (numbers[i] != numbers[i-1]){
if (cent == 1) pre = numbers[i];
else cent--;
}
else cent++;
for(int i = 0;i < numbers.size();i++)
if (pre == numbers[i]) times++;
return times*2 > numbers.size()?pre:0;
}
};
面試題40：最小的k個數
輸入n個整數，找出其中最小的K個數。例如輸入4,5,1,6,2,7,3,8這8個數字，則最小的4個數字是1,2,3,4。
基於快排的Partition函數
准確來說，該時間復雜度不應該是題解所說的\(O(n)\)。
- 最佳情況下是選擇中位數作為基准數，這時候就能將數組一分為二，直接舍棄一半，遍歷次數為\(S = n+n/2+n/4...\)，時間復雜度倒是可以算作\(O(n)\)。
- 最差情況下是每次都選擇了值最小或最大的元素作為基准值，那每次就只能舍棄一個值，遍歷次數為\(S = n+(n-1)+(n-2)...\)，所以時間復雜度為\(O(n^2)\)。
- 綜合來說，時間復雜度介於\(O(n)\)到\(O(n^2)\)之間
class Solution {
public:
int partition(vector<int> &input,int left,int right){
int key = rand()%(right-left+1)+left;
swap(input[key],input[left]);
key = left;
while(left < right){
//如果兩個where交換位置呢？
//最后可能出現input[left] > input[key]&&left > key的情況
//即最后交換后左側會有一個值大於基准值
while(left < right && input[right] >= input[key]) right--;
while(left < right && input[left] <= input[key]) left++;
if (left < right) swap(input[left],input[right]);
}
swap(input[left],input[key]);
return left;
}
vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
if (input.empty() || k > input.size() || --k < 0) return vector<int>(input.begin(),input.begin());
int left = 0,right = input.size();//范圍[left,right)
while(left < right){
int mid = partition(input,left,right-1);
if (mid == k) return vector<int>(input.begin(),input.begin()+k+1);
else if (mid < k ) left = mid +1;
else right = mid;
}
}
};
基於優先隊列（堆）
當數據量大，且不允許改變數據范圍時，使用堆，時間復雜度\(O(nlogk)\)
class Solution {
public:
vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
vector<int> ans;
priority_queue<int> que;
if (input.empty() || k > input.size() || k <= 0) return ans;
for(auto it = input.begin();it != input.end();it++)
if (que.size() < k) que.push(*it);
else if (que.top() > *it){
que.pop();
que.push(*it);
}
while(!que.empty()){
ans.push_back(que.top());
que.pop();
}
return ans;
}
};
面試題41：數據流中的中位數
如何得到一個數據流中的中位數？如果從數據流中讀出奇數個數值，那么中位數就是所有數值排序之后位於中間的數值。如果從數據流中讀出偶數個數值，那么中位數就是所有數值排序之后中間兩個數的平均值。我們使用Insert()方法讀取數據流，使用GetMedian()方法獲取當前讀取數據的中位數。
兩個優先隊列（堆）
左側用最大堆，右側用最小堆，顯然中位數就是兩個堆頂之一或兩個堆頂的平均值
class Solution {
public:
priority_queue<int> max_que;
priority_queue<int,vector<int>,greater<int> > min_que;
void Insert(int num){
int sum = max_que.size()+min_que.size();
if (sum&1) min_que.push(num);
else max_que.push(num);
if (!min_que.empty()&&min_que.top() < max_que.top()){//當右側最小值小於左側最大值時交換
min_que.push(max_que.top());
max_que.push(min_que.top());
min_que.pop();
max_que.pop();
}
}
double GetMedian(){
return ((max_que.size()+min_que.size())&1)?max_que.top():(max_que.top()+min_que.top())/2.0;
}
};
面試題42：連續子數組的最大和
HZ偶爾會拿些專業問題來忽悠那些非計算機專業的同學。今天測試組開完會后,他又發話了:在古老的一維模式識別中,常常需要計算連續子向量的最大和,當向量全為正數的時候,問題很好解決。但是,如果向量中包含負數,是否應該包含某個負數,並期望旁邊的正數會彌補它呢？例如:{6,-3,-2,7,-15,1,2,2},連續子向量的最大和為8(從第0個開始,到第3個為止)。給一個數組，返回它的最大連續子序列的和，你會不會被他忽悠住？(子向量的長度至少是1)
貪心
思路略，僅提供代碼
int FindGreatestSumOfSubArray(vector<int> array) {
if (array.empty()) return 0;
int ans = array[0];
int Max = array[0];
int pre = 0;
for(auto each:array){
pre += each;
Max = max(each,Max);
ans = max(pre,ans);
pre = max(pre,0);
}
return Max < 0?Max:ans;
}