LeetCode随笔之Binary Tree(二叉树)

1. 二叉搜索（排序）树建树及其他操作

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
    double w;
    struct node *l,*r;
}*Node;

void Build(Node &rt,double a)//建树
{
    if(rt==NULL)
    {
        rt=new node;
        rt->w=a;
        rt->l=0;
        rt->r=0;
    }
    else
    {
        if(a<rt->w)
            Build(rt->l,a);
        else
            Build(rt->r,a);
    }
}
double fin(struct node *rt)  //找最小的权
{
    if(!rt)
        return 0;
    else if(!rt->l)
        return rt->w;
    else
        return fin(rt->l);
}

void delet(Node &rt,double w)//删除权为w点
{
    if(!rt)
    {
        printf("没有\n");
        return ;
    }
    else if(rt->w<w)
        delet(rt->r,w);
    else if(rt->w>w)
        delet(rt->l,w);
    else if(rt->l&&rt->r)
    {
        struct node *tmp;
        tmp=rt;
        tmp->w=fin(tmp->r);
        delet(tmp->r,tmp->w);
    }
    else
    {
        struct node *t;
        t=rt;
        if(rt->l)
            rt=rt->l;
        else
            rt=rt->r;
        delete(t);
    }

}
void in(struct node *rt) //中序
{
    if(rt)
    {
        in(rt->l);
        printf("%lf ",rt->w);
        in(rt->r);
    }
    else
        return ;
}
double w;
int aim;

void search(Node rt,int &cnt) //找第aim小
{
    if(rt)
    {
        search(rt->l,cnt);
        cnt++;
        if(cnt==aim)
        {
            w=rt->w;
            return;
        }
        search(rt->r,cnt);

    }    
}
int main()
{
    int n;
    scanf("%d",&n);
    struct node *root;
    root=0;
    for(int i=1;i<=n;i++) //插入
    {
        double a;
        scanf("%lf",&a);
        Build(root,a);
    }
    in(root);
    printf("\n");
    scanf("%d",&n);
    for(int i=1;i<=n;i++)  //删除
    {
        double a;
        scanf("%lf",&a);
        delet(root,a);
        in(root);
        printf("\n");
    }
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&aim);  //第aim小
        int cnt=0;
        search(root,cnt);
        printf("%lf\n",w);
    }
    return 0;
}
/*
9
3 4 2 5 7 6 3.5 3.1 3.6
0
3
6
7
3

*/

1. 中兴2018算法笔试题
   例：
   输入两个数组，7 4 3 6 5 //表示二叉树的节点的值
   {[1,2],[1,3],[3,4],[3,5]} //表示二叉树边连接的节点的编号
   这个二叉树的图示为
   
   请输出路径树的所有路径上的数连乘的最大的值，此题的结果就是7*3*6；
   我现在就是不太会用这些数据建树，如果能建树成功的话，这个连乘最大值还是很好求的。希望各位神牛不吝赐教。
   1
   2
   3
   4
   5
   class Solution{
   int getMaxValue(vector &nodeValue,vector

//用例1
//5
//7 4 3 6 5
//1 2
//1 3
//3 4
//3 5
//用例2
//5
//7 4 -3 -5 4
//1 2
//1 3
//3 4
//3 5
#include <iostream>
#include <vector>
#include <map>

using namespace std;

//7 4 3 6 5   //表示二叉树的节点的值
//{[1,2],[1,3],[3,4],[3,5]}  //表示二叉树边连接的节点的编号
struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int val):val(val),left(NULL),right(NULL){}
};
class Solution{
public:
    int getMaxValue(vector<int> &nodeValue,vector<vector<int>> &edges){
        TreeNode *root=setTree(nodeValue,edges);

        return dfs(root).first;
    }
    //由于路径节点有正有负，所以需要dfs时，需要返回当前连乘的最大值和最小值
    //树的操作采用后续遍历
    pair<int,int> dfs(TreeNode* root){
        if(!root->left && !root->right){
            return make_pair(root->val,root->val);
        }
        pair<int,int> resl,resr;
        if(root->left){
            pair<int,int> a=dfs(root->left);
            resl.first=max(a.first*root->val,a.second*root->val);
            resl.second=min(a.first*root->val,a.second*root->val);
        }
        if(root->right){
            pair<int,int> b=dfs(root->right);
            resr.first=max(b.first*root->val,b.second*root->val);
            resr.second=min(b.first*root->val,b.second*root->val);
        }
        pair<int,int> res;
        res.first=max(resl.first,resr.first);
        res.second=min(resl.second,resr.second);
        return res;
    }
    TreeNode* setTree(vector<int> &nodeValue,vector<vector<int>> &edges){
        map<int,TreeNode*> my;
        for(int i=0;i<nodeValue.size();i++){//逐个将节点序号和新的节点用map关联
            TreeNode *node=new TreeNode(nodeValue[i]);
            my[i+1]=node;
        }
        for(int i=0;i<edges.size();i++){//按照边来索引建树
            if(my[edges[i][0]]->left!=NULL) my[edges[i][0]]->right=my[edges[i][1]];
            else my[edges[i][0]]->left=my[edges[i][1]];
        }
        return my[1];
    }
};
int main(){
    int n;cin>>n;
    vector<int> nodeValue;
    vector<vector<int>> edges(n-1);
    for(int i=0;i<n;i++){
        int tmp;cin>>tmp;nodeValue.push_back(tmp);
    }
    for(int i=0;i<n-1;i++){
        for(int j=0;j<2;j++){
            int tmp;cin>>tmp;edges[i].push_back(tmp);
        }
    }
    Solution solve;
    int out=solve.getMaxValue(nodeValue,edges);

}