Ch4-1: identify if a tree is "balanced" (注：CTCI 第四版和第五版的定义不一样)

To identify if the most different leaves, it is:  If < 1, then balance. otherwise, not.

So we need to traverse the tree to find the leaves' depth, so we pick 1 of 3 traverse oders: the inorder.

In order to implement a tree, need a structure:

struct BinNode{
	int data;
	BinNode *parent, *lChild, *rChild;
};

Then we can traverse each node and find the depth of each leaf. Read this snippet, very elegant recursion version (although not high efficient as iteration version since large constant coefficient of O(n)). 

Look at the:  ++d, dep[++numLeaf]=d, --d;

// the helper method
int d=0, numLeaf=0, dep[MAX_NUM];
void getDep(BinNode* head){
	if(head == NULL) return;
	++d;  // key in recursion
	getDep(head->lChild);
	if(head->lChild==NULL && head->rChild==NULL){
		dep[++numLeaf] = d;  //
	}
	getDep(head->rChild);
	--d;  // key in recursion
}

Then we can simply check all the dep[numLeaf] and find the largest, smallest one, and find the difference of them.

Also, as the linked list, we need to implement tree, so we need to initialize it by init() and insert().

The insert() is elegant too.

// very good design of the insert method!
void insert(BinNode* &head, int value){
	if(head==NULL) {
		//head->data = value;  Hawstein used array to store BST
		BST[idx].data = value;
		BST[idx].parent = p;
		head = &BST[idx++]; // note, this is post increment 
		return;  // C++ primer P223, this return equal to break
	};

	p = head;
	if(value < head->data)
		insert(head->lChild, value);
	else
		insert(head->rChild, value);
}

And here is the whole code:

// Ch4-1 solution: identify if a BST is balanced.
// Note: this is the solution for CTCI 4th, not 5th.
// In 4th, the definition of balanced is: a balanced tree is defined to be a tree such that no two leaf nodes differ in distance from the root by more than one.
// In 5th, a balanced tree is defined to be a tree such that the heights of the two subtrees of any node never differ by more than one.

#include 
   
   
    
    
#include 
    
    
     
     

const int MAX_NUM = 100;

using namespace std;

struct BinNode{
    int data;
	BinNode *parent, *lChild, *rChild;
};

BinNode *head, *p, BST[MAX_NUM];
int idx;

void init(){
	head = p = NULL;
	memset(BST, '\0', sizeof(BST));  // since an array, then init as 
	idx=0;							 // EOF by using termination value
}

void insert(BinNode* &head, int value){
	if(head==NULL) {
		//head->data = value;  Hawstein used array to store BST
		BST[idx].data = value;
		BST[idx].parent = p;
		head = &BST[idx++];
		return;
	};

	p = head;
	if(value < head->data){
		insert(head->lChild, value);
        //cout << "inserted: "<< value << " as lChild of "<< head->data << endl;
    }
    else{
		insert(head->rChild, value);
        //cout << "inserted: "<< value << " as rChild of "<< head->data << endl;
    }
}

// the helper method
int d=0, numLeaf=0, dep[MAX_NUM];
void getDep(BinNode* head){
	if(head == NULL) return;
	++d;  // key in recursion
	getDep(head->lChild);
	if(head->lChild==NULL && head->rChild==NULL){
		dep[++numLeaf] = d;  //
	}
	getDep(head->rChild);
	--d;  // key in recursion
}

// the main method
bool isBalance(BinNode* head){
	if(head==NULL) return true;
	getDep(head);
	int max = dep[0], min = dep[0];
	for(int i =0; i
     
     
      
      max) max=dep[i];
		if(dep[i]
      
      
       
        1) return false;
	else return true;
}

int main(){
	init();
	int a[] = {
		5, 3, 8, 1, 4, 7, 10, 2, 6, 9, 11, 12
        //5, 3, 8, 12
	};
    int num_a = 12;
	for(int i = 0; i
       
       
         data << endl; cout << checker; return 0; } 
       
      
      
     
     
    
    
   
   

and the output:

Executing the program....
$demo 
0
testing num_a    1
5: BST[0]
3: BST[1]
8: BST[2]
1: BST[3]
4: BST[4]
7: BST[5]
10: BST[6]
2: BST[7]
6: BST[8]
9: BST[9]
11: BST[10]
12: BST[11]
testing num_a    2
data: 10
0x6018a0