第十九題：
題目：
輸入一個矩陣，按照從外向裏以順時針的順序依次打印出每一個數字，例如，如果輸入如下矩陣： 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.
題解：
這裏要注意的是，這個矩陣不是n*n ，他的行列數可以不相等
解題思路：把打印數字當做在這個矩陣中轉圈打印，我們很容易計算得到需要打印多少圈，然後依次打印即可
因爲行列數不相等，所以需要防止重複打印，例如這個矩陣只有一行，我們就不能打印一圈，那麼會重複，只有打印半圈，即一行
class Solution {
public:
vector<int> printMatrix(vector<vector<int> > matrix) {
int row=matrix.size();
int col=matrix[0].size();
vector<int>ans;
ans.clear();
int t=((row<col?row:col)+1)/2;
for(int i=0;i<t;i++){
for(int j=i;j<col-i;j++)
ans.push_back(matrix[i][j]);//1號
for(int j=i+1;j<row-i;j++)
ans.push_back(matrix[j][col-i-1]);//2號
for(int j=col-i-2;j>=i&&(row-i-1!=i);j--)
ans.push_back(matrix[row-i-1][j]);//3號
for(int j=row-i-2;j>i&&(col-i-1!=i);j--)
ans.push_back(matrix[j][i]);//4號
//在行和列是奇數的情況下
//1號打印了最後一行的時候，3號就不能再打印了，所以有對應的行控制row-i-1!=i
//2號打印了最後一列的時候，4號就不能再打印了，所以有對應的列控制col-i-1!=i
}
return ans;
}
};第二十題：
定義棧的數據結構，請在該類型中實現一個能夠得到棧最小元素的min函數
題解：
定義一個dataStack棧和minStack棧，第一個用來存push的數據的，第二個用來存我們所需的答案的
下面程序如果push下面的數據，那麼minStack裏面的數據如下所示
data：9 8 4 5 6 3
min：9 8 4 4 4 3
class Solution {
public:
stack<int> dataStack, minStack;
void push(int value) {
dataStack.push(value);
if (minStack.empty()) minStack.push(value);
else{
int m = minStack.top();
value<=m?minStack.push(value):minStack.push(m);
}
}
void pop() {
dataStack.pop();
minStack.pop();
}
int top() {
return dataStack.top();
}
int min() {
return minStack.top();
}
};第二十一題：
輸入兩個整數序列，第一個序列表示棧的壓入順序，請判斷第二個序列是否爲該棧的彈出順序。假設壓入棧的所有數字均不相等。例如序列1,2,3,4,5是某棧的壓入順序，序列4，5,3,2,1是該壓棧序列對應的一個彈出序列，但4,3,5,1,2就不可能是該壓棧序列的彈出序列。（注意：這兩個序列的長度是相等的）
題解：
本題新建立一個棧，進行模擬即可判斷是否有次序列存在
class Solution {
public:
bool IsPopOrder(vector<int> pushV,vector<int> popV) {
stack<int>tmp;
int a=0,b=0,sizeA=pushV.size(),sizeB=popV.size();
while(a<sizeA){
tmp.push(pushV[a++]);
while(tmp.top()==popV[b]&&b<sizeB)
tmp.pop(),b++;
}
return b==sizeB;
}
};第二十二題：
從上往下打印出二叉樹的每個節點，同層節點從左至右打印
題解：
利用一個隊列，保存每一層的節點，利用這一層的節點我們就可以訪問到下一層，就模擬得到最終的答案了
/*
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) {
queue<TreeNode*>q;
vector<int>v;
if(root==NULL) return v;
q.push(root);
while(!q.empty()){
TreeNode* t=q.front();q.pop();
if(t->left!=NULL) q.push(t->left);
if(t->right!=NULL)q.push(t->right);
v.push_back(t->val);
}
return v;
}
};第二十三題：
輸入一個整數數組，判斷該數組是不是某二叉搜索樹的後序遍歷的結果。如果是則輸出Yes,否則輸出No。假設輸入的數組的任意兩個數字都互不相同
題解：
後序序列的頭結點位於最後
二叉搜索樹（BST）的特點是：右子樹所有節點的值都小於根節點，左兒子所有的節點都大於根節點
根據上面的特性，遞歸判斷是否都滿足上面的特性即可
class Solution {
private:
bool deal(vector<int> &a,int left,int right){
if(left>=right) return true;
int p=left;
while(a[p]<a[right]) p++;
int q=p;
while(a[q]>a[right]) q++;
if(q!=right) return false;
return deal(a,left,p-1)&&deal(a,p,right-1);
}
public:
bool VerifySquenceOfBST(vector<int> sequence) {
if(sequence.size()==0) return false;
return deal(sequence,0,sequence.size()-1);
}
};第二十四題：
輸入一顆二叉樹和一個整數，打印出二叉樹中結點值的和爲輸入整數的所有路徑
路徑定義：從樹的根結點開始往下一直到葉結點所經過的結點形成一條路徑
題解：
DFS思想：
從根節點dfs到葉子節點，然後回溯，再DFS，在過程中判斷是否有滿足條件的路徑
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
private:
vector<int> tmp;
vector<vector<int> > ans;///必須是在函數外面定義
public:
vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
if(!root) return ans;
tmp.push_back(root->val);
expectNumber-=(root->val);
if(expectNumber==0&& !root->left && !root->right)
ans.push_back(tmp);///注意這裏，不能在這裏return，因爲之前push進去的值沒有pop出來
FindPath(root->left,expectNumber);
FindPath(root->right,expectNumber);
tmp.pop_back();
return ans;
}
};