Дерево турнира с выбыванием

#define _CRT_SECURE_NO_WARNINGS
#include "stdafx.h"
#include <iostream>
#include <stdio.h>
#include <conio.h>
using namespace std;
struct tree 
{
    int info;
    tree *right;
    tree *left;
};
tree *create_tree(tree *current, int element)
{
   if (current==NULL) 
     {
        current = new tree;
        current->info = element;
        current->right = NULL;
        current->left = NULL;
        return current;
     }
   if (current->info < element)          
     current->right = create_tree(current->right, element);
   else
     current->left  = create_tree(current->left, element);
   return current;
}
void simmetric(tree *current,int l)
{
   if(current!=NULL)
    {
        simmetric(current->left,l+1);
        for(int i=0;i<l;i++)
            cout << "\t";
        cout << current->info << endl;
        simmetric(current->right,l+1);        
    }
}
void show_tree(int massive[], int mcounter)       
{
   tree *current;
   current = NULL;
   for (int i=0; i<mcounter; i++)        
      current = create_tree(current, massive[i]);     
   cout<<"\nSymmetric: \n";
   simmetric(current,0); 
}
void delete_tree(tree **current)
{
    int count=13;
    if(*current!=NULL)
    {
        delete_tree(&(*current)->left);
        delete_tree(&(*current)->right);
        delete *current;
        count--;
        if(count==0)
            *current=NULL;
    }
}
void showsymmetric(tree *current,int l)
{
    if(current!=NULL)
    {
        showsymmetric(current->left,l+1);
        for(int i=0;i<l;i++)
            cout << "\t";
        cout << current->info << endl;
        showsymmetric(current->right,l+1);
    }
    delete_tree(&current);
}
int main()
{
int massive [13] = {5, 9, 13, 14, 2, 7, 1, 15, 18, 8, 4, 3, 50};
show_tree(massive,13);
getch();
return 0;

#include <iostream>
#include <list>
#include <ctime> 
using namespace std;
struct node{
    int value;
    int level;
    node* left;
    node* right;
    node(int val=0):value(val), right(NULL), left(NULL), level(0){};
};
list<node*> fill(){
    list<node*> buffer;
    int n;
    struct node* new_elem;
    srand(time(NULL));
    cout<<"input n of elems:";
    cin>>n;
    cout<<"elements are:";
    while(n--)
    {
        new_elem=new node(rand()%90+10);
        cout<<(new_elem->value)<<", ";
        buffer.push_back(new_elem);
    }
    cout<<endl;
    return buffer;
}
node* build_tree(list<node*> buffer){
    node* a;
    node* b;
    node* parent_of_a_b;
 
    while (!buffer.empty()){
        a=buffer.front();
        buffer.pop_front();
        if (buffer.empty())
            return a;
        b=buffer.front();
        buffer.pop_front();
        parent_of_a_b=new node(max(a->value, b->value));
        parent_of_a_b->left=a;
        parent_of_a_b->right=b;
        parent_of_a_b->level=max(a->level, b->level)+1;
        buffer.push_back(parent_of_a_b);    
    }
 
}
void print_level(int lvl, node* root){
    if (root->level>lvl){
        print_level(lvl, root->left);
        print_level(lvl, root->right);
    }
    else{
        if (root->level==lvl){
            cout<<root->value;
            for (int i=0; i<4*(1<<lvl)-2; i++)
                cout<<" ";
        }
    }
 
}
void print_tree(node* root){
    cout<<"THE TREE:"<<endl;
    for (int i=(root->level); i>=0; i--){
        for (int j=0; j<2*(1<<i)-2; j++)
            cout<<" ";
        print_level(i, root);
        cout<<endl;
    }
}
int main() // Оcновное тело программы
{
    list<node*> buffer;
    node* root;
    buffer=fill();
    root=build_tree(buffer);
    print_tree(root);
    system("PAUSE");
}

tree *tournament(tree *current, int massive[],int l,int r)
{
    int m = (l+r)/2;
    current = new tree;
    current->info = massive[m];
    current->right = NULL;
    current->left = NULL;
    if (l == r) 
        return current;
    current->left = tournament (current->left,massive, 1, m) ;
    current->right = tournament (current->right,massive, m+1, r) ;
    int u = current->left->info;
    int v = current->right->info;
    if (u > v) 
        current->info = u; 
    else current->info=v;
    return current;
}

struct node{
    int value;
    int level;
    node* left;
    node* right;
};