P3/P5 功能：二叉树操作 结构实习作业

最新推荐文章于 2023-04-01 11:20:36 发布
最新推荐文章于 2023-04-01 11:20:36 发布
阅读量1.5k 收藏 20
点赞数 9
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41424132/article/details/81166121
本文介绍了一种二叉树操作的实习作业实现方法，包括树的初始化、遍历、节点交换、查找、删除等功能，并提供了丰富的示例代码，有助于读者理解和掌握二叉树的基本操作。

 有关树的操作的实习作业

为啥我标题写错了。。。现在才发现。。。。

大部分要求的功能呢，老娘都写出来了来着 哈夫曼树那种特别难写分又少的我就没有写 ~_~

但是由于种种不可抗力的原因，我的删除功能是假的 会用0把那个数字换掉

因为我搜索函数是独立出来的  指针是用函数互相传的 然后就有一个结果，我不能动我的原☞针 ，只能动它指向的数据...

据说传递一个*&就可以了但是我没有学会 或者找指针的工作不用外面的函数，delete里面自己写就可以的，各位大神自己写吧

 

 界面

 coffee是一个小彩蛋 （￣︶￣）↗　

w : 输出一个 map.txt --like this:

q: 输出一个 test.txt --like this:

源码：

/*
	源文件名：P5.cpp
	功能：二叉树操作
*/
#include <iostream>
#include <iomanip>
#include <conio.h>
#include <stdio.h>
#include <process.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <stack>
#include <queue>
using namespace std;
 struct BiTNode        //二叉树结点类型
{
	int data;         //数据
		int tem1,tem2;    //辅助数据（实习题不用）
	BiTNode *left=NULL;    //左子树指针
	BiTNode *right=NULL;   //右子树指针
};
//放置全局变量的位置
#define max 100
int leaves = 0;
BiTNode MYTREE;
BiTNode *Tree;      //本程序操作的二叉树根指针
int elem[max];        //存放原始数据
//放置函数声明的位置
void wait(){
	cout << "\n请按任意键继续\n" << flush;
	getch();
}
void generate(BiTNode *Tree);
void show_in_order(BiTNode *T);
void leaf(BiTNode *T);
void deep(BiTNode * root);
void Exchange(BiTNode *bt);
void CreateTree(BiTNode *T);
void sbtree(BiTNode*Tree);
void coffee();
BiTNode *init1();
void showBinTree(BiTNode *Tree);
void findintree(BiTNode *T);
void del_it(BiTNode *T);
void preOrder2(BiTNode *root);
void leveOrder(BiTNode *root);
void printTree(BiTNode *t,int space);
void GuangYi(BiTNode *T);
void write_in_3_order(BiTNode *T);
int main()
{
	Tree = &MYTREE;
	MYTREE.left=NULL;
	MYTREE.right=NULL;
	char choice;


	while (1)
	{
		system("cls");
		cout << "\n\n\n\n";
		cout << "\t\t              单链表操作  \n";
		cout << "\t\t======================================";
		cout << "\n\n";
		cout << "\t\t             1：初始化 (随机)     \n";
		cout << "\t\t             2：coffee      \n";
		cout << "\t\t             3：分别先序、中序、后序遍历二叉树   \n";
		cout << "\t\t             4：叶子结点的数目       \n";
		cout << "\t\t             5：树的深度        \n";
		cout << "\t\t             6: 有结点的左、右子树相互交换       \n";
		cout << "\t\t             7: 用数组elem随机数序列，生成二叉排序树     \n";
		cout << "\t\t             8: 排序树中查找结点    \n";
		cout << "\t\t             9: 排序树中删除结点    \n";
		cout << "\t\t========================================pro	     \n";
		cout << "\t\t             z：不用递归，先序遍历       \n";
		cout << "\t\t             x：从根结点开始，逐层从左到右输出各结点      \n";
		cout << "\t\t             c：凹入表示法的表示        \n";
		cout << "\t\t             v：广义表示法的表示        \n";
		cout << "\t\t             w：输出到文件里(MAP)        \n";
		cout << "\t\t             q：输出到文件里(三序)      \n";
		cout << "\t\t             0：退出        \n";
		cout << "\n";
		cout << "\t\t请选择：" << flush;

		choice = getch();
		system("cls");

		switch(choice)
		{
			case '1':
			Tree = init1();
				break;
			case '2':
      coffee();
				break;
			case '3':
			show_in_order(Tree);
				break;
			case '4':
			leaf(Tree);
				break;
			case '5':
			deep(Tree);
				break;
										case '0':
											exit(0);
			case '6':
			cout<<"如果要查看效果,请分别在运行本功能前后生成MAP\n"<<endl;
			Exchange(Tree);
					break;

			case '7':
			sbtree(Tree);
							break;
			case '8':
			findintree(Tree);
			wait();
					           break;
			case '9':
			del_it(Tree);
			               break;
			case 'z':
			preOrder2(Tree);
			wait();
											break;
			case 'w':
			showBinTree(Tree);
			break;
			case 'x':
			leveOrder(Tree);
			wait();
			break;
			case'c':
			printTree(Tree,1);
			wait();
			break;
			case 't':
			generate(Tree);// 测试用 画好的树
			break;
			case 'v':
			GuangYi(Tree);
			wait();
			break;
			case 'q':
			write_in_3_order(Tree);
			wait();
			break;
		}
	}
}
void BENULL(BiTNode *T)     //用来把儿子指向变成null
{
	T->left=NULL;
	T->right=NULL;
}
//三种排序的输出
void Preorder(BiTNode *T)
{
	if(T)
	{
		if(T->data==NULL);
		else{printf("%d ",T->data);}	/*访问结点*/
		Preorder(T->left);
		Preorder(T->right);
	}
}
void Postorder(BiTNode *T)
{
	if(T)
	{
		Postorder(T->left);
		Postorder(T->right);
		if(T->data==NULL);
		else{printf("%d ",T->data);}	/*访问结点*/
	}
}
void Inorder(BiTNode *T)
{
	if(T)
	{
		Inorder(T->left);
		if(T->data==NULL);
		else{printf("%d ",T->data);}	/*访问结点*/
		Inorder(T->right);
	}
}
void show_in_order(BiTNode *T)
{
	cout<<"\n先序遍历:"<<endl;Preorder(T);
	cout<<"\n中序遍历:"<<endl;Inorder(T);
	cout<<"\n后序遍历:"<<endl;Postorder(T);
	wait();
}
//查找叶子节点
void count_leaf(BiTNode *T )
{
  if(T)
  {
    if(T->left==NULL&&NULL==T->right){leaves++;return;}
    count_leaf(T->left);
    count_leaf(T->right);
  }
}
void leaf(BiTNode *T)
{
	count_leaf(T);
	cout<<"叶子节点的总数:"<<leaves<<endl;
	leaves = 0;//计数器归零
	wait();
}
//深度
int depth(BiTNode * root)
{
 int rdepth=0; //根节点深度
int lval=0; //左子树深度
int rval=0; //右子树深度
 if(!root)   //当到达叶子节点的左子树或右子树或整棵树为空树时
	 {
		rdepth=0;
	 }
 else
    {
    lval=depth(root->left);//遍历左子树
    rval=depth(root->right); //遍历右子树

    rdepth=1+(lval>rval?lval:rval);
    }

  return rdepth;
}
void deep(BiTNode * root)
{
  int x;
  x=depth(root);
    cout <<"深度是"<<x<<endl;
		wait();
}
//交换左右
void do_Exchange(BiTNode *bt)
{
    BiTNode *temp;
    if(bt){
        temp = bt -> left;
        bt -> left = bt -> right;
        bt -> right = temp;
        do_Exchange(bt -> left);
        do_Exchange(bt -> right);
    }
}
void Exchange(BiTNode *bt)
{
	do_Exchange(bt);
	cout<<"左右交换已经完成"<<flush;
	wait();
}
//gengrate
void generate(BiTNode *Tree)
{
  cout<<"rrrrrrrrrrrrrrrrrrrrrrrrrrrr"<<endl;
  BiTNode *t;
  t= Tree;
	t->data = 11;

	t->left =(BiTNode*) malloc(sizeof(BiTNode));
	t->left->data=22;
	BENULL(t->left);
	t->right=(BiTNode*) malloc(sizeof(BiTNode));
	t->right->data = 33;
  BENULL(	t->right);
	t->left->left =(BiTNode*) malloc(sizeof(BiTNode));
	t->left->left->data=44;
	BENULL(t->left->left);
	t->right->left=(BiTNode*) malloc(sizeof(BiTNode));
	t->right->left->data=55;
	BENULL(t->right->left);
	t->right->right=(BiTNode*) malloc(sizeof(BiTNode));
	t->right->right->data=66;
	BENULL(t->right->right);
	wait();
}
BiTNode *Generate(int n)
{
	int nl;
	if (n==0)
		return NULL;

	BiTNode *P = new BiTNode;
	P->data = rand() % 999 +1;
	nl=rand() % (n);
	P->left = Generate(nl);
	P->right = Generate(n-1-nl);
	return P;
}
BiTNode *init1()
{
	int i,n;

	while (1)
	{
	    cout << "输入数据个数（0－" << max-1 << "）：" << flush;
		cin >> n;
		if (n >= 0 && n <= max-1)
			break;
		cout << endl;
	}
	while (1)
	{
	    cout << "输入随机数种子（0－32767）：" << flush;
		cin >> i;
		if (i >= 0 && i <= 32767)
			break;
		cout << endl;
	}
	srand(i);  //指定随机数种子，相同的种子将产生相同的数据序列
	rand();

//	release(Tree);
	return Generate (n);
}
void getWidth(BiTNode *Tree, int depth, int shift, char map[max*2][max*2])
{
	int i;

	if (Tree->left != NULL)
	{
		getWidth(Tree->left, depth+1, shift, map);
		Tree->tem1 = Tree->left->tem1 + Tree->left->tem2 + 1;
		for (i=(Tree->left->tem1+shift)*2; i<shift*2; i=i+2)
		{
			map[depth*2+1][i]='-';
			map[depth*2+1][i+1]='-';
		}
	}
	else Tree->tem1 = 0;
	if (Tree->right != NULL)
	{
		getWidth(Tree->right, depth+1, shift+Tree->tem1+1, map);
		Tree->tem2 = Tree->right->tem1 + Tree->right->tem2 + 1;
	}
	else Tree->tem2 = 0;

	for (i=shift*2; i<(Tree->tem1+shift)*2; i++)
		map[depth*2][i]=' ';

	map[depth*2][(Tree->tem1+shift)*2]=(char)(Tree->data / 1000 +48);
	map[depth*2][(Tree->tem1+shift)*2+1]=(char)(Tree->data / 100 % 10 +48);
	map[depth*2][(Tree->tem1+shift)*2+2]=(char)(Tree->data / 10 % 10 +48);
	map[depth*2][(Tree->tem1+shift)*2+3]=(char)(Tree->data %10 +48);
	if (Tree->data<1000)
	{
		map[depth*2][(Tree->tem1+shift)*2]=' ';
		if (Tree->data<100)
		{
			map[depth*2][(Tree->tem1+shift)*2+1]=map[depth*2][(Tree->tem1+shift)*2+2];
			map[depth*2][(Tree->tem1+shift)*2+2]=map[depth*2][(Tree->tem1+shift)*2+3];
			map[depth*2][(Tree->tem1+shift)*2+3]=' ';
			if (Tree->data<10)
				map[depth*2][(Tree->tem1+shift)*2+1]=' ';
		}
	}

	if (Tree->left != NULL)
	{
		map[depth*2+1][(Tree->left->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->left->tem1+shift)*2+2]=(char)0xb0;
		map[depth*2+1][(Tree->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+shift)*2+2]=(char)0xbc;
		for (i=(Tree->left->tem1+shift)*2+3; i<(Tree->tem1+shift)*2; i=i+2)
		{
			map[depth*2+1][i]=(char)0xa9;
			map[depth*2+1][i+1]=(char)0xa4;
		}
	}
	if (Tree->right != NULL)
	{
		map[depth*2+1][(Tree->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+shift)*2+2]=(char)0xb8;
		map[depth*2+1][(Tree->tem1+Tree->right->tem1+shift)*2+3]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+Tree->right->tem1+shift)*2+4]=(char)0xb4;
		for (i=(Tree->tem1+shift)*2+3; i<(Tree->tem1+Tree->right->tem1+shift)*2+2; i=i+2)
		{
			map[depth*2+1][i]=(char)0xa9;
			map[depth*2+1][i+1]=(char)0xa4;
		}
	}
	if (Tree->left != NULL && Tree->right != NULL)
	{
		map[depth*2+1][(Tree->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+shift)*2+2]=(char)0xd8;
	}

}
void showBinTree(BiTNode *Tree)
{
	char map[max*2][max*2];
	FILE *f;
	int i,j,k;

	f=fopen("Map.txt","w");
	if (Tree == NULL)
	{
		fprintf(f,"空树");
		fclose(f);
		return;
	}
	for (i=0; i<max*2; i++)
		for (j=0; j<max*2; j++)
			map[i][j]=' ';
	getWidth(Tree,0,0,map);
	for (i=0; i<max*2; i++)
	{
		k=max*2-1;
		while (k>=0 && map[i][k]==' ')
			k--;

		for (j=0; j<=k; j++)
			fprintf(f,"%c",map[i][j]);
		fprintf(f,"\n");
//		if (k<0)
//			break;
	}
	fclose(f);
}

//elem
void radom_elem(int list[])
{
	int i,n;
	while (1)
	{
	    cout << "输入数据个数（0－" << max-1 << "）：" << flush;
		cin >> n;
		if (n >= 0 && n <= max-1)
			break;
		cout << endl;
	}
	while (1)
	{
	    cout << "输入随机数种子（0－32767）：" << flush;
		cin >> i;
		if (i >= 0 && i <= 32767)
			break;
		cout << endl;
	}
	srand(i);  //指定随机数种子，相同的种子将产生相同的数据序列
	rand();

	for (i = 0; i < n; i++)
	{
		list[i] = rand() % 999 +1;
	}
	list[n] = 0;
}
void insertNode(BiTNode*t,int key)
{
	BiTNode*p,*Parent,*Head;
	p=new BiTNode;
	p->data=key;
	BENULL(p);

	Head=t;
	while(Head)
	{
				Parent=Head;
				if(key<Head->data)
							Head=Head->left;
				else
			Head=Head->right;
	}
	if(key<Parent->data)   //注意不是head，一定要用Parent个连接
		Parent->left=p; //连接节点  //新值小于根节点，连接在左子树，否则连接在右子树
	else
		Parent->right=p;
}
void Sort_tree(BiTNode*t)
{
	t->data=elem[0];
	BENULL(t);
	int i;
	for(i=1;elem[i]!=0;i++)
	{
		insertNode(t,elem[i]);
	}
}
void sbtree(BiTNode*Tree){
    cout<<"生成elem[]"<<endl;
		radom_elem(elem);
    Sort_tree(Tree);
		cout<<"bstree完成"<<endl;
  	show_in_order(Tree);
	}

//find
BiTNode *W,*K,*kroot;
int min_k=100000;
void find(BiTNode *T,int key)
{
	if(T)
	{
		find(T->left,key);
		if(key==T->data)
			{
				W=T;
			}
		find(T->right,key);
	}
}

void findintree(BiTNode *T)
{
	cout<<"输入要查找到key:"<<flush;
	int n;
	cin>>n;
	W=NULL;
	find(T,n);
	if(W==NULL)printf("树中没有要查找的数字\n" );
	else
	 printf("树中有该数字,指针:%p\n",&W );
}

void find_min(BiTNode *T)
{
	cout<<"entered min"<<endl;
	if(T)
	{
			if(min_k>T->data)
				{
					cout<<"swap>-<"<<endl;
					min_k=T->data;
					K=T;
				}
		find_min(T->left);
		find_min(T->right);
	}
}
void del_ing(BiTNode *&kill)
{
	if(kill->left==NULL&&kill->right==NULL)
	{
			kill->data=0;
	}

	else if(NULL==kill->right)
	{
		kill->data=0;
	  kill=kill->left;
	}
		else
		{
			find_min(kill->right);
			cout<<"minbac K="<<K->data<<endl;
			kill->data = K->data;
			K->data=0;
		}
}
void del_it(BiTNode *T)
{
			printf("PS:我输出了一些方便我调试的东西 请多见谅\n" );
		cout<<"输入要del的key:"<<flush;
		int n;
		cin>>n;
		W=NULL;
		find(T,n);
		if(W==NULL)printf("树中没有要del的数字\n" );

		else
		{
			printf("deleting^^^\n" );
			K=NULL;
			kroot=NULL;
			del_ing(W);
		}
		printf("=====================DELETE COMPLETE\n" );
		show_in_order(Tree);
}
//
void preOrder2(BiTNode *root)     //非递归前序遍历
{
	  stack<BiTNode*>s;
    BiTNode *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            cout<<p->data<<" ";
            s.push(p);
            p=p->left;
        }
        if(!s.empty())
        {
            p=s.top();
            s.pop();
            p=p->right;
        }
    }
}
//
void leveOrder(BiTNode *root)
{
	  queue<BiTNode*>s;
    BiTNode *disp,*p=root;
		s.push(p);
  		while (!s.empty())
				{
					disp=s.front();
					s.pop();
					cout<<disp->data<<" "<<flush;
					if(p->left)s.push(p->left);
					if(p->right)s.push(p->right);
					p=s.front();
				}
}
//
void printTree(BiTNode *t,int space)
{
    /*如果为空树，return；*/
    if(t==NULL) return ;
    /*输出根*/
    int i,j,k;
    for(i=0;i<space;i++) printf(" ");
    printf("%d\n",t->data);
    /*输出子树*/
    if(t->left)printTree(t->left,space+3);
		if(t->right)printTree(t->right,space+3);
}
//
void GuangYi(BiTNode *T)
{
	if(T)
	{
		if(T->data==NULL);
		else{printf("%d ",T->data);}	/*访问结点*/
		cout<<"("<<flush;
		GuangYi(T->left);
		GuangYi(T->right);
		cout<<")"<<flush;
	}
}
//
void wPreorder(BiTNode *T,FILE *&fp)
{
	if(T)
	{
		if(T->data==NULL);
		else{fprintf(fp,"%d ",T->data);}	/*访问结点*/
		wPreorder(T->left,fp);
		wPreorder(T->right,fp);
	}
}
void wPostorder(BiTNode *T,FILE *&fp)
{
	if(T)
	{
		wPostorder(T->left,fp);
		wPostorder(T->right,fp);
		if(T->data==NULL);
		else{fprintf(fp,"%d ",T->data);}	/*访问结点*/
	}
}
void wInorder(BiTNode *T,FILE *&fp)
{
	if(T)
	{
		wInorder(T->left,fp);
		if(T->data==NULL);
		else{fprintf(fp,"%d ",T->data);}	/*访问结点*/
		wInorder(T->right,fp);
	}
}
void write_in_3_order(BiTNode *T)
{
	cout<<"在同一文件夹下的test.txt将会被写入"<<endl;
	FILE *fp = NULL;
	fp = fopen("test.txt", "w+");
	fprintf(fp,"\nPREorder  :");
  wPreorder(Tree,fp);
	fprintf(fp,"\nINorder    :");
	wInorder(Tree,fp);
	fprintf(fp,"\nPOSTorder:");
	wPostorder(Tree,fp);
	fclose(fp);
	cout<<"写--入--完--成--"<<endl;
}








void coffee()
{
cout<<
"					       _==/          i     i          \==_             \n"
"					     /XX/            |\___/|            \XX\           \n"
"					   /XXXX\            |XXXXX|            /XXXX\             \n"
"					  |XXXXXX\_         _XXXXXXX_         _/XXXXXX|            \n"
"					 XXXXXXXXXXXxxxxxxxXXXXXXXXXXXxxxxxxxXXXXXXXXXXX             \n"
"					|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|             \n"
"					XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX             \n"
"					|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|             \n"
"					 XXXXXX/^^^^^\XXXXXXXXXXXXXXXXXXXXX/^^^^^\XXXXXX             \n"
"					  |XXX|       \XXX/^^\XXXXX/^^\XXX/       |XXX|             \n"
"					      \XX\       \X/    \XXX/    \X/       /XX/             \n"
"		    			       *\       *      \X/      *      /*               \n "<<endl;
			wait();}

 老师提供了一个bint.h 

可以输出 W 那种树 挺厉害的 我是写不来 就直接用了；

 

附上BINT.h

//屏幕提示后，从键盘输入个数和随机数种子，在数组elem中生成指定个数的数据，供其他程序使用，0表示数据结束
void init0(int list[])
{
	int i,n;
	while (1)
	{
	    cout << "输入数据个数（0－" << max-1 << "）：" << flush;
		cin >> n;
		if (n >= 0 && n <= max-1)
			break;
		cout << endl;
	}
	while (1)
	{
	    cout << "输入随机数种子（0－32767）：" << flush;
		cin >> i;
		if (i >= 0 && i <= 32767)
			break;
		cout << endl;
	}
	srand(i);  //指定随机数种子，相同的种子将产生相同的数据序列
	rand();

	for (i = 0; i < n; i++)
	{
		list[i] = rand() % 999 +1;
	}
	list[n] = 0;
}

void getWidth(BiTNode *Tree, int depth, int shift, char map[max*2][max*2])
{
	int i;

	if (Tree->left != NULL)
	{
		getWidth(Tree->left, depth+1, shift, map);
		Tree->tem1 = Tree->left->tem1 + Tree->left->tem2 + 1;
		for (i=(Tree->left->tem1+shift)*2; i<shift*2; i=i+2)
		{
			map[depth*2+1][i]='-';
			map[depth*2+1][i+1]='-';
		}
	}
	else Tree->tem1 = 0;
	if (Tree->right != NULL)
	{
		getWidth(Tree->right, depth+1, shift+Tree->tem1+1, map);
		Tree->tem2 = Tree->right->tem1 + Tree->right->tem2 + 1;
	}
	else Tree->tem2 = 0;

	for (i=shift*2; i<(Tree->tem1+shift)*2; i++)
		map[depth*2][i]=' ';
	
	map[depth*2][(Tree->tem1+shift)*2]=(char)(Tree->data / 1000 +48);
	map[depth*2][(Tree->tem1+shift)*2+1]=(char)(Tree->data / 100 % 10 +48);
	map[depth*2][(Tree->tem1+shift)*2+2]=(char)(Tree->data / 10 % 10 +48);
	map[depth*2][(Tree->tem1+shift)*2+3]=(char)(Tree->data %10 +48);
	if (Tree->data<1000)
	{
		map[depth*2][(Tree->tem1+shift)*2]=' ';
		if (Tree->data<100)
		{
			map[depth*2][(Tree->tem1+shift)*2+1]=map[depth*2][(Tree->tem1+shift)*2+2];
			map[depth*2][(Tree->tem1+shift)*2+2]=map[depth*2][(Tree->tem1+shift)*2+3];
			map[depth*2][(Tree->tem1+shift)*2+3]=' ';
			if (Tree->data<10)
				map[depth*2][(Tree->tem1+shift)*2+1]=' ';
		}
	}

	if (Tree->left != NULL)
	{
		map[depth*2+1][(Tree->left->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->left->tem1+shift)*2+2]=(char)0xb0;
		map[depth*2+1][(Tree->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+shift)*2+2]=(char)0xbc;
		for (i=(Tree->left->tem1+shift)*2+3; i<(Tree->tem1+shift)*2; i=i+2)
		{
			map[depth*2+1][i]=(char)0xa9;
			map[depth*2+1][i+1]=(char)0xa4;
		}
	}
	if (Tree->right != NULL)
	{
		map[depth*2+1][(Tree->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+shift)*2+2]=(char)0xb8;
		map[depth*2+1][(Tree->tem1+Tree->right->tem1+shift)*2+3]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+Tree->right->tem1+shift)*2+4]=(char)0xb4;
		for (i=(Tree->tem1+shift)*2+3; i<(Tree->tem1+Tree->right->tem1+shift)*2+2; i=i+2)
		{
			map[depth*2+1][i]=(char)0xa9;
			map[depth*2+1][i+1]=(char)0xa4;
		}
	}
	if (Tree->left != NULL && Tree->right != NULL)
	{
		map[depth*2+1][(Tree->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+shift)*2+2]=(char)0xd8;
	}

}

//生成文件Map.txt，显示以Tree为根指针的二叉树
void showBinTree(BiTNode *Tree)
{
	char map[max*2][max*2];
	FILE *f;
	int i,j,k;

	f=fopen("Map.txt","w");
	if (Tree == NULL)
	{
		fprintf(f,"空树");
		fclose(f);
		return;
	}
	for (i=0; i<max*2; i++)
		for (j=0; j<max*2; j++)
			map[i][j]=' ';
	getWidth(Tree,0,0,map);
	for (i=0; i<max*2; i++)
	{
		k=max*2-1; 
		while (k>=0 && map[i][k]==' ')
			k--;

		for (j=0; j<=k; j++)
			fprintf(f,"%c",map[i][j]);
		fprintf(f,"\n");
//		if (k<0)
//			break;
	}
	fclose(f);
}

//供init1O调用的释放函数
void release(BiTNode *Tree)
{
	if (Tree==NULL)
		return;
	release(Tree->left);
	release(Tree->right);
	free(Tree);
}

//供init1调用的生成函数
BiTNode *Generate(int n)
{
	int nl;
	if (n==0)
		return NULL;

	BiTNode *P = new BiTNode;
	P->data = rand() % 999 +1;
	nl=rand() % (n);
	P->left = Generate(nl);
	P->right = Generate(n-1-nl);
	return P;
}

//屏幕提示后，从键盘输入个数和随机数种子，以Tree为根指针，生成指定结点个数的二叉树，供其他程序使用，同时生成文件Map.txt，显示这课二叉树
BiTNode *init1()
{
	int i,n;

	while (1)
	{
	    cout << "输入数据个数（0－" << max-1 << "）：" << flush;
		cin >> n;
		if (n >= 0 && n <= max-1)
			break;
		cout << endl;
	}
	while (1)
	{
	    cout << "输入随机数种子（0－32767）：" << flush;
		cin >> i;
		if (i >= 0 && i <= 32767)
			break;
		cout << endl;
	}
	srand(i);  //指定随机数种子，相同的种子将产生相同的数据序列
	rand();

//	release(Tree);
	return Generate (n);
}

 

p3--for VC6.0

ps:因为老师只会vc 老娘只能给改出来一个特别版本，献给同样老师是老顽固 VC6使用者的孩子们：

/*
	源文件名：P5.cpp
	功能：二叉树操作
*/
#include <iostream>
#include <iomanip>
#include <conio.h>
#include <stdio.h>
#include <process.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <stack>
#include <queue>
using namespace std;
 struct BiTNode        //二叉树结点类型
{
	int data;         //数据
		int tem1,tem2;    //辅助数据（实习题不用）
	BiTNode *left;    //左子树指针
	BiTNode *right;   //右子树指针
};
//放置全局变量的位置
#define max 100
int leaves = 0;
BiTNode MYTREE;
BiTNode *Tree;      //本程序操作的二叉树根指针
int elem[max];        //存放原始数据
//放置函数声明的位置
void wait(){
	cout << "\n请按任意键继续\n" << flush;
	getch();
}
void generate(BiTNode *Tree);
void show_in_order(BiTNode *T);
void leaf(BiTNode *T);
void deep(BiTNode * root);
void Exchange(BiTNode *bt);
void CreateTree(BiTNode *T);
void sbtree(BiTNode*Tree);
void coffee();
BiTNode *init1();
void showBinTree(BiTNode *Tree);
void findintree(BiTNode *T);
void del_it(BiTNode *T);
void preOrder2(BiTNode *root);
void leveOrder(BiTNode *root);
void printTree(BiTNode *t,int space);
void GuangYi(BiTNode *T);
void write_in_3_order(BiTNode *T);
void main()
{
	Tree = &MYTREE;
	MYTREE.left=NULL;
	MYTREE.right=NULL;
	char choice;


	while (1)
	{
		system("cls");
		cout << "\n\n\n\n";
		cout << "\t\t              单链表操作  \n";
		cout << "\t\t======================================";
		cout << "\n\n";
		cout << "\t\t             1：初始化 (随机)     \n";
		cout << "\t\t             2：coffee      \n";
		cout << "\t\t             3：分别先序、中序、后序遍历二叉树   \n";
		cout << "\t\t             4：叶子结点的数目       \n";
		cout << "\t\t             5：树的深度        \n";
		cout << "\t\t             6: 有结点的左、右子树相互交换       \n";
		cout << "\t\t             7: 用数组elem随机数序列，生成二叉排序树     \n";
		cout << "\t\t             8: 排序树中查找结点    \n";
		cout << "\t\t             9: 排序树中删除结点    \n";
		cout << "\t\t========================================pro	     \n";
		cout << "\t\t             z：不用递归，先序遍历       \n";
		cout << "\t\t             x：从根结点开始，逐层从左到右输出各结点      \n";
		cout << "\t\t             c：凹入表示法的表示        \n";
		cout << "\t\t             v：广义表示法的表示        \n";
		cout << "\t\t             w：输出到文件里(MAP)        \n";
		cout << "\t\t             q：输出到文件里(三序)      \n";
		cout << "\t\t             0：退出        \n";
		cout << "\n";
		cout << "\t\t请选择：" << flush;

		choice = getch();
		system("cls");

		switch(choice)
		{
			case '1':
			Tree = init1();
				break;
			case '2':
      coffee();
				break;
			case '3':
			show_in_order(Tree);
				break;
			case '4':
			leaf(Tree);
				break;
			case '5':
			deep(Tree);
				break;
										case '0':
											exit(0);
			case '6':
			cout<<"如果要查看效果,请分别在运行本功能前后生成MAP\n"<<endl;
			Exchange(Tree);
					break;

			case '7':
			sbtree(Tree);
							break;
			case '8':
			findintree(Tree);
			wait();
					           break;
			case '9':
			del_it(Tree);
			               break;
			case 'z':
			preOrder2(Tree);
			wait();
											break;
			case 'w':
			showBinTree(Tree);
			break;
			case 'x':
			leveOrder(Tree);
			wait();
			break;
			case'c':
			printTree(Tree,1);
			wait();
			break;
			case 't':
			generate(Tree);// 测试用 画好的树
			break;
			case 'v':
			GuangYi(Tree);
			wait();
			break;
			case 'q':
			write_in_3_order(Tree);
			wait();
			break;
		}
	}
}
void BENULL(BiTNode *T)     //用来把儿子指向变成null
{
	T->left=NULL;
	T->right=NULL;
}
//三种排序的输出
void Preorder(BiTNode *T)
{
	if(T)
	{
		if(T->data==NULL);
		else{printf("%d ",T->data);}	/*访问结点*/
		Preorder(T->left);
		Preorder(T->right);
	}
}
void Postorder(BiTNode *T)
{
	if(T)
	{
		Postorder(T->left);
		Postorder(T->right);
		if(T->data==NULL);
		else{printf("%d ",T->data);}	/*访问结点*/
	}
}
void Inorder(BiTNode *T)
{
	if(T)
	{
		Inorder(T->left);
		if(T->data==NULL);
		else{printf("%d ",T->data);}	/*访问结点*/
		Inorder(T->right);
	}
}
void show_in_order(BiTNode *T)
{
	cout<<"\n先序遍历:"<<endl;Preorder(T);
	cout<<"\n中序遍历:"<<endl;Inorder(T);
	cout<<"\n后序遍历:"<<endl;Postorder(T);
	wait();
}
//查找叶子节点
void count_leaf(BiTNode *T )
{
  if(T)
  {
    if(T->left==NULL&&NULL==T->right){leaves++;return;}
    count_leaf(T->left);
    count_leaf(T->right);
  }
}
void leaf(BiTNode *T)
{
	count_leaf(T);
	cout<<"叶子节点的总数:"<<leaves<<endl;
	leaves = 0;//计数器归零
	wait();
}
//深度
int depth(BiTNode * root)
{
 int rdepth=0; //根节点深度
int lval=0; //左子树深度
int rval=0; //右子树深度
 if(!root)   //当到达叶子节点的左子树或右子树或整棵树为空树时
	 {
		rdepth=0;
	 }
 else
    {
    lval=depth(root->left);//遍历左子树
    rval=depth(root->right); //遍历右子树

    rdepth=1+(lval>rval?lval:rval);
    }

  return rdepth;
}
void deep(BiTNode * root)
{
  int x;
  x=depth(root);
    cout <<"深度是"<<x<<endl;
		wait();
}
//交换左右
void do_Exchange(BiTNode *bt)
{
    BiTNode *temp;
    if(bt){
        temp = bt -> left;
        bt -> left = bt -> right;
        bt -> right = temp;
        do_Exchange(bt -> left);
        do_Exchange(bt -> right);
    }
}
void Exchange(BiTNode *bt)
{
	do_Exchange(bt);
	cout<<"左右交换已经完成"<<flush;
	wait();
}
//gengrate
void generate(BiTNode *Tree)
{
  cout<<"rrrrrrrrrrrrrrrrrrrrrrrrrrrr"<<endl;
  BiTNode *t;
  t= Tree;
	t->data = 11;

	t->left =(BiTNode*) malloc(sizeof(BiTNode));
	t->left->data=22;
	BENULL(t->left);
	t->right=(BiTNode*) malloc(sizeof(BiTNode));
	t->right->data = 33;
  BENULL(	t->right);
	t->left->left =(BiTNode*) malloc(sizeof(BiTNode));
	t->left->left->data=44;
	BENULL(t->left->left);
	t->right->left=(BiTNode*) malloc(sizeof(BiTNode));
	t->right->left->data=55;
	BENULL(t->right->left);
	t->right->right=(BiTNode*) malloc(sizeof(BiTNode));
	t->right->right->data=66;
	BENULL(t->right->right);
	wait();
}
BiTNode *Generate(int n)
{
	int nl;
	if (n==0)
		return NULL;

	BiTNode *P = new BiTNode;
	P->data = rand() % 999 +1;
	nl=rand() % (n);
	P->left = Generate(nl);
	P->right = Generate(n-1-nl);
	return P;
}
BiTNode *init1()
{
	int i,n;

	while (1)
	{
	    cout << "输入数据个数（0－" << max-1 << "）：" << flush;
		cin >> n;
		if (n >= 0 && n <= max-1)
			break;
		cout << endl;
	}
	while (1)
	{
	    cout << "输入随机数种子（0－32767）：" << flush;
		cin >> i;
		if (i >= 0 && i <= 32767)
			break;
		cout << endl;
	}
	srand(i);  //指定随机数种子，相同的种子将产生相同的数据序列
	rand();

//	release(Tree);
	return Generate (n);
}
void getWidth(BiTNode *Tree, int depth, int shift, char map[max*2][max*2])
{
	int i;

	if (Tree->left != NULL)
	{
		getWidth(Tree->left, depth+1, shift, map);
		Tree->tem1 = Tree->left->tem1 + Tree->left->tem2 + 1;
		for (i=(Tree->left->tem1+shift)*2; i<shift*2; i=i+2)
		{
			map[depth*2+1][i]='-';
			map[depth*2+1][i+1]='-';
		}
	}
	else Tree->tem1 = 0;
	if (Tree->right != NULL)
	{
		getWidth(Tree->right, depth+1, shift+Tree->tem1+1, map);
		Tree->tem2 = Tree->right->tem1 + Tree->right->tem2 + 1;
	}
	else Tree->tem2 = 0;

	for (i=shift*2; i<(Tree->tem1+shift)*2; i++)
		map[depth*2][i]=' ';

	map[depth*2][(Tree->tem1+shift)*2]=(char)(Tree->data / 1000 +48);
	map[depth*2][(Tree->tem1+shift)*2+1]=(char)(Tree->data / 100 % 10 +48);
	map[depth*2][(Tree->tem1+shift)*2+2]=(char)(Tree->data / 10 % 10 +48);
	map[depth*2][(Tree->tem1+shift)*2+3]=(char)(Tree->data %10 +48);
	if (Tree->data<1000)
	{
		map[depth*2][(Tree->tem1+shift)*2]=' ';
		if (Tree->data<100)
		{
			map[depth*2][(Tree->tem1+shift)*2+1]=map[depth*2][(Tree->tem1+shift)*2+2];
			map[depth*2][(Tree->tem1+shift)*2+2]=map[depth*2][(Tree->tem1+shift)*2+3];
			map[depth*2][(Tree->tem1+shift)*2+3]=' ';
			if (Tree->data<10)
				map[depth*2][(Tree->tem1+shift)*2+1]=' ';
		}
	}

	if (Tree->left != NULL)
	{
		map[depth*2+1][(Tree->left->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->left->tem1+shift)*2+2]=(char)0xb0;
		map[depth*2+1][(Tree->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+shift)*2+2]=(char)0xbc;
		for (i=(Tree->left->tem1+shift)*2+3; i<(Tree->tem1+shift)*2; i=i+2)
		{
			map[depth*2+1][i]=(char)0xa9;
			map[depth*2+1][i+1]=(char)0xa4;
		}
	}
	if (Tree->right != NULL)
	{
		map[depth*2+1][(Tree->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+shift)*2+2]=(char)0xb8;
		map[depth*2+1][(Tree->tem1+Tree->right->tem1+shift)*2+3]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+Tree->right->tem1+shift)*2+4]=(char)0xb4;
		for (i=(Tree->tem1+shift)*2+3; i<(Tree->tem1+Tree->right->tem1+shift)*2+2; i=i+2)
		{
			map[depth*2+1][i]=(char)0xa9;
			map[depth*2+1][i+1]=(char)0xa4;
		}
	}
	if (Tree->left != NULL && Tree->right != NULL)
	{
		map[depth*2+1][(Tree->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+shift)*2+2]=(char)0xd8;
	}

}
void showBinTree(BiTNode *Tree)
{
	char map[max*2][max*2];
	FILE *f;
	int i,j,k;

	f=fopen("Map.txt","w");
	if (Tree == NULL)
	{
		fprintf(f,"空树");
		fclose(f);
		return;
	}
	for (i=0; i<max*2; i++)
		for (j=0; j<max*2; j++)
			map[i][j]=' ';
	getWidth(Tree,0,0,map);
	for (i=0; i<max*2; i++)
	{
		k=max*2-1;
		while (k>=0 && map[i][k]==' ')
			k--;

		for (j=0; j<=k; j++)
			fprintf(f,"%c",map[i][j]);
		fprintf(f,"\n");
//		if (k<0)
//			break;
	}
	fclose(f);
}

//elem
void radom_elem(int list[])
{
	int i,n;
	while (1)
	{
	    cout << "输入数据个数（0－" << max-1 << "）：" << flush;
		cin >> n;
		if (n >= 0 && n <= max-1)
			break;
		cout << endl;
	}
	while (1)
	{
	    cout << "输入随机数种子（0－32767）：" << flush;
		cin >> i;
		if (i >= 0 && i <= 32767)
			break;
		cout << endl;
	}
	srand(i);  //指定随机数种子，相同的种子将产生相同的数据序列
	rand();

	for (i = 0; i < n; i++)
	{
		list[i] = rand() % 999 +1;
	}
	list[n] = 0;
}
void insertNode(BiTNode*t,int key)
{
	BiTNode*p,*Parent,*Head;
	p=new BiTNode;
	p->data=key;
	BENULL(p);

	Head=t;
	while(Head)
	{
				Parent=Head;
				if(key<Head->data)
							Head=Head->left;
				else
			Head=Head->right;
	}
	if(key<Parent->data)   //注意不是head，一定要用Parent个连接
		Parent->left=p; //连接节点  //新值小于根节点，连接在左子树，否则连接在右子树
	else
		Parent->right=p;
}
void Sort_tree(BiTNode*t)
{
	t->data=elem[0];
	BENULL(t);
	int i;
	for(i=1;elem[i]!=0;i++)
	{
		insertNode(t,elem[i]);
	}
}
void sbtree(BiTNode*Tree){
    cout<<"生成elem[]"<<endl;
		radom_elem(elem);
    Sort_tree(Tree);
		cout<<"bstree完成"<<endl;
  	show_in_order(Tree);
	}

//find
BiTNode *W,*K,*kroot;
int min_k=100000;
void find(BiTNode *T,int key)
{
	if(T)
	{
		find(T->left,key);
		if(key==T->data)
			{
				W=T;
			}
		find(T->right,key);
	}
}

void findintree(BiTNode *T)
{
	cout<<"输入要查找到key:"<<flush;
	int n;
	cin>>n;
	W=NULL;
	find(T,n);
	if(W==NULL)printf("树中没有要查找的数字\n" );
	else
	 printf("树中有该数字,指针:%p\n",&W );
}

void find_min(BiTNode *T)
{
	cout<<"entered min"<<endl;
	if(T)
	{
			if(min_k>T->data)
				{
					cout<<"swap>-<"<<endl;
					min_k=T->data;
					K=T;
				}
		find_min(T->left);
		find_min(T->right);
	}
}
void del_ing(BiTNode *&kill)
{
	if(kill->left==NULL&&kill->right==NULL)
	{
			kill->data=0;
	}

	else if(NULL==kill->right)
	{
		kill->data=0;
	  kill=kill->left;
	}
		else
		{
			find_min(kill->right);
			cout<<"minbac K="<<K->data<<endl;
			kill->data = K->data;
			K->data=0;
		}
}
void del_it(BiTNode *T)
{
			printf("PS:我输出了一些方便我调试的东西 请多见谅\n" );
		cout<<"输入要del的key:"<<flush;
		int n;
		cin>>n;
		W=NULL;
		find(T,n);
		if(W==NULL)printf("树中没有要del的数字\n" );

		else
		{
			printf("deleting^^^\n" );
			K=NULL;
			kroot=NULL;
			del_ing(W);
		}
		printf("=====================DELETE COMPLETE\n" );
		show_in_order(Tree);
}
//
void preOrder2(BiTNode *root)     //非递归前序遍历
{
	  stack<BiTNode*>s;
    BiTNode *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            cout<<p->data<<" ";
            s.push(p);
            p=p->left;
        }
        if(!s.empty())
        {
            p=s.top();
            s.pop();
            p=p->right;
        }
    }
}
//
void leveOrder(BiTNode *root)
{
	  queue<BiTNode*>s;
    BiTNode *disp,*p=root;
		s.push(p);
  		while (!s.empty())
				{
					disp=s.front();
					s.pop();
					cout<<disp->data<<" "<<flush;
					if(p->left)s.push(p->left);
					if(p->right)s.push(p->right);
					p=s.front();
				}
}
//
void printTree(BiTNode *t,int space)
{
    /*如果为空树，return；*/
    if(t==NULL) return ;
    /*输出根*/
    int i,j,k;
    for(i=0;i<space;i++) printf(" ");
    printf("%d\n",t->data);
    /*输出子树*/
    if(t->left)printTree(t->left,space+3);
		if(t->right)printTree(t->right,space+3);
}
//
void GuangYi(BiTNode *T)
{
	if(T)
	{
		if(T->data==NULL);
		else{printf("%d ",T->data);}	/*访问结点*/
		cout<<"("<<flush;
		GuangYi(T->left);
		GuangYi(T->right);
		cout<<")"<<flush;
	}
}
//
void wPreorder(BiTNode *T,FILE *&fp)
{
	if(T)
	{
		if(T->data==NULL);
		else{fprintf(fp,"%d ",T->data);}	/*访问结点*/
		wPreorder(T->left,fp);
		wPreorder(T->right,fp);
	}
}
void wPostorder(BiTNode *T,FILE *&fp)
{
	if(T)
	{
		wPostorder(T->left,fp);
		wPostorder(T->right,fp);
		if(T->data==NULL);
		else{fprintf(fp,"%d ",T->data);}	/*访问结点*/
	}
}
void wInorder(BiTNode *T,FILE *&fp)
{
	if(T)
	{
		wInorder(T->left,fp);
		if(T->data==NULL);
		else{fprintf(fp,"%d ",T->data);}	/*访问结点*/
		wInorder(T->right,fp);
	}
}
void write_in_3_order(BiTNode *T)
{
	cout<<"在同一文件夹下的test.txt将会被写入"<<endl;
	FILE *fp = NULL;
	fp = fopen("test.txt", "w+");
	fprintf(fp,"\nPREorder  :");
  wPreorder(Tree,fp);
	fprintf(fp,"\nINorder    :");
	wInorder(Tree,fp);
	fprintf(fp,"\nPOSTorder:");
	wPostorder(Tree,fp);
	fclose(fp);
	cout<<"写--入--完--成--"<<endl;
}








void coffee()
{
cout<<
"					       _==/          i     i          \==_             \n"
"					     /XX/            |\___/|            \XX\           \n"
"					   /XXXX\            |XXXXX|            /XXXX\             \n"
"					  |XXXXXX\_         _XXXXXXX_         _/XXXXXX|            \n"
"					 XXXXXXXXXXXxxxxxxxXXXXXXXXXXXxxxxxxxXXXXXXXXXXX             \n"
"					|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|             \n"
 "					XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX             \n"
"					|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|             \n"
 "					 XXXXXX/^^^^^\XXXXXXXXXXXXXXXXXXXXX/^^^^^\XXXXXX             \n"
 "					  |XXX|       \XXX/^^\XXXXX/^^\XXX/       |XXX|             \n"
 "					      \XX\       \X/    \XXX/    \X/       /XX/             \n"
"		    			       *\       *      \X/      *      /*               \n "<<endl;
			wait();}

 树是真的难写

指针瞎几把指 会让人很难受

现在我的结构成绩还是没出来

实习成绩都出来了

Thank you for reading my essay.

"Kim"
关注
数据结构：二叉树详解 c++信息学奥赛基础知识讲解
青少年编程学习指导
06-24 2136
​ 一、二叉树的定义 二叉树(Binary Tree) 是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树T TT： 有且仅有一个根结点； 除根结点外的其余结点又可分为两个不相交的子集TL和TR，分别称为T的左子树和右子树，且TL和TR本身又都是二叉树。 很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。 从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；二是结点的子树有左右之分，不能随意调换，调换后又是一棵新的二叉树。
数据结构实验报告：二叉树的基本操作及应用
热门推荐
2码8改
01-30 1万+
二叉树的基本操作实现&&果子合并 一、实验目的 1、使学生熟练掌握二叉树的逻辑结构和存储结构。 2、熟练掌握二叉树的各种遍历算法。 3、使学生熟练掌握哈夫曼树的生成算法。 4、熟练掌握哈夫曼编码的方法。 二、实验内容 本次实验提供4个题目，难度不等，学生可以根据自己的情况选做，其中题目一是必做题，其它选作！ 题目一：二叉...
实验四 二叉树操作.cpp
06-20
1．输入字符序列，建立二叉链表。 2．中序遍历二叉树:递归算法。 3．中序遍历二叉树:非递归算法。（最好也能实现先序，后序非递归算法） 4．求二叉树的高度 。 5．求二叉树的叶子个数。
网易实习生笔试题：二叉树
helloworlddm的博客
07-23 490
题目描述： 有一棵二叉树，树上每个点标有权值，权值各不相同，请设计一个算法算出权值最大的叶节点到权值最小的叶节点的距离。二叉树每条边的距离为1，一个节点经过多少条边到达另一个节点为这两个节点之间的距离。 给定二叉树的根节点root，请返回所求距离。class Tree { void Inorder(TreeNode *root,vector<int>&v,int &small,int &
第三章 P3.1树和二叉树
baidu_39491365的博客
06-10 341
1.树的一些概念 非空的树有根，树有子树，树和子树就像递归一样，树中有子树，子树这棵树又有子树，又有子树又有子树又有子树又.....如下图 注意子树和子树不会有相交的结点 树是保证结点连通的一种最小连接方式，你随意去掉一条边，树就不连通了。 2.树的表示 3.二叉树 把儿子-兄弟表示法的图旋转45度，可以看出，实际上是一个二叉树。 对于上图第三点...
远古课程作业 数据结构与算法实习 二叉树的基本操作（附源码和实验报告，95分以上，做法不一定全对）
m0_53358056的博客
04-01 793
2、在写算二叉树深度的函数时，自己独立去想，死活想不出来，后来参考了优快云上的代码，豁然开朗，在写递归时，先假设这个函数可以完成相应的操作，再根据函数的结果，进行一些简单操作，递归就可以实现功能了，例如在算深度时，假设左右子树的深度都能通过此函数算出来，而树的深度就等于较深子树的深度加一，这样就把函数写出来了。总之，知识掌握的还是不够多，不够深。*11、根据Huffman编码原理，使用数组elem中的随机数序列（以0表示结束，不包括0）作为结点的权重，生成赫夫曼树，以及赫夫曼编码，计算平均带权径长度。
文本二叉树
魏莘墨的专栏
12-08 2819
/* 3:文本二叉树 查看 提交 统计 提问 总时间限制: 1000ms 内存限制: 65536kB 描述 如上图，一棵每个节点都是一个字母，且字母互不相同的二叉树，可以用以下若干行文本表示: A -B --* --C -D --E ---* ---F 在这若干行文本中： 1) 每个字母代表一个节点。该字母在文本中是第几行，就称该节点的行号是几。根在第1行 2) 每个字母左边的'-'字
山东大学《数据结构》实验五：二叉树操作
1个胖墩的课后笔记
01-14 1972
实验五 二叉树操作 一、 实验目的 掌握二叉树的基本概念，二叉树的存储结构使用链表。 二、 实验内容 1、输入一个完全二叉树的层次遍历字符串，创建这个二叉树，输出这个 二叉树的前序遍历字符串、中序遍历字符串、后序遍历字符串、结点 数目、二叉树高度(上述每一个结果独立一行显示)。 2、输入二叉树前序序列和中序序列(各元素各不相同)，创建这个二叉 树，输出该二叉树的后序序列、层次遍历。 代码如下： #...
二叉树的前序遍历
qq_43413774的博客
04-06 6219
前言 在讲二叉树的遍历之前，我们首先讲一下递归这个东西，很多人，写递归函数靠运气，或者说不只是写递归函数，写任何代码都靠运气，听天由命，有时候自己都不知道自己写的是什么就过了，这样写代码肯定是不行的。 之所以我们会有这种情况是因为，我们在写一个代码的时候没有一个明确的方法体，我们在这里以递归为例子。 递归 我们在写递归算法的时候主要有三要素，每次写递归按照这三要素写，一般不会出错。 1.确定递归函数的参数和返回值： 确认哪些参数是递归过程中需要处理的，那么就在递归函数里加上这个参数，返回值每次递归的返回值一
数据结构作业：二叉树与图的算法解析
"西南交通大学的数据结构第4次作业，涵盖了二叉树和图的相关知识，包括算法设计与编程题目。" 本次作业主要涉及了数据结构中的核心概念——二叉树和图，具体知识点如下： 一、二叉树部分： 1. **二叉树的直径**：...
erchashu 即二叉树.
04-16
学会二叉树的好方法哦 千万不要错过!1！1!
二叉树操作（C语言）含注释
m0_62925086的博客
02-22 862
二叉树的操作（C语言） 1：初始化 2：显示(Map.txt) 3：先序遍历(递归法) 4中序遍历(递归法) 5：后序遍历 (递归法) 6：统计叶子结点数目 7：二叉树深度 8：左右子树交换 9：生成二叉排序树 a：查找排序树中的结点 b：删除排序树中的结点 c：先序遍历(非递归法) d：层次遍历 e：凹入法表示二叉树 f：广义表表示二叉树
二叉树的基本操作 附源码
可行的code
07-04 2416
一、 目的 1．掌握二叉树的存储实现。 2．掌握二叉树的遍历思想。 3．掌握二叉树的常见算法的程序实现。 二、内容 1、内容 a)从键盘上输入数据，建立二叉链表。 b)前序遍历、中序遍历、后序遍历二叉树：递归算法。 c)前序遍历、中序遍历、后序遍历二叉树：非递归算法。 d)借助队列实现二叉树的层...
数据结构-数据选择算法-即从指定数组中选取指定个数的数据的种类
siliang13的专栏
04-20 2267
本文转载http://blog.youkuaiyun.com/feixiaoxing/article/details/6877461 在数学中，有一些数据选择的内容。举个例子来说，有这样一组数据：1、2、3、4。现在我们打算从中挑选出1个数据，那么有几种选择呢？结果应该是1、2、3、4；那么如果挑选2个数据呢，怎么选呢？那么结果应该是12、13、14、15。以此类推，我们还能挑选出3个数据、4个数据
数据结构基础：P3.3-树(一)---＞二叉树的遍历
InnerPeaceHQ的博客
12-26 1358
本系列文章为浙江大学陈越、何钦铭数据结构学习笔记，前面的系列文章链接如下： 数据结构基础：P1-基本概念 数据结构基础：P2.1-线性结构—＞线性表 数据结构基础：P2.2-线性结构—＞堆栈 数据结构基础：P2.3-线性结构—＞队列 数据结构基础：P2.4-应用实例—＞多项式加法运算 数据结构基础：P2.5-应用实例—＞多项式乘法与加法运算-C实现 数据结构基础：P3.1-树(一)—＞树与树的表示 数据结构基础：P3.2-树(一)—＞二叉树及存储结构 文章目录一、先序中序后序遍历1.1 先序遍历1.2 中
二叉排序树的插入与遍历（例子是九度1201题）
haroroda的博客
02-25 3224
二叉排序树的插入与遍历（例子是九度1201题）
【经典算法实现 22】根据数组动态创建二叉树（实现方法一）
|~~~热爱生活、努力学习的小伙汁~~~|
08-19 1124
本文主要实现，根据数据动态创建二叉树的功能。 实现结果如下: ----->1 ----->2 ----->3 ----->4 ----->6 ----->5
合肥工业大学数据结构实验：二叉树操作详解
合肥工业大学数据结构试验三主要围绕二叉树这一数据结构展开，涉及到多个与二叉树相关的操作和概念。以下是对该试验内容的详细解读和知识点说明： 1. 求二叉树的高度： 二叉树的高度定义为根节点到最远叶子节点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值