2016年阿里C/C++开发笔试程序题一

#include "iostream"
using namespace std;
struct pair_t
{
    int a,b;
};
struct node_t
{
    int a,b;
    node_t *left, *right;
};
/*
    build用来建立二叉树
    实现思路：
    从pair[]中找到最大的b，以最大b那个元素为根节点root，因为根节点
    b肯定是最大的，然后再将pair[]中小于root->a的元素归于lpair[]，
    大于root->a的元素归于rpair[],  用递归的方式将lpair和rpair建立
    root的左子树和右子树
*/
node_t *build(pair_t *pair, int n)
{
    int i = 0;
    int maxb_index = 0;            //pair中b最大的下标 
    int maxb = 0;
    int temp;
    int left_num = 0;              //pair中小于root->a的元素个数    
    int right_num = 0;             //pair中大于root->a的元素个数
    node_t *root = new node_t;     
    pair_t *rpair = new pair_t[n]; //存放pair中大于root->a的元素       
    pair_t *lpair = new pair_t[n]; //存放pair中小于root->a的元素

    if(n == 0) {root = 0;return root;}//n=0为递归结束的标志

    for(i = 0; i < n; i++)         //找到最大的b及对应的下标
    {
        if(pair[i].b > maxb)
        {
            maxb = pair[i].b;
            maxb_index = i;
        }
    }
    root->a = pair[maxb_index].a;  //将找到的元素作为根节点
    root->b = pair[maxb_index].b;

    for(i = 0; i < n; i++)
    {
        if(pair[i].a < root->a)   //将小于root->a的元素全部存放在lpair[]数组中
        {
            *lpair = pair[i];
            lpair++;
            left_num++;
        }
        else if(pair[i].a > root->a) //将大于root->a的元素全部存放在rpair[]数组中
        {
            *rpair = pair[i];
            rpair++;
            right_num++;
        }
    }

    lpair = lpair - left_num;
    rpair = rpair - right_num;

    root->left  = build(lpair,left_num); //构建左子树
    root->right = build(rpair,right_num);//构建右子树
    return root;
}
/*
    insert用于将节点插入二叉树中
*/
node_t *insert(node_t *root, node_t xnode)
{
    node_t *head;
    node_t *prehead;
    node_t *newNode = new node_t;
    prehead = head = root;
    newNode->a = xnode.a;
    newNode->b = xnode.b;           
    while(1)
    {
        if(xnode.a > head->a)          //如果xnode.a 大于 head->a说明xnode在head右边或者取代head
        { 
            if(xnode.b < head->b)      //如果xnode.b 小于 head->b，说明还需要往head下面查找
            {
                prehead = head;
                head = head->right;
                continue;
            }
            else                       //如果xnode.b 大于 head->b，说明xnode恰好在head上面一层
            {
                if(head != root)
                    prehead->right = newNode;
                newNode->right = head->right;
                newNode->left = head;
                head->right = 0;
                if(head == root)
                    root = newNode;
                return root;
            }
        }
        else                        //如果xnode.a 大于 head->a，逻辑与上面相似
        {
            if(xnode.b < head->b)
            {
                prehead = head;
                head = head->left;
                continue;
            }
            else
            {
                if(head != root)
                    prehead->left = newNode;
                newNode->right = head;
                newNode->left = head->left;
                head->left = 0;
                if(head == root)
                    root = newNode;
                return root;
            }
        }

    }

}
void print(node_t *root)
{
    if(root != 0)
    {
        cout<<"("<<root->a<<", "<<root->b<<")"<<endl;
    }
    else return;
    print(root->left);
    print(root->right);
}
void main()
{
    node_t *root;
    node_t node = {20,9};
    pair_t initPair[7] = {{5,8},{2,10},{4,3},{1,5},{0,2},{9,1}};
    root = build(initPair, 7);
    print(root);
    cout<<"--------------------------"<<endl;
    root = insert(root, node);
    print(root);
    cout<<"over"<<endl;
}

“`

本程序是自己所想，不保证正确，仅供参考，还望勿喷，欢迎意见讨论^_^