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

最新推荐文章于 2014-05-11 15:07:37 发布

原创最新推荐文章于 2014-05-11 15:07:37 发布 · 877 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

ctci 专栏收录该内容

34 篇文章

订阅专栏

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; imax) 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; idata << 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