数据结构 实验7~9 二叉树的基本操作和应用

实验项目名称：二叉树的基本操作和应用

实验目的：熟悉树的基本概念，树状结构的逻辑特性、存储表示方法和二叉树的基本操作。

实验要求：熟悉树的基本概念，树状结构的逻辑特性、存储表示方法和树的基本操作，实现二叉树的遍历算法（前序、中序和后序遍历）及其简单应用。

实验内容

编写程序，用二叉链表存储表示方法，实现二叉树的基本操作。

(1) 根据扩展二叉树的前序遍历序列，建立二叉树。

(2) 根据二叉树的前序和中序遍历序列，构造二叉树。

(3) 实现二叉树的前序、中序和后序遍历，输出遍历结果。

#include <iostream>
using namespace std;

struct BiNode
{
    char data;                  //存放数据域
    BiNode *lchild, *rchild;    //遍历左右子树指针
};

class BiTree
{
public:
    BiTree(){root = Creat();}          //构造函数,建立一棵二叉树
    ~BiTree(){Release(root);}          //析构函数,释放各结点的存储空间
    void PreOrder(){PreOrder(root);}   //前序遍历二叉树
    void InOrser(){InOrder(root);}     //中序遍历二叉树
    void PostOrder(){PostOrder(root);} //后序遍历二叉树
    void LevelOrder();                 //层序遍历二叉树
private:
    BiNode* Creat();                   //构造函数调用
    void Release(BiNode *bt);          //析构函数调用
    void PreOrder(BiNode *bt);         //前序遍历函数调用
    void InOrder(BiNode *bt);          //中序遍历函数调用
    void PostOrder(BiNode *bt);        //后序遍历函数调用
    BiNode *root;                      //指向根结点的头指针
};

//构造函数——建立二叉树
BiNode* BiTree::Creat()
{
    BiNode *bt;
    char ch;
    cout << "请输入建立的二叉树（空树用字符#代替)" << endl;
    cin >> ch;                  //输入结点的数据信息,假设为字符
    if(ch == '#') bt = NULL;    //输入字符#表示建立一棵空树
    else{
        bt = new BiNode;
        bt->data = ch;
        bt->lchild = Creat();   //递归建立左子树
        bt->rchild = Creat();   //递归建立右子树
    }
    return bt;
}

//析构函数——销毁二叉树
void BiTree::Release(BiNode *bt)
{
    if(bt == NULL) return;
    else
    {
        Release(bt->lchild);     //释放左子树
        Release(bt->rchild);     //释放右子树
        delete bt;               //释放根结点
    }
}

//前序遍历
void BiTree::PreOrder(BiNode *bt)
{
    if(bt == NULL) return;      //递归调用的结束条件
    else
    {
        cout << bt->data;       //访问根结点bt的数据域
        PreOrder(bt->lchild);   //前序递归遍历bt的左子树
        PreOrder(bt->rchild);   //前序递归遍历bt的右子树
    }
}

//中序遍历
void BiTree::InOrder(BiNode *bt)
{
    if(bt == NULL) return;      //递归调用的结束条件
    else
    {
        InOrder(bt->lchild);    //中序递归遍历bt的左子树
        cout << bt->data;       //访问根结点bt的数据域
        InOrder(bt->rchild);    //中序递归遍历bt的右子树
    }
}

//后序遍历
void BiTree::PostOrder(BiNode *bt)
{
    if(bt == NULL) return;      //递归调用的结束条件
    else
    {
        PostOrder(bt->lchild);  //后序递归遍历bt的左子树
        PostOrder(bt->rchild);  //后序递归遍历bt的右子树
        cout << bt->data;       //访问根结点bt的数据域
    }
}

//层序遍历
void BiTree::LevelOrder()
{
    BiNode *Q[100], *q = NULL;
    int front = -1, rear = -1;  //队列初始化
    if(root == NULL) return;    //二叉树为空,算法结束
    Q[++rear] = root;           //根指针入队
    while(front != rear)        //当队列非空时
    {
        q = Q[++front];         //出队
        cout << q->data;
        if(q->lchild != NULL) Q[++rear] = q->lchild;
        if(q->rchild != NULL) Q[++rear] = q->rchild;
    }
}

int main()
{
    BiTree T;          //定义对象变量T
    cout << "该二叉树的前序遍历序列是：";
    T.PreOrder();
    cout << endl;
    cout << "该二叉树的中序遍历序列是：";
    T.InOrser();
    cout << endl;
    cout << "该二叉树的后序遍历序列是：";
    T.PostOrder();
    cout << endl;
    cout << "该二叉树的层序遍历序列是：";
    T.LevelOrder();
    cout << endl;
    return 0;
}

(4) 哈夫曼树的设计与实现。

/*哈夫曼算法建立最优二叉树*/
#include <iostream>
using namespace std;

//哈夫曼树的结点结构定义
struct ElemType
{
  int weight;                  //假定权值为整数
  int parent, lchild, rchild;  //游标
};

class HuffmanTree
{
public:
	HuffmanTree(int w[ ], int n); //构造n棵只有一个根结点的二叉树
	HuffmanTree( );   //无参构造
	void Print( );
private:
	ElemType *huffTree;
	int num;
	void Select(int n, int &i1, int &i2);
};

void HuffmanTree :: Select(int n, int &i1, int &i2)
{
	int i = 0, temp;
	for (i; i < n; i++)
		if (huffTree[i].parent == -1) {i1 = i; break;}
	for (i = i + 1; i < n; i++)
		if (huffTree[i].parent == -1) {i2 = i; break;}
	if (huffTree[i1].weight > huffTree[i2].weight)
	{
		temp = i1;
		i1 = i2;
		i2 = temp;
	}
	for (i = i + 1; i < n; i++)
	{
		if (huffTree[i].parent == -1)
		{
			if (huffTree[i].weight < huffTree[i1].weight)
			{
				i2 = i1;
                i1 = i;
			}
			else if (huffTree[i].weight < huffTree[i2].weight)
			{
				i2 = i;
			}
		}
	}
}

HuffmanTree :: HuffmanTree(int w[ ], int n)
{
	int i, k, i1, i2;
	huffTree = new ElemType [2*n-1];
	num = n;
	for (i = 0; i < 2*num-1; i++)         //初始化，所有结点均没有双亲和孩子
	{
		huffTree[i].parent = -1;
		huffTree[i].lchild = huffTree[i].rchild = -1;
 	}
  	for (i = 0; i < num; i++)             //存储叶子结点的权值
    	huffTree[i].weight = w[i];
  	for (k = num; k < 2*num-1; k++)       //n-1次合并
  	{
    	Select(k, i1, i2);        //权值最小的根结点下标为i1和i2
		huffTree[k].weight = huffTree[i1].weight + huffTree[i2].weight;
    	huffTree[i1].parent = k; huffTree[i2].parent = k;
    	huffTree[k].lchild = i1; huffTree[k].rchild = i2;
  	}
}

void HuffmanTree :: Print( )
{
	int i, k;
	cout << "每个叶子结点到根结点的路径是:" << endl;
	for (i = 0; i < num; i++)
	{
		cout << huffTree[i].weight;
		k = huffTree[i].parent;
		while (k != -1)
		{
			cout << "-->" << huffTree[k].weight;
			k = huffTree[k].parent;
		}
		cout << endl;
	}
}

int main( )
{
    int n;
    cout << "请输入要构造的权值数n=";
	cin >> n;
	cout << "请输入n个权值:" << endl;
	int w[n]; //含有n个权值的数组
	for(int i = 0; i < n; i++)
    {
        cin >> w[i];
    }
	HuffmanTree T (w, n);
	T.Print();
	return 0;
}