剑指offer刷题记录——举例让抽象具体化

包含main函数的栈

题目描述

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
注意：保证测试中不会当栈为空的时候，对栈调用pop()或者min()或者top()方法。

实现思路

这个题目主要考察的还是如何用O(1)的方法得到栈中所含最小元素的min函数。首先需要一个栈存储栈元素实现相应的栈操作，而为了实现min函数显然要引入一个辅助栈。
过程就是，在添加元素时将元素大小与辅助栈的栈顶元素比较，如果比较小的话则压入辅助栈顶。弹出元素时，也要考虑弹出的元素是否为辅助栈的栈顶元素，要随之弹出。

具体实现

class Solution {
public:
    stack<int> stack1;
    stack<int> stack2;
    void push(int value) {
        stack1.push(value);
        if(stack2.empty()){
            stack2.push(value);
        }
        else{
            if(stack2.top()>=value)
                stack2.push(value);
        }
    }
    void pop() {
        if(stack1.top()==stack2.top()){
            stack1.pop();
            stack2.pop();
        }
        else
            stack1.pop();
        
    }
    int top() {
        return stack1.top();
        
    }
    int min() {
        return stack2.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) {
        if(pushV.empty() || popV.empty() || pushV.size()!=popV.size())
            return false;
        stack<int> s;
        for(int i=0, j=0;i<pushV.size();i++){
            s.push(pushV[i]);
            while((!s.empty()&&s.top()==popV[j])&&j<popV.size()){
                s.pop();
                j++;
            }
        }
        return s.empty();
    }
};

 

从上往下打印二叉树

题目描述

二叉树的层次遍历，好像做过了。

具体实现

/*
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> res;
        queue<TreeNode*> q;
        if(root==NULL)
            return res;
        q.push(root);
        while(!q.empty()){
            TreeNode*  cur = q.front();
            q.pop();
            if(cur->left)
                q.push(cur->left);
            if(cur->right)
                q.push(cur->right);
            res.push_back(cur->val);
        }
        return res;
    }
};

 

二叉搜索树的后序遍历序列

题目描述

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

实现思路

由于后续遍历的方式是先遍历左子树再遍历右子树最后遍历根。又是二叉搜索树，这就决定了序列的最后一个数为根，而除去这个数序列将分为两个部分。
前一部分是小于根的左子树，后一部分是大于根的右子树。检查序列是否出错，然后再进行递归调用，看两个子树是否符合后序遍历。

具体实现

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        if(sequence.empty()) return false;
        vector<int> left,right;
        int low = 0;
        int sz = sequence.size();
        int high = sz-1;
        int i=0;
        for(;i<high;i++ ){
            if(sequence[i]>sequence[high])
                break;
        }
        for(int j=i;j<high;j++)
            if(sequence[j]<sequence[high])
                return false;
        if(i!=0){
            for(int m=0;m<i;m++){
                left.push_back(sequence[m]);
            }
        }
        if(i!=high-1){
            for(int m=i;m<high;m++)
                right.push_back(sequence[m]);
        }
        bool leftb=true,rightb=true;
        if(left.size()>1) leftb=VerifySquenceOfBST(left);
        if(right.size()>1) rightb=VerifySquenceOfBST(right);
        return leftb&&rightb;
        
    }
};

 

二叉树中和为某一值的路径

题目描述

输入一颗二叉树的根节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

具体实现

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    vector<vector<int> > res;
    vector<int>  path;
    void find(TreeNode* root,int sum){
        if(root==NULL) return;
        path.push_back(root->val);
        if(!root->right&&!root->left&&root->val==sum)
                res.push_back(path);
        else{
            if(root->left) find(root->left,sum-root->val);
            if(root->right) find(root->right,sum-root->val);
        }
        path.pop_back();
    }
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
        find(root,expectNumber);
        return res;
    }
};