数据结构与算法分析 树

由后缀式构造二叉表达树,前序遍历是前缀式,中序遍历是中缀式,后序遍历是后缀式

#include
#include
using namespace std;

template
struct BinaryNode{
	Object data;
	BinaryNode *left;
	BinaryNode *right;

	BinaryNode(const Object & x,BinaryNode *l,BinaryNode *r):data(x),left(l),right(r){}
};

void preOrderPrint(BinaryNode * root)
{
	if(root==NULL)
		return;
	cout<data<<" ";
	preOrderPrint(root->left);
	preOrderPrint(root->right);
}

void inOrderPrint(BinaryNode * root)
{
	if(root==NULL)
		return;	
	inOrderPrint(root->left);
	cout<data<<" ";
	inOrderPrint(root->right);
}

void postOrderPrint(BinaryNode * root)
{
	if(root==NULL)
		return;	
	postOrderPrint(root->left);	
	postOrderPrint(root->right);
	cout<data<<" ";

}

int main(){
	stack< BinaryNode * > s;
	char word;
	cin>>word;
	while(word!='=')
	{
		if(word>='a' && word<='z')
		{
			BinaryNode *temp=new BinaryNode(word,NULL,NULL);
			s.push(temp);
		}
		else
		{
			BinaryNode *b=s.top();
			s.pop();
			BinaryNode *a=s.top();
			s.pop();
			BinaryNode *result=new BinaryNode(word,a,b);
			s.push(result);
		}
		cin>>word;
	}
	cout<<"前序:";
	preOrderPrint(s.top());
	cout<


#include
#include
using namespace std;

/*二叉查找树*/
template
class BinarySearchTree{
public:
	BinarySearchTree()
	{
		root=NULL;
	}

	~BinarySearchTree()
	{
		makeEmpty();
	}

	BinarySearchTree(const BinarySearchTree &rhs):root(NULL)
	{
		*this=rhs;
	}
	const BinarySearchTree & operator=(const BinarySearchTree &rhs)
	{
		if(this!=&rhs)
		{
			makeEmpty();/*回收内存*/
			root=clone(rhs.root);
		}
		return *this;
	}
	void makeEmpty()
	{
		makeEmpty(root);
	}

	void insert(const Object & x){
		/*插入结点*/
		insert(x,root);
	}

	const Object & findMin()const
	{
		return findMin(root)->data;
	}

	const Object & findMax()const
	{
		return findMax(root)->data;
	}

	void printTree()const
	{
		printTree(root);
	}

	/*判断x是否在二叉查找树中*/
	bool contains(const Object &x)const
	{
		return contains(x,root);
	}

	void remove(const Object &x)
	{
		remove(x,root);
	}
private:
	struct BinaryNode{
		Object data;
		BinaryNode *left;
		BinaryNode *right;

		BinaryNode(const Object & x,BinaryNode *l,BinaryNode *r):data(x),left(l),right(r){}
	};
	BinaryNode *root;/*根指针*/
	void insert(const Object &x,BinaryNode * &t)
	{
		/*在递归的例程中,只有当一个新树叶生成的时候,t才改变*/
		/*当这种情况发生的时候,就说明递归例程被其它结点p调用了。*/
		/*该结点是树叶的父亲,调用的将是insert(x,t->left)或者是insert(x,t->right)*/
		/*在任何一种方法中,t是p->left或者p->right的引用。*/
		/*这意味着p->left或p->right将会被改变为指向新结点。*/
		if(t==NULL)
			t=new BinaryNode(x,NULL,NULL);
		else if(xdata)
			insert(x,t->left);
		else if(t->dataright);
		else/*重复,什么也不做*/
			;
	}
	void printTree(BinaryNode *t) const
	{
		/*中序遍历*/
		if(t==NULL)
			return;
		printTree(t->left);
		cout<data<<" ";
		printTree(t->right);
	}
	BinaryNode * findMin(BinaryNode *t)const
	{
		if(t==NULL)/*二叉操作树为空*/
			return NULL;
		if(t->left==NULL)/*找到了*/
			return t;
		return findMin(t->left);/*下一个*/
	}

	//BinaryNode * findMax(BinaryNode *t)const
	//{
	//	if(t==NULL)/*二叉操作树为空*/
	//		return NULL;
	//	if(t->right==NULL)/*找到了*/
	//		return t;
	//	return findMax(t->right);/*下一个*/
	//}

	/*findMax的非递归实现*/
	BinaryNode * findMax(BinaryNode *t)const 
	{
		while(t!=NULL && t->right!=NULL)
			t=t->right;
		return t;
	}

	bool contains(const Object & x,BinaryNode *t)const
	{
		if(t==NULL)
			return false;/*没有找到匹配*/
		if(xdata)
			contains(x,t->left);
		else if(t->dataright);
		else
			return true;/*匹配*/
	}

	/*删除元素x*/
	void remove(const Object & x,BinaryNode * &t)const
	{
		if(t==NULL)/*元素没找到*/
			return;
		if(xdata)
			remove(x,t->left);
		else if(t->dataright);
		else if(t->left!=NULL && t->right!=NULL)/*删除的结点有两个孩子*/
		{
			t->data=findMin(t->right)->data;/*用右子树的最小值替换删除结点的值*/
			remove(t->data,t->right);/*递归删除右边子树最小值结点,这次删除简单,因为该节点只有一个右子树,不可能有左子树*/
		}
		else/*只有1个或0个孩子*/
		{
			BinaryNode * old=t;
			t=(t->left!=NULL)?t->left:t->right;
			delete old;
		}
	}

	BinaryNode *clone(BinaryNode *t)const
	{
		if(t==NULL)
			return NULL;
		return new BinaryNode(t->data,clone(t->left),clone(t->right));
	}

	void makeEmpty(BinaryNode * &t)
	{
		if(t!=NULL)
		{
			makeEmpty(t->left);
			makeEmpty(t->left);
			delete t;
		}
		t=NULL;
	}
};


int main(){
	BinarySearchTree b;
	b.insert(6);
	b.insert(2);
	b.insert(1);
	b.insert(4);
	b.insert(3);
	b.insert(8);
	b.printTree();
	cout< c=b;/*复制构造函数*/
	
	c.printTree();
	cout<
#include
using namespace std;

/*求高度为h的AVL树的最小结点个数*/
int f(int n)
{
	if(n==0)
		return 1;
	else if(n==1)
		return 2;
	else 
		return f(n-1)+f(n-2)+1;
}

int main(){
	for(int i=1;i!=10;i++)
		cout<<"高度为"<

AVL树的实现

#ifndef AVL_TREE_H
#define AVL_TREE_H

#include "dsexceptions.h"
#include     // For NULL
using namespace std;

// AvlTree class
//
// CONSTRUCTION: with ITEM_NOT_FOUND object used to signal failed finds
//
// ******************PUBLIC OPERATIONS*********************
// void insert( x )       --> Insert x
// void remove( x )       --> Remove x (unimplemented)
// bool contains( x )     --> Return true if x is present
// Comparable findMin( )  --> Return smallest item
// Comparable findMax( )  --> Return largest item
// boolean isEmpty( )     --> Return true if empty; else false
// void makeEmpty( )      --> Remove all items
// void printTree( )      --> Print tree in sorted order
// ******************ERRORS********************************
// Throws UnderflowException as warranted

template 
class AvlTree
{
  public:
    AvlTree( ) : root( NULL )
      { }
    AvlTree( const AvlTree & rhs ) : root( NULL )
    {
        *this = rhs;
    }

    ~AvlTree( )
    {
        makeEmpty( );
    }

    /**
     * Find the smallest item in the tree.
     * Throw UnderflowException if empty.
     */
    const Comparable & findMin( ) const
    {
        if( isEmpty( ) )
            throw UnderflowException( );
        return findMin( root )->element;
    }

    /**
     * Find the largest item in the tree.
     * Throw UnderflowException if empty.
     */
    const Comparable & findMax( ) const
    {
        if( isEmpty( ) )
            throw UnderflowException( );
        return findMax( root )->element;
    }

    /**
     * Returns true if x is found in the tree.
     */
    bool contains( const Comparable & x ) const
    {
        return contains( x, root );
    }

    /**
     * Test if the tree is logically empty.
     * Return true if empty, false otherwise.
     */
    bool isEmpty( ) const
    {
        return root == NULL;
    }

    /**
     * Print the tree contents in sorted order.
     */
    void printTree( ) const
    {
        if( isEmpty( ) )
            cout << "Empty tree" << endl;
        else
            printTree( root );
    }

    /**
     * Make the tree logically empty.
     */
    void makeEmpty( )
    {
        makeEmpty( root );
    }

    /**
     * Insert x into the tree; duplicates are ignored.
     */
    void insert( const Comparable & x )
    {
        insert( x, root );
    }
     
    /**
     * Remove x from the tree. Nothing is done if x is not found.
     */
    void remove( const Comparable & x )
    {
        cout << "Sorry, remove unimplemented; " << x <<
                " still present" << endl;
    }

    /**
     * Deep copy.
     */
    const AvlTree & operator=( const AvlTree & rhs )
    {
        if( this != &rhs )
        {
            makeEmpty( );
            root = clone( rhs.root );
        }
        return *this;
    }

  private:
    struct AvlNode
    {
        Comparable element;
        AvlNode   *left;
        AvlNode   *right;
        int       height;

        AvlNode( const Comparable & theElement, AvlNode *lt,
                                                AvlNode *rt, int h = 0 )
          : element( theElement ), left( lt ), right( rt ), height( h ) { }
    };

    AvlNode *root;


    /**
     * Internal method to insert into a subtree.
     * x is the item to insert.
     * t is the node that roots the subtree.
     * Set the new root of the subtree.
     */
    void insert( const Comparable & x, AvlNode * & t )
    {
        if( t == NULL )
            t = new AvlNode( x, NULL, NULL );
        else if( x < t->element )
        {
            insert( x, t->left );
            if( height( t->left ) - height( t->right ) == 2 )
                if( x < t->left->element )
                    rotateWithLeftChild( t );
                else
                    doubleWithLeftChild( t );
        }
        else if( t->element < x )
        {
            insert( x, t->right );
            if( height( t->right ) - height( t->left ) == 2 )
                if( t->right->element < x )
                    rotateWithRightChild( t );
                else
                    doubleWithRightChild( t );
        }
        else
            ;  // Duplicate; do nothing
        t->height = max( height( t->left ), height( t->right ) ) + 1;
    }

    /**
     * Internal method to find the smallest item in a subtree t.
     * Return node containing the smallest item.
     */
    AvlNode * findMin( AvlNode *t ) const
    {
        if( t == NULL )
            return NULL;
        if( t->left == NULL )
            return t;
        return findMin( t->left );
    }

    /**
     * Internal method to find the largest item in a subtree t.
     * Return node containing the largest item.
     */
    AvlNode * findMax( AvlNode *t ) const
    {
        if( t != NULL )
            while( t->right != NULL )
                t = t->right;
        return t;
    }


    /**
     * Internal method to test if an item is in a subtree.
     * x is item to search for.
     * t is the node that roots the tree.
     */
    bool contains( const Comparable & x, AvlNode *t ) const
    {
        if( t == NULL )
            return false;
        else if( x < t->element )
            return contains( x, t->left );
        else if( t->element < x )
            return contains( x, t->right );
        else
            return true;    // Match
    }
/****** NONRECURSIVE VERSION*************************
    bool contains( const Comparable & x, AvlNode *t ) const
    {
        while( t != NULL )
            if( x < t->element )
                t = t->left;
            else if( t->element < x )
                t = t->right;
            else
                return true;    // Match

        return false;   // No match
    }
*****************************************************/

    /**
     * Internal method to make subtree empty.
     */
    void makeEmpty( AvlNode * & t )
    {
        if( t != NULL )
        {
            makeEmpty( t->left );
            makeEmpty( t->right );
            delete t;
        }
        t = NULL;
    }

    /**
     * Internal method to print a subtree rooted at t in sorted order.
     */
    void printTree( AvlNode *t ) const
    {
        if( t != NULL )
        {
            printTree( t->left );
            cout << t->element << endl;
            printTree( t->right );
        }
    }

    /**
     * Internal method to clone subtree.
     */
    AvlNode * clone( AvlNode *t ) const
    {
        if( t == NULL )
            return NULL;
        else
            return new AvlNode( t->element, clone( t->left ), clone( t->right ), t->height );
    }
        // Avl manipulations
    /**
     * Return the height of node t or -1 if NULL.
     */
    int height( AvlNode *t ) const
    {
        return t == NULL ? -1 : t->height;
    }

    int max( int lhs, int rhs ) const
    {
        return lhs > rhs ? lhs : rhs;
    }

    /**
     * Rotate binary tree node with left child.
     * For AVL trees, this is a single rotation for case 1.
     * Update heights, then set new root.
     */
    void rotateWithLeftChild( AvlNode * & k2 )
    {
        AvlNode *k1 = k2->left;
        k2->left = k1->right;
        k1->right = k2;
        k2->height = max( height( k2->left ), height( k2->right ) ) + 1;
        k1->height = max( height( k1->left ), k2->height ) + 1;
        k2 = k1;
    }

    /**
     * Rotate binary tree node with right child.
     * For AVL trees, this is a single rotation for case 4.
     * Update heights, then set new root.
     */
    void rotateWithRightChild( AvlNode * & k1 )
    {
        AvlNode *k2 = k1->right;
        k1->right = k2->left;
        k2->left = k1;
        k1->height = max( height( k1->left ), height( k1->right ) ) + 1;
        k2->height = max( height( k2->right ), k1->height ) + 1;
        k1 = k2;
    }

    /**
     * Double rotate binary tree node: first left child.
     * with its right child; then node k3 with new left child.
     * For AVL trees, this is a double rotation for case 2.
     * Update heights, then set new root.
     */
    void doubleWithLeftChild( AvlNode * & k3 )
    {
        rotateWithRightChild( k3->left );
        rotateWithLeftChild( k3 );
    }

    /**
     * Double rotate binary tree node: first right child.
     * with its left child; then node k1 with new right child.
     * For AVL trees, this is a double rotation for case 3.
     * Update heights, then set new root.
     */
    void doubleWithRightChild( AvlNode * & k1 )
    {
        rotateWithLeftChild( k1->right );
        rotateWithRightChild( k1 );
    }
};

#endif


你可能感兴趣的:(数据结构,算法,C++)