剑指offer第二、三天

剑指offer第二、三天

1.二叉树的深度

class Solution {
    int get_height(TreeNode* node)
    {
        if(node == nullptr)return 0;
        else return 1 + max(get_height(node->left),get_height(node->right));
    }
public:
    int treeDepth(TreeNode* root) {
        return get_height(root);
    }
};

2.二叉搜索树的第k个结点

class Solution {
    void dfs(TreeNode* node,vector<TreeNode*>&ans)
    {
        if(node->left)dfs(node->left,ans);
        ans.push_back(node);
        if(node->right)dfs(node->right,ans);
    }
public:
    TreeNode* kthNode(TreeNode* root, int k) {
        vector<TreeNode*>ans;
        //这是一个二叉搜索树，直接进行中序遍历的话，就可以得到一个有序的数组，然后直接返回第k个结点就行了
        // if(root == nullptr)
        dfs(root,ans);
        return ans[k-1];
    }
};

3.重建二叉树

class Solution {
    TreeNode* traversal(vector<int>&preorder,vector<int>&inorder)
    {
        if(preorder.size() == 0)return nullptr;
        int rootvalue = preorder[0];
        TreeNode* root = new TreeNode(rootvalue);
        if(preorder.size() == 1)return root;
        int idx;
        for(idx = 0;idx<inorder.size();++idx)
            if(inorder[idx] == rootvalue)
                break;
        vector<int>leftInorder(inorder.begin(),inorder.begin()+idx);
        vector<int>rightInorder(inorder.begin()+idx+1,inorder.end());
        vector<int>leftPreorder(preorder.begin()+1,preorder.begin()+1+leftInorder.size());
        vector<int>rightPreorder(preorder.begin()+1+leftInorder.size(),preorder.end());
        root->left = traversal(leftPreorder,leftInorder);
        root->right = traversal(rightPreorder,rightInorder);
        return root;
    }
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size() == 0)return nullptr;
        return traversal(preorder,inorder);
    }
};

4.树的子结构

class solution {
    bool isSame(TreeNode*s,TreeNode*t)
    {
        if(s==nullptr && t!=nullptr)return false;
        if(s==nullptr && t==nullptr)return true;
        if(s!=nullptr && t==nullptr)return true;
        return s->val==t->val
        &&isSame(s->left,t->left)
        &&isSame(s->right,t->right);
    }
public:
    bool hasSubtree(TreeNode* pRoot1, TreeNode* pRoot2) {
        if(pRoot2==nullptr)return false;
        if(pRoot1==nullptr)return false;
        return isSame(pRoot1,pRoot2)
        ||hasSubtree(pRoot1->left,pRoot2)
        ||hasSubtree(pRoot1->right,pRoot2);
    }
};

5.二叉树的镜像

class Solution {
    void postorder(TreeNode* node)
    {
        if(node == nullptr)return;
        postorder(node->left);
        postorder(node->right);
        swap(node->left,node->right);
    }
public:
    void mirror(TreeNode* root) {
        postorder(root);
    }
};

6.从上往下打印二叉树

class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
		vector<int>ans;
		if(root == nullptr)return ans;
		queue<TreeNode*>que;
		que.push(root);
		while(!que.empty())
		{
			auto t = que.front();
			que.pop();
			ans.push_back(t->val);
			if(t->left)
				que.push(t->left);
			if(t->right)
				que.push(t->right);
		}
		return ans;
    }
};

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

class Solution {
private:
    bool check(vector<int>&sequence,int l,int r)
    {
        if(l>=r)return true;
        int j = r-1,root = sequence[r];
        while(j>=0 && sequence[j] > root)j--;
        for(int i = l;i<=j;++i)
        {
            if(sequence[i] > root)return false;
        }
        return check(sequence,l,j)&&check(sequence,j+1,r-1);
    }
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        int n = sequence.size();
        if(n == 0)return false;
        return check(sequence,0,n-1);
    }
};

8.二叉搜索树与双向链表

class Solution {
	void inorder(TreeNode* node,TreeNode* & first,TreeNode* & last)
	{
		if(node==nullptr)return;
		inorder(node->left,first,last);
		if(last)
		{
			last->right = node;
			node->left = last;
		}
		else{
			first = node;
		}
		last = node;
		inorder(node->right,first,last);
	}
public:
    TreeNode* Convert(TreeNode* root) {
        TreeNode*first,*last;
		first = last = nullptr;
		inorder(root,first,last);
		return first;
    }
};

9. 判断是不是平衡二叉树

class Solution {
  public:
   
    int get_height(TreeNode* node) {
        if (node == nullptr)return 0;
        else
            return max(get_height(node->left), get_height(node->right)) + 1;
    }
    bool is_balanced(TreeNode* node) {
        if (node == nullptr)return true;
        return is_balanced(node->left)&&is_balanced(node->right)&&abs(get_height(node->left) - get_height(node->right)) <= 1;
    }
    bool IsBalanced_Solution(TreeNode* pRoot) {
        // write code here
        return is_balanced(pRoot);
    }
};