剑指offer 算法 （举例让抽象具体化）

题目描述

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

解析：从上往下遍历 root结点 左结点 右结点 每遍历一个依次存入队列 由队列的先进先出 依次便可逐层存结点入数组中

/*
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> Array;
        if(!root)
            return Array;
        vector<TreeNode *> Q;
        int cnt=0;
        Q.push_back(root);
        while( cnt< Q.size() )
        {
            TreeNode *Node=Q[cnt++];
            Array.push_back(Node->val);
            if(Node->left)
                Q.push_back(Node->left);
            if(Node->right)
                Q.push_back(Node->right);
        }
        return Array;
    }
};

题目描述

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

解析：二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
	int length = sequence.size();
        if( length == 0 )
            return false;
        int start = 0;
        int end = length-1;
        
        return Tree( sequence , start , end );
    }
    bool Tree( vector<int> sequence , int start , int end )
    {
        if( start == end || start == ( end + 1 ) )
            return true;
        int root = sequence[end];
        int i , j;
        for( i = start ; i < end ; i ++ )//左子树
        {
            if( sequence[ i ] > root )
                break;
        }
        for( j = i ; j < end ; j ++ )//判断是否符合右子树
        {
            if( sequence[ j ] <= root )
                return false;
        }
        bool leftT = Tree( sequence , start , i - 1 );
        bool rightT = Tree( sequence , i , end - 1 );
        return leftT && rightT ;
        
    }
};

题目描述

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

/*
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> > FindPath(TreeNode* root,int expectNumber) {
		vector<vector<int> > array;
        vector<int> v;
        if( root == NULL || expectNumber == 0 )
            return array;
        int sum=0;
        preTree(root,expectNumber,array,v,sum);
        return array;
    }
	void preTree(TreeNode* root,int expectNumber,vector<vector<int> > &array,vector<int> v,int sum)
    {
        
        if( root == NULL )
            return;
        sum += root->val;
        v.push_back(root->val);
        if( root->left == NULL && root->right == NULL )
        {
            if( sum == expectNumber )
                array.push_back(v);
            return;
        }
        preTree( root->left, expectNumber, array , v , sum );
        preTree( root->right, expectNumber, array , v , sum );
    }
};