Ch4.3: transform an ordered array into a balanced Tree

In this problem, it is like the classical recursion example: draw the ruler as the sign of algorithms 4th textbook.

In order to draw a balanced tree from an array, we need to keep left subtree.height similar or equal to right subtree.height.

First need to find the root--->we can choose the middle number of the array. then recursively go to left construction and right construction.

Here is the main algorithm: 

note: the first parameter seems no use of the head, but it is a good one. By using call-by-reference of the head pointer, we don't need to declare head as  a global variable, and it can be explicitly shown in the recursion part to tell the order of recursion: left tree first and then right one.

void min_BST(BinNode* &head, BinNode *parent, int a[], int start, int end){
	if(start<=end){
		int mid=(start+end)>>1;
		node[cnt].data = a[mid];
		node[cnt].parent = parent;
		head = &node[cnt++];
		min_BST(head->lChild, head, a, start, mid-1);
		min_BST(head->rChild, head, a, mid+1, end);
	}
}

Here is the whole code.

// Ch4-3: create a balanced minimal BST from an ordered array 

#include 
#include 
using namespace std;

const int maxn=100;

int jerry = 0;

struct BinNode{
    int data;
    BinNode *parent, *lChild, *rChild;
};
BinNode node[maxn];
int cnt;

//BinNode *head = NULL; if use ver2, need to declare head as global var
void init(){
	memset(node, '\0', sizeof(node));
	cnt=0;
}

void min_BST(BinNode* &head, BinNode *parent, int a[], int start, int end){
	if(start<=end){
		int mid=(start+end)>>1;
		node[cnt].data = a[mid];
		node[cnt].parent = parent;
		head = &node[cnt++];
		min_BST(head->lChild, head, a, start, mid-1);
		min_BST(head->rChild, head, a, mid+1, end);
	}
}
// if "BinNode* &head" is not inside of method, then it must be a global variable
// so as to be changed every time, also, it will be less clear in recursion:
// which is first? lChild or rChild. So I prefer to have "BinNode* &head" inside 
// of the method, need to make a call by reference that we can modify the value
/*
void min_BST_ver2(BinNode *parent, int a[], int start, int end){
    if(start <= end){
        int mid = (start + end)>>1;
        node[cnt].data = a[mid];
        node[cnt].parent = parent;
        head = &node[cnt++];
        min_BST_ver2(head, a, start, mid-1);
        min_BST_ver2(head, a, mid+1, end);
    }
}
*/

int height(BinNode* head){
    if(head==NULL) 
        return 0;
    else{
		return max(height(head->lChild), height(head->rChild))+1;
	}
}

int main(){
	init();
	int a[] = {
		0,1,2,3
	};
    
    
	BinNode *head = NULL;  //if use ver2, need to declare head as global var
	min_BST(head, NULL, a, 0, 3);
    
    cout<<"\nheight: "<data<lChild)<<"  " <lChild << "dizhi\n";
    cout<lChild->data<rChild->data<rChild->rChild->data<// Ch4.3: Given a binary search tree, design an algorithm which creates a linked list of all the nodes at each depth (i.e., if you have a tree with depth D, you’ll have D linked lists).

// based on Hawstein's solution
// and modified into class version according to zyli github

#include 
#include 
#include 

using namespace std;

template
class BinNode{
public:
    T key;
    BinNode *parent, *lChild, *rChild;
    BinNode(){}
	BinNode(T t): key(t), parent(NULL), lChild(NULL), rChild(NULL){}
};

template
class BTree{
private:
	BinNode *m_root;
public:
	BTree(): m_root(NULL){}
	BTree(BinNode *t): m_root(t){}

	BinNode* getRoot() const{return m_root;}
	// node the 1st parameter cannot be "BinNode* &pnode"
	BinNode* balanceTree(BinNode* pnode, BinNode *parent, T *arr, int low, int high){
		if(low>high || arr == NULL)
			return NULL;
		int mid = (low+high)>>1;
		pnode = new BinNode(arr[mid]);
		pnode->parent = parent;
		pnode->lChild = balanceTree(pnode->lChild, pnode, arr, low, mid-1);
		pnode->rChild = balanceTree(pnode->rChild, pnode, arr, mid+1, high);

		return pnode;
	}

	void PrintPre(BinNode *pnode)
	{
		if(pnode == NULL)
			return;
 
		cout << pnode->key << " ";
		PrintPre(pnode->lChild);
		PrintPre(pnode->rChild);		
	}
};


int main(){
    cout << "hello"< *bt = new BTree();
	BinNode *proot = bt->balanceTree(bt->getRoot(), NULL, arr, low, high);
    bt = new BTree(proot);
    bt->PrintPre(bt->getRoot());
}