关闭

二叉树

100人阅读 评论(0) 收藏 举报
分类:

1.树的节点:节点包含数据和指向其它节点的指针,因为不知道有几个指向其它节点的指针呢个,所以树的结构变得难以定义(因为子节点的个数是未知的),这是可以采用左孩子和右兄弟的表示方法,左孩子可以访问左子树的节点,用右子树可以一直往下访问它的兄弟节点,这样就可以实现树的定义和访问。

2.二叉树:对于二叉树,它只有左子树和右子树,所以二叉树就不难表示,二叉链中包含数据,指向左子树的指针和指向右子树的指针,三叉链中包含数据,指向左子树的指针,指向右子树的指针和指向父亲节点的指针。

3.二叉树的遍历:

         先序:根节点->左子树节点->右子树节点

         中根:左子树节点->根节点->右子树节点

         后根:左子树节点->左子树节点->根节点


template <typename T>
struct BinaryTreeNode
{
                 BinaryTreeNode<T >* _left;
                 BinaryTreeNode<T >* _right;
                 T _data;
                BinaryTreeNode( const T & data)
                                :_data( data)
                                , _left( NULL)
                                , _right( NULL)
                {
                }
};

template<typename T>
class BinaryTree
{
public:
                BinaryTree()
                                :_root( NULL)
                {
                }
                BinaryTree( const T * a,int size,const T& invalid)
                {
                                 int pos = 0;
                                _root = _CreatBinaryTree( a,pos,size ,invalid);
                }
                ~BinaryTree()
                {
                                 int pos = 0;
                                _DelBinaryTree(_root);
                                cout << endl;
                }
                BinaryTree( const BinaryTree <T>& b)//树的拷贝构造
                {
                                _root=_CopyBinaryTree( b._root);
                }
                 BinaryTree<T >& operator=(BinaryTree< T> b )
                {
                                swap(_root, b._root);//现代写法
                                 return *this ;
                }
                 void PrevOrder()//先序遍历
                {
                                _PrintPrevOrder(_root);
                                cout << endl;

                }
                 void InOrder()//中序遍历
                {
                                _PrintInOrder(_root);
                                cout << endl;
                }
                 void PostOrder()//后序遍历
                {
                                _PrintPostOrder(_root);
                                cout << endl;
                }
                 void LevelOrder()//层序遍历
                {
                                _PrintLevelOrder(_root);
                }
                 size_t Size()
                {
                                 return _Size(_root);
                }
                 size_t Depth()
                {
                                 return _Depth(_root);
                }
                 size_t LeafSize()//叶子节点个数
                {
                                 return _LeafSize(_root);
                }
protected:
                 BinaryTreeNode<T >* _CopyBinaryTree(BinaryTreeNode< T>* root )//复制树
                {
                                 BinaryTreeNode<T >* newroot = NULL;
                                 if (root == NULL)
                                {
                                                 return NULL ;
                                }
                                newroot = new BinaryTreeNode <T>(root->_data);
                                newroot->_left = _CopyBinaryTree( root->_left);
                                newroot->_right = _CopyBinaryTree( root->_right);
                                 return newroot;
                }
                 int _LeafSize(BinaryTreeNode <T>* root)//树的叶子节点个数(左子树叶子节点个数+右子树叶子节点个数)
                {
                                 if (root ==NULL)
                                {
                                                 return 0;
                                }
                                 else if (root->_left == NULL&&root ->_right == NULL)
                                {
                                                 return 1;
                                }
                                 else
                                {
                                                 return _LeafSize(root ->_left) + _LeafSize(root->_right);
                                }
                }

                 int _Depth(BinaryTreeNode <T>* root)//树的深度
                {
                                 int leftdepth = 0;
                                 int rightdepth = 0;
                                 if (root == NULL)
                                {
                                                 return 0;
                                }
                                leftdepth = _Depth( root->_left);
                                rightdepth = _Depth( root->_right);
                                 return _Depth(root ->_left) > _Depth(root->_right) ? leftdepth + 1: rightdepth + 1;
                }

                 int _Size(BinaryTreeNode <T>* root)//树的节点个数
                {
                                 if (root ==NULL)
                                {
                                                 return 0;
                                }
                                 return _Size(root ->_left) + _Size(root->_right) + 1; //左子树个数+右子树个数+跟节点
                }

                 void _PrintLevelOrder(BinaryTreeNode <T>* root)//层序遍历(借助队来实现)
                {
                                 queue<BinaryTreeNode <T>*> q;
                                 if (root == NULL)
                                {
                                                 return;
                                }
                                q.push( root);
                                 while (q.size())
                                {
                                                 if (q.front()->_left != NULL )
                                                {
                                                                q.push(q.front()->_left);
                                                }
                                                 if (q.front()->_right != NULL )
                                                {
                                                                q.push(q.front()->_right);
                                                }
                                                cout << q.front()->_data << " " ;
                                                q.pop();
                                }
                }

                 void _PrintPrevOrder(BinaryTreeNode <T>* root)//先序打印
                {
                                 if (root == NULL)
                                {
                                                 return;
                                }
                                cout << root->_data << " " ;
                                _PrintInOrder( root->_left);
                                _PrintInOrder( root->_right);
                }

                 void _PrintInOrder(BinaryTreeNode <T>* root)//中序遍历
                {
                                 if (root == NULL)
                                {
                                                 return;
                                }
                                _PrintInOrder( root->_left);
                                cout << root->_data << " " ;
                                _PrintInOrder( root->_right);
                }

                 void _PrintPostOrder(BinaryTreeNode <T>* root)//后序遍历
                {
                                 if (root == NULL)
                                {
                                                 return;
                                }
                                _PrintPostOrder( root->_left);
                                _PrintPostOrder( root->_right);
                                cout << root->_data << " " ;
                }

                 void _DelBinaryTree(BinaryTreeNode <T>* root)//删除二叉树
                {
                                 if (root == NULL)
                                {
                                                 return;
                                }
                                 if (root ->_left == NULL&& root->_right == NULL )
                                {
                                                 delete root ;
                                                 return;
                                }
                                _DelBinaryTree( root->_left);
                                _DelBinaryTree( root->_right);
                }

                 BinaryTreeNode<T >* _CreatBinaryTree(const T* a, int& pos,int size, const T& invalid)//创建一个二叉树
                {
                                 BinaryTreeNode<T >* root=NULL;
                                 if (a [pos] != invalid&&pos <size)
                                {
                                                root = new BinaryTreeNode <T>(a[pos]);
                                                root->_left = _CreatBinaryTree(a , ++pos, size, invalid);
                                                root->_right = _CreatBinaryTree(a ,++pos, size, invalid);
                                }
                                 return root;
                }
private:
                 BinaryTreeNode<T >* _root;
};


/*******************************/

void test()
{
                 int a1[10] = { 1, 2, 3, '#' , '#', 4, '#', '#' , 5, 6 };
                 BinaryTree<int > b1(a1, 10, '#');//将#封装,这样灵活性更强,可以改变
                 //b1.PrevOrder();
                 /*b1.InOrder();
                b1.PostOrder();
                b1.LevelOrder();*/
                 //cout << endl;
                 //cout << b1.Size() << endl;;

                 BinaryTree<int > b2;
                b2 = b1;
                b2.PrevOrder();
                b2.InOrder();
                b2.PostOrder();
                 //cout<<b2.Size()<<endl;
                 //cout<<b2.Depth()<<endl;

                cout << b1.LeafSize() << endl;
}


 


本文出自 “anser” 博客,请务必保留此出处http://674353165.blog.51cto.com/10786549/1766136

1
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:13449次
    • 积分:303
    • 等级:
    • 排名:千里之外
    • 原创:32篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类