BinaryTree

 ��������һ���Ƚ���Ҫ����ݽṹ����ƪ���½�����linux��ʵ��BinaryTree

 һ.���빤��Ŀ¼�����Լ��ڹ���Ŀ¼�½���һ��DataStruct��Ŀ¼��

 $touch BinaryTree.cpp ���ļ�

 $vim BinaryTree.cpp 

 ��.������

  1).�������Ľ��� -- �ݹ齨��

 ��Ҫע��ĵ�

  a.indexΪ�����±�������Ϊ�ǵݹ齨�������Ա��봫���á�

  b.invaildΪ��Ч��ֵ��������ֹ���������

 2).���������������

  a.��������ڵ㣬�ٱ������������������������

 3).���������������

a.����������������ٱ����ڵ㣬�������������

 4).�������ĺ������

a.����������������ٱ�����������������ڵ㡣

 5).�������IJ������

a.���ö����Ƚ��ȳ������ԣ���ѹ��ڵ㣬֮����ʸ�ڵ㣬pop��ڵ㣬ѹ�����������Դ˷��ʡ�

 ��.��������

$g++ -o BinaryTree BinaryTree.cpp -g (-g �Ǽ��������Ϣ������gdb����)

$./BinaryTree

���

������

���룺

#pragma once
#include<iostream>
using namespace std;
#include<queue>


template<class T>
struct BinaryTreeNode
{
	BinaryTreeNode(const T& x)
	:_data(x)
	, _left(NULL)
	, _right(NULL)
	{}


	T _data;
	BinaryTreeNode<T>* _left;
	BinaryTreeNode<T>* _right;
};

template<class T>
class BinaryTree
{
	typedef BinaryTreeNode<T> Node;
public:
	BinaryTree()
		:_root(NULL)
	{}

	BinaryTree(const T* a, size_t size, const T& invaild)
	{
		size_t index = 0;
		_root = _BinaryTree(a, size, index, invaild);
	}

	~BinaryTree()
	{}

	BinaryTree(const BinaryTree<T>& t)
	{
		_root = _Copy(t._root);
	}

	void prevOrder()   //ǰ�����
	{
		_prevOrder(_root);
		cout << endl;
	}

	void inOrder()     //�������
	{
		_inOrder(_root);
		cout << endl;
	}

	void nextOrder()    //�������
	{
		_nextOrder(_root);
		cout << endl;

	}

	void levelOrder()
	{
		_levelOrder(_root);
	}

	size_t size()
	{
		return _size(_root);
	}

	size_t Depth()
	{
		return _Depth(_root);
	}

	size_t leafsize()
	{
		return _leafsize(_root);
	}

	size_t GetKLevel(int k)
	{
		return _GetKLevel(int k);
	}

protected:

	void _Destroy(Node* root)
	{
		if (root == NULL)
		{
			return;
		}
		//--------------------------------------------------
		_Destroy(root->_left);
		_Destroy(root->_right);

		_Destroy root;

	}

	Node* _Copy(Node* root)
	{
		if (root == NULL)
		{
			return NULL;
		}

		Node* newRoot = new Node(root->_data);
		newRoot->_left = _Copy(root->_left);
		newRoot->_right = _Copy(root->_right);

		return newRoot;
	}


	Node* _BinaryTree(const T* a, size_t size, size_t& index, const T& invaild)    //����Ҫ��index������
	{
		Node* root = NULL;
		if (index < size && a[index] != invaild)
		{
			root = new Node(a[index]);
			root->_left = _BinaryTree(a, size, ++index, invaild);
			root->_right = _BinaryTree(a, size, ++index, invaild);
		}
		return root;
	}
	

	void _prevOrder(Node* root)
	{
		//Node* cur = root;
		if (root == NULL)
		{
			return;
		}
		cout << root->_data << " ";
		_prevOrder(root->_left);
		_prevOrder(root->_right);
	}

	void _inOrder(Node* root)
	{
		if (root == NULL)
		{
			return;
		}
		_inOrder(root->_left);
		cout << root->_data << " ";
		_inOrder(root->_right);
	}

	void _nextOrder(Node* root)
	{
		if (root == NULL)
		{
			return;
		}
		_nextOrder(root->_left);
		_nextOrder(root->_right);
		cout << root->_data << " ";
	}

	size_t _size(Node* root)
	{
		if (root == NULL)
		{
			return 0;
		}
		//�������������������ϸ�ڵ�

		return _size(root->_left) + _size(root->_right) + 1;
	}

	//size_t _Depth(Node* root)
	//{
	//	if (root == NULL)
	//	{
	//		return 0;
	//	}
	//	return _Depth(root->_left) > _Depth(root->_right) ? _Depth(root->_left)+1 : _Depth(root->_right)+1;   //Ч��̫��
	//}

	size_t _Depth(Node* root)
	{
		if (root == NULL)
		{
			return 0;
		}
		int leftdepth = _Depth(root->_left);   //---------------------------------
		int rightdepth = _Depth(root->_right);

		return leftdepth > rightdepth ? leftdepth+1 : rightdepth+1;
	}

	size_t _leafsize(Node* root)
	{
		static size_t size = 0;
		if (root == NULL)
		{
			return 0;
		}

		if (root->_left == NULL && root->_right == NULL)
		{
			++size;
			return size;
		}
		
		_leafsize(root->_left);
		_leafsize(root->_right);

		return size;
	}

	size_t _GetKLevel(int k)
	{
		if (_root == NULL)
		{
			return 0;
		}

		if (k == 1)
		{
			return 1;
		}


		Node* cur = _root;
		static size_t LeafKSize = 0;
		static size_t Level = 1;

		if (Level == k - 1)
		{
			
			if (_root->_left != NULL)
			{
				leafsize++;
			}

			if (_root->_right != NULL)
			{
				leafsize++;
			}

		}

		Level++;
		_GetKLevel(_root->_left);
		_GetKLevel(_root->_right);
	}

	void _levelOrder(Node* root)
	{
		if (root == NULL)
		{
			return;
		}
		queue<Node*> qTree;
		qTree.push(root);
		while (!qTree.empty())
		{
			Node* cur = qTree.front();
			qTree.pop();
			cout << cur->_data << " ";
			if (cur->_left)
			{
				qTree.push(cur->_left);
			}

			if (cur->_right)
			{
				qTree.push(cur->_right);
			}
		}
		cout << endl;
	}
	

protected:
	Node* _root;
};

 �������DZ�����ѧϰ����е�һЩ�����ܽᡣ��Ȼ�������������ޣ���������©��ϣ���ҿ���ָ��

���ij��� ����һ��ССС˾���� ���ͣ�����ر����˳���http://10799170.blog.51cto.com/10789170/1782797