剑指offer（2）

举例让抽象具体化

栈的压入、弹出序列

题目描述：输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

class Solution {
public:
    //判断popV当前位之前是否有在pushV中排在它之前的数字，有则false，无则true
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        if(pushV.size()==0 || popV.size()==0)
            return false;
        vector<int> st;//用来存储假如顺序
        for(int i=0,j=0;i<pushV.size();)
        {
            st.push_back(pushV[i++]);
            //一旦发现有与j所在位置相同的数字就向前查找，将相同的数字都排除掉，判断最后st是否为空
            while(j<popV.size() && popV[j]==st.back())
            {
                st.pop_back();
                j++;
            }
        }
        return st.empty();
    }
};

从上往下打印二叉树

题目描述:从上往下打印出二叉树的每个节点，同层节点从左至右打印。(使用队列操作)

queue模板类的定义在<queue>头文件中。与stack模板类很相似，queue模板类也需要两个模板参数，一个是元素类型，一个容器类型，元素类型是必要的，容器类型是可选的，默认为deque类型。

定义queue对象的示例代码如下：queue<int> q1;queue<double> q2;

queue的基本操作有：

　　入队，如例：q.push(x); 将x接到队列的末端。

　　出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。

　　访问队首元素，如例：q.front()，即最早被压入队列的元素。

　　访问队尾元素，如例：q.back()，即最后被压入队列的元素。

　　判断队列空，如例：q.empty()，当队列空时，返回true。

　　访问队列中的元素个数，如例：q.size()

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

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

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

class Solution {
public:
    //采用递归方式来求
    bool isBST(vector<int> que,int m,int n){
        if(m>=n) return true;
        int i=n;
        while(i--){if(que[i]<que[n]) break;}
        int l=i;
        for(;i>=m;i--){if(que[i]>que[n]) break;}
        if(i>=m) return false;
        return isBST(que,l,m-1) && isBST(que,l+1,n-1);
        /*for(;i>-1 && que[i]>que[n];i--);
        if(i != -1)
        {
            int l = i;
            while(i--){
                if(que[i]>que[n])
                    return false;
            }
            return isBST(que,m,l) && isBST(que,l+1,n-1);
        }
        return isBST(que,m,n-1);*/
    }
    bool VerifySquenceOfBST(vector<int> sequence) {
        if(sequence.size()==0) return false;
        return isBST(sequence,0,sequence.size()-1);
        //采用简单的非递归方式，每次比较都比较到了sequence[0]
        /*int n = sequence.size();
        while(n--){
            int i=n;
            while(i--){if(sequence[i]<sequence[n]) break;}
            for(;i>=0;i--){if(sequence[i]>sequence[n]) break;}
            if(i>=0) return false;
        }
        return true;*/
        //通过记录当前比较的子树的左边位置，使得每次比较的时候不至于比较到sequence[0]
        /*int n = sequence.size();
        int l=0;
        while(n--){
            int i=n;
            int j=l;
            while(i--){if(sequence[i]<sequence[n]) break;}
            if(i+1<n) l=i+1;
            else l=0;
            for(;i>=j;i--){if(sequence[i]>sequence[n]) break;}
            if(i>=j) return false;
        }
        return true;*/
    }
};

 把字符串转换成整数

题目描述：将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。

class Solution {
public:
    int StrToInt(string str) {
        int temp=0;
        int i=0;
        if(str[0] == '-' || str[0] == '+')
            i++;
        while(str[i]!='\0')
        {
            if(str[i]<'0' || str[i]>'9')//判断是否含有非数字
                break;
            temp = temp*10 + (str[i]-'0');
            i++;
        }
        if(str[i]!='\0')//判断如果含有非数字则返回0
            return 0;
        if(str[0] == '-')
            temp = -temp;
        return temp;
    }
};

 数组中出现次数超过一半的数字(时间效率)

题目描述:数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为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.size()==0) return 0;
        
        int temp = numbers[0];
        int count = 1;
        for(int i=1;i<numbers.size();i++)
        {
            if(temp == numbers[i]) count++;
            else count--;
            if(count==0)
            {
                temp = numbers[i];
                count++;
            }
        }
        count = 0;
        for(int i=0;i<numbers.size();i++)
            if(temp == numbers[i])
                count++;
        return count*2>numbers.size()?temp:0;
        
    }
};

还可以使用排序或者Partition，连接：http://blog.csdn.net/yangquanhui1991/article/details/52053995

 二叉树中和为某一值的路径(举例让抽象具体化)

题目描述:输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

/*
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> cur;
    void path(TreeNode* root,int left)
    {
        cur.push_back(root->val);
        if(left-root->val==0 && !root->left &&!root->right)
            res.push_back(cur);
        else
        {
            if(root->left) path(root->left,left-root->val);
            if(root->right) path(root->right,left-root->val);
        }
        cur.pop_back();
    }
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
        if(root) path(root,expectNumber);
        return res;
    }*/
    //非递归
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
        vector<vector<int> > res;   
        if (root == NULL)
            return res;
        stack<TreeNode *> s;
        s.push(root);
        int sum = 0; //当前和
        vector<int> curPath; //当前路径
        TreeNode *cur = root; //当前节点
        TreeNode *last = NULL; //保存上一个节点
        while (!s.empty()){
            if (cur == NULL){
                TreeNode *temp = s.top();
                if (temp->right != NULL && temp->right != last){
                    cur = temp->right; //转向未遍历过的右子树
                }else{
                    last = temp; //保存上一个已遍历的节点
                    s.pop();
                    curPath.pop_back(); //从当前路径删除
                    sum -= temp->val;
                }  }
            else{
                s.push(cur);
                sum += cur->val;
                curPath.push_back(cur->val);
                if (cur->left == NULL && cur->right == NULL && sum == expectNumber){
                    res.push_back(curPath);
                }
                cur = cur->left; //先序遍历，左子树先于右子树
            }
        }
        return res;
    }
};