求C++高手！！！

Posted 2023-04-04

现有多个类定义的头文件，每个文件中必须定义
enum Error_codesuccess,fail,range_error,underflow,overflow,fatal,not_present,duplicate_error,entry_inserted,entry_found,internal_error;
的枚举类型，而每个头文件被主函数调用，怎样防止Error_code的重定义？？？

使用预编译指令
#ifndef POINT_H_H
#define POINT_H_H 1
enum Error_codesuccess,fail,range_error,underflow,overflow,fatal,not_present,duplicate_error,entry_inserted,entry_found,internal_error;

#endif 参考技术A 用预编译指令
建议看看孙鑫的视频，上面就讲过 参考技术B 学会，多做练习!
1．m个人的成绩存放在score数组中，请编写函数fun，它的功能是：将低于平均分的人数作为函数值返回，将低于平均分的分数放在below所指的数组中。
例如，当score数组中的数据为10、20、30、40、50、60、70、80、90时，函数返回的人数应该是4，below中的数据应为10、20、30、40。
**************************************************
2．请编写函数fun，它的功能是：求出1到1000之内能被7或11整除、但不能同时被7和11整除的所有整数并将它们放在a所指的数组中，通过n返回这些数的个数。

**************************************************
3．请编写函数void fun(int x，int pp[]，int *n)，它的功能是：求出能整除x且不是偶数的各整数，并按从小到大的顺序放在pp所指的数组中，这些除数的个数通过形参n返回。
例如，若x中的值为30，则有4个数符合要求，它们是1，3，5，15。
**************************************************
4．请编写一个函数void fun(char *tt，int pp[])，统计在tt字符串中“a”到“z”26个字母各自出现的次数，并依次放在pp所指数组中。
例如，当输入字符串abcdefgabcdeabc后，程序的输出结果应该是：3 3 3 2 2 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
**************************************************
5．请编写一个函数void fun(int m，int k，int xx[])，该函数的功能是：将大于整数m且紧靠m的k个素数存入xx所指的数组中。
例如，若输入：17，5，则应输出：19，23，29，31，37。
**************************************************
6．请编写一个函数void fun(char a[]，char b[]，int n)，其功能是：删除一个字符串中指定下标的字符。其中，a指向原字符串，删除后的字符串存放在b所指的数组中，n中存放指定的下标。
例如，输入一个字符串World，然后输入3，则调用该函数后的结果为Word。
**************************************************
7．请编写一个函数int fun(int*s，int t，int *k)，用来求出数组的最大元素在数组中的下标并存放在k所指的存储单元中。
例如，输入如下整数：876 675 896 10l 30l 40l 980 43l 451 777 ，则输出结果为：6，980。
**************************************************
8．编写函数fun，函数的功能是：根据以下公式计算s，计算结果作为函数值返回；n通过形参传入。
S=1+1/(1+2)+1/(1+2+3)+……1/(1+2+3+…+n)
例如：若n的值为11时，函数的值为1.833333。
**************************************************
9．编写函数fun，它的功能是：根据以下公式求P的值，结果由函数值带回。m与n为两个正整数且要求m>n。

例如：m=12，n=8时，运行结果为495.000000。
**************************************************
10．编写函数fun，它的功能是：利用以下所示的简单迭代方法求方程COS(X)-X=0的一个实根。
Xn+1=COS(Xn)
迭代步骤如下：
(1)取x1初值为0.0；
(2)x0=x1，把x1的值赋给x0；
(3)x1=COS(x0)，求出一个新的x1；
(4)若x0—x1的绝对值小于0.000001，则执行步骤(5)，否则执行步骤(2)；
(5)所求x1就是方程COS(X)-X=0的一个实根，作为函数值返回。
程序将输出结果Root=0.739085。
**************************************************
11．下列程序定义了NXN的二维数组，并在主函数中自动赋值。请编写函数fun(int a[][N]，该函数的功能是：使数组左下半三角元素中的值全部置成0。例如：a数组中的值为：
，则返回主程序后a数组中的值应为：。
**************************************************
12．下列程序定义了NXN的二维数组，并在主函数中赋值。请编写函数fun，函数的功能是：求出数组周边元素的平均值并作为函数值返回给主函数中的s。例如：若a数组中的值为：
，则返回主程序后s的值应为3.375。
**************************************************
13．请编一个函数void fun(int tt[M][N]，int pp[N])，tt指向一个M行N列的二维数组，求出二维数组每列中最小元素，并依次放入pp所指一维数组中。二维数组中的数已在主函数中赋予。
**************************************************
14．请编写函数fun，函数的功能是求出二维数组周边元素之和，作为函数值返回。二维数组中的值在主函数中赋予。
例如：若二维数组中的值为：，则函数值为61。
*************************************************
15．请编写一个函数unsigned fun(unsigned w)，w是一个大于10的无符号整数，若w是n(n≥2)位的整数，则函数求出w的后n-1位的数作为函数值返回。
例如：w值为5923，则函数返回923；若w值为923，则函数返回23。
**************************************************
16．请编一个函数float fun(double h)，函数的功能是对变量h中的值保留2位小数，并对第三位进行四舍五入(规定h中的值为正数)。
例如：若h值为8.32433，则函数返回8.32；若h值为8.32533，则函数返回8.33。
**************************************************
17．请编一个函数fun(char*s)，该函数的功能是把字符串中的内容逆置。
例如：字符串中原有的字符串为abcdefg，则调用该函数后，串中的内容为gfedcba。
**************************************************
18．编写程序，实现矩阵(3行3列)的转置(即行列互换)。
例如，若输入下面的矩阵：，则程序输出：
**************************************************
19．编写函数fun，该函数的功能是：从字符串中删除指定的字符。同一字母的大、小写按不同字符处理。
例如：若程序执行时输入字符串为：turbo c and borland c++，从键盘上输入字符n，则输出后变为：turbo c ad borlad c++；如果输入的字符在字符串中不存在，则字符串照原样输出。
**************************************************
20．编写函数int fun(int lim，int aa[MAX])，该函数的功能是求出小于或等于lim的所有素数并放在aa数组中，该函数返回所求出的素数的个数。
**************************************************
21．请编写函数fun，对长度为7个字符的字符串，除首、尾字符外，将其余5个字符按ASCII码降序排列。
例如，若原来的字符串为CEAedca，则排序后输出为CedcEAa。
**************************************************
22．N名学生的成绩已在主函数中放入一个带头节点的链表结构中，h指向链表的头节点。请编写函数fun，它的功能是：找出学生的最高分，由函数值返回。
**************************************************
23．请编写函数fun，该函数的功能是：判断字符串是否为回文?若是则函数返回1，主函数中输出YES，否则返回0，主函数中输出NO。回文是指顺读和倒读都一样的字符串。
例如，字符串LEVEL是回文，而字符串123312就不是回文。
**************************************************
24．请编写一个函数fun，它的功能是：将一个数字字符串转换为一个整数(不得调用C语言提供的将字符串转换为整数的函数)。
例如，若输入字符串“-1234”，则函数把它转换为整数值-1234。
**************************************************
25．请编写一个函数fun，它的功能是：比较两个字符串的长度，(不得调用C语言提供的求字符串长度的函数)，函数返回较长的字符串。若两个字符串长度相同，则返回第一个字
符串。
例如，输入：beijing shanghai<CR>(<CR>为回车键)，函数将返回shanghai。
*************************************************
26．请编写一个函数fun，它的功能是：根据以下公式求π的值(要求满足精度0.0005，即某项小于0.0005时停止迭代)：

程序运行后，如果输入精度0.0005，则程序输出为3.14…。
**************************************************
27．请编写一个函数fun，它的功能是：求出1到m之内(含m)能被7或11整除的所有整数放在数组a中，通过n返回这些数的个数。
例如，若传送给m的值为50，则程序输出：
7 11 14 21 22 28 33 35 42 44 49
**************************************************
28．请编写一个函数fun，它的功能是：找出一维整型数组元素中最大的值和它所在的下标，最大的值和它所在的下标通过形参传回。数组元素中的值已在主函数中赋予。
主函数中x是数组名，n是x中的数据个数，max存放最大值，index存放最大值所在元素的下标。
**************************************************
29．请编写一个函数fun，它的功能是：将ss所指字符串中所有下标为奇数位置上的字母转换为大写(若该位置上不是字母，则不转换)。
例如，若输入abc4EFg，则应输出aBc4EFg。
**************************************************
30．请编写一个函数fun，它的功能是：求出一个2xM整型二维数组中最大元素的值，并将此值返回调用函数。
**************************************************
31．请编写函数fun，其功能是：将s所指字符串中除了下标为偶数、同时ASCII值也为偶数的字符外，其余的全都删除；串中剩余字符所形成的一个新串放在t所指的数组中。
例如，若s所指字符串中的内容为ABCDEFG123456，其中字符A的ASCII码值为奇数，因此应当删除；其中字符B的ASCII码值为偶数，但在数组中的下标为奇数，因此也应当删除；而字符2的ASCII码值为偶数，所在数组中的下标也为偶数，因此不应当删除，其他依此类推。最后t所指的数组中的内容应是246。
**************************************************
32．请编写函数fun，其功能是：将s所指字符串中除了下标为奇数、同时ASCII值也为奇数的字符之外，其余的所有字符都删除，串中剩余字符所形成的一个新串放在t所指的数组中。
例如，若s所指字符串中的内容为ABCDEFGl2345，其中字符A的ASCII码值虽为奇数，但所在元素的下标为偶数，因此必需删除；而字符1的ASCII码值为奇数，所在数组中的下标也为奇数，因此不应当删除，其他依此类推。最后t所指的数组中的内容应是135。
**************************************************
33．假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：使字符串中尾部的*号不得多于n个；若多于n个，则删除多余的*号；若少于或等于n个，则什么也不做，字符串中间和前面的*号不删除。
例如，字符串中的内容为****A*BC*DEF*G*******，若n的值为4，删除后，字符串中的内容则应当是****A*BC*DEF*G****；若n的值为7，则字符串中的内容仍为 ****A*BC*DEF*G*******。n的值在主函数中输入。在编写函数时，不得使用C语言提供的字符串函数。
**************************************************
34．学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中，请编写函数fun，它的功能是：把分数最高的学生数据放在h所指的数组中，注意：分数最高的学生可能不只一个，函数返回分数最高的学生的人数。
**************************************************
35．请编写一个函数，用来删除字符串中的所有空格。
例如，输入asd af aa z67，则输出为asdafaaz67。
**************************************************
36．假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：将字符串中的前导*号全部移到字符串的尾部。
例如，字符串中的内容为*******A*BC*DEF*G****，移动后，字符串中的内容应当是A*BC*DEF*G***********。在编写函数时，不得使用C语言提供的字符串函数。
**************************************************
37．某学生的记录由学号、8门课程成绩和平均分组成，学号和8门课程的成绩已在主函数中给出。请编写函数fun，它的功能是：求出该学生的平均分放在记录的ave成员中。请自己定义正确的形参。
例如，若学生的成绩是85.5，76，69.5，85，91，72，64.5，87.5，则他的平均分应当是78.875。
*************************************************
38．请编写函数fun，它的功能是：求出ss所指字符串中指定字符的个数，并返回此值。
例如，若输入字符串123412132，输入字符1，则输出3。
**************************************************
39．请编写函数fun，该函数的功能是：移动一维数组中的内容；若数组中有n个整数，要求把下标从0到p（p小于等于n-1）的数组元素平移到数组的最后。
例如，一维数组中的原始内容为：1，2，3，4，5，6，7，8，9，10；p的值为3。移动后，一维数组中的内容应为：5，6，7，8，9，10，1，2，3，4。
**************************************************
40．请编写函数fun，该函数的功能是：移动字符串中的内容，移动的规则如下：把第1到第m个字符，平移到字符串的最后，把第m+l到最后的字符移到字符串的前部。
例如，字符串中原有的内容为ABCDEFGHIJK，m的值为3，移动后，字符串中的内容应该是DEFGHIJKABC。
**************************************************
41．请编写函数fun，该函数的功能是：将M行N列的二维数组中的字符数据，按列的顺序依次放在一个字符串中。
例如，若二维数组中的数据为：

则字符串中的内容应是WSHWSHWSHWSH。
**************************************************
42．下列程序定义了NxN的二维数组，并在主函数中自动赋值。请编写函数fun(int a[][N]，int n)，该函数的功能是：使数组右上半三角元素中的值乘以m。例如：若m的值为2，a数组中的值为：，则返回主程序后a数组中的值应为：。
**************************************************
43．编写一个函数，从传入的num个字符串中找出最长的一个字符串，并通过形参指针max传回该串地址(用****作为结束输入的标志)。
************************************************
44．编写一个函数，该函数可以统计一个长度为2的字符串在另一个字符串中出现的次数。例如，假定输入的字符串为：asd asasdfg asd as zx67 asd mklo，子字符串为as，则应输出6。
**************************************************
45．假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：只删除字符串前导和尾部的*号，串中字母之间的*号都不删除。形参n给出了字符串的长度，形参h给出了字符串中前导*号的个数，形参e给出了字符串中最后*号的个数。在编写函数时，不得使用C语言提供的字符串函数。
例如，若字符串中的内容为****A*BC*DEF*G*******，删除后，字符串中的内容则应当是A*BC*DEF*G。
**************************************************
46．学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中，请编写函数fun，它的功能是：按分数的高低排列学生的记录，高分在前。
**************************************************
47．请编写一个函数void fun(char*ss)，其功能是：将字符串ss中所有下标为奇数位置上的字母转换为大写(若该位置上不是字母，则不转换)。
例如，若输入abc4EFgh，则应输出aBc4EFgH。
**************************************************
48．请编写函数fun，其功能是：将两个两位数的正整数a、b合并形成一个整数放在c中。合并的方式是：将a数的十位和个位数依次放在c数的千位和十位上，b数的十位和个位数依次放在c数的百位和个位上。
例如，当a=45，b=12，调用该函数后，c=4152。
**************************************************
49．请编写函数fun，其功能是：将s所指字符串中下标为偶数同时ASCII值为奇数的字符删除，s中剩余的字符形成的新串放在t所指的数组中。
例如，若s所指字符串中的内容为ABCDEFGl2345，其中字符C的ASCII码值为奇数，在数组中的下标为偶数，因此必须删除；而字符1的ASCII码值为奇数，在数组中的下标也为奇数，因此不应当删除，其他依此类推。最后t所指的数组中的内容应是BDFl2345。
**************************************************
50．已知学生的记录由学号和学习成绩构成，N名学生的数据已存入a结构体数组中。请编写函数fun，该函数的功能是：找出成绩最高的学生记录，通过形参返回主函数(规定只有一个最高分)。已给出函数的首部，请完成该函数。

我们数据结构实验课让用C++做一个二叉树的遍历的程序，老师也没讲过具体怎么弄，求高手解答！

请从用什么软件讲起……我们学过C++，但是数据结构课用的是清华大学的教材，老师说上面用的语言是类C，然后也没讲过用什么语句什么的突然就叫我们写程序，都不会啊……
我们用的软件是Microsoft Visual C++ 6.0
求高手！求讲解！

自己写的，运行通过，MFC的有点难弄，将就着用吧。

queue.h//链式队列用于层序遍历树

// queue.h: interface for the queue class.

//

//////////////////////////////////////////////////////////////////////

#if !defined(AFX_QUEUE_H__6515EF6D_27AA_4799_95F8_6FE216E99F0F__INCLUDED_)

#define AFX_QUEUE_H__6515EF6D_27AA_4799_95F8_6FE216E99F0F__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

#include <iostream.h>

#include <assert.h>

template<class T>

struct LinkNode

 T data;

 LinkNode<T> *link;

 LinkNode(LinkNode<T> *ptr = NULL)link = ptr;//仅初始化指针成员的初始函数.

 LinkNode(const T& item,LinkNode<T> *ptr = NULL)

 data = item;link = ptr;  //初始化数据与指针成员的构造函数.

;

template <class T>

class queue

private: 

 LinkNode<T> *front,*rear;//

public:

 queue():rear(NULL),front(NULL);//

 ~queue()makeempty();;//

 bool EnQueue(T &x);//

 bool DeQueue(T &x);//

 bool getFront(T &x);//

 void makeempty();//

 bool Isempty()constreturn front==NULL;//

 int getSize()const;//

 friend ostream &operator<<(ostream &os,queue<T> &q);//

;

template<class T>

void queue<T>::makeempty()

 LinkNode<T> *p;

 while(front!=NULL)

 

  p=front;

  front=front->link;

  delete p;

 

template <class T>

bool queue<T>::EnQueue(T &x)

 if(front==NULL)

 

  front=rear=new LinkNode<T>(x);

  if(front==NULL)

   return false;

 

 else

 

  rear->link=new LinkNode<T>(x);

  if(rear==NULL)

   return false;

  rear=rear->link;

 

 return true;

template <class T>

bool queue<T>::DeQueue(T &x)

 if(Isempty())return false;

 LinkNode<T> *p=front;

 x=front->data;

 front=front->link;

 delete p;

 return true;

template<class T>

bool queue<T>::getFront(T &x)

 if(Isempty())return false;

 x=front->data;

 return true;

template <class T>

int queue<T>::getSize() const

 LinkNode<T> *p=front;

 int k=0;

 while(p)

 

  k++;

  p=p->link;

 

 return k;

#endif // !defined(AFX_QUEUE_H__6515EF6D_27AA_4799_95F8_6FE216E99F0F__INCLUDED_)

BinaryTree.h

// BinaryTree.h: interface for the BinaryTree class.

//

//////////////////////////////////////////////////////////////////////

#if !defined(AFX_BINARYTREE_H__61FEB349_65EE_40FB_82DF_25FFBCBDFC6E__INCLUDED_)

#define AFX_BINARYTREE_H__61FEB349_65EE_40FB_82DF_25FFBCBDFC6E__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

#include <iostream.h>

typedef int T;

struct BinTreeNode

 T data;

    BinTreeNode  *leftChild,*rightChild;

    BinTreeNode():leftChild(NULL),rightChild(NULL)

    BinTreeNode(T x,BinTreeNode *l=NULL,BinTreeNode *r=NULL):data(x),leftChild(l),rightChild(r)

 

;

class BinaryTree 

public:

    BinaryTree():root(NULL)   //  

    BinaryTree(T value):RefValue(value) ,root(NULL)         //

    ~BinaryTree()destroy(root);/////////

    void CreateBinTree()CreateBinTree(root);

 bool IsEmpty()return(root==NULL)?true:false;////////

    BinTreeNode *Parent(BinTreeNode *current)/////////

 return(root==NULL||root==current)?NULL:Parent(root,current);//////

 BinTreeNode *LeftChild(BinTreeNode *current)////

 return(current!=NULL)?current->leftChild:NULL;

    BinTreeNode *RightChild(BinTreeNode *current)///////

 return(current!=NULL)?current->rightChild:NULL;

 int Height()return Height(root);///////

 int Size()return Size(root);///////

    BinTreeNode *getRoot()constreturn root;///////

 void preOrder()///////

 preOrder(root);

 void inOrder()///////

 inOrder(root);

    void postOrder()///

 postOrder(root);

    void levelOrder()/////

 levelOrder(root);

 void destroy()destroy(root);;

 int Leaves ()return leaves(root);

protected:

    BinTreeNode  *root;

 T RefValue;

 

    void CreateBinTree(BinTreeNode * &subTree);

 bool Insert(BinTreeNode * &subTree,const T &x);////////

 void destroy(BinTreeNode * &subTree);/////

 bool Find(BinTreeNode * &subTree,const T &x);///////

    BinTreeNode  *Copy(BinTreeNode *orignode);///////

 int Height(BinTreeNode * subTree);////////

    int Size(BinTreeNode * subTree);///////

    BinTreeNode *Parent(BinTreeNode *Parent,BinTreeNode *current);//////

 BinTreeNode *Find(BinTreeNode * &subTree,const T &x)const;////////

 void Traverse(BinTreeNode * &subTree,ostream &out);///////

 void preOrder(BinTreeNode * &subTree);///////

 void inOrder(BinTreeNode * &subTree);///////

 void postOrder(BinTreeNode * &subTree);///////

 void levelOrder(BinTreeNode *&subtree);

 int leaves(BinTreeNode * &subTree); 

;

#endif // !defined(AFX_BINARYTREE_H__61FEB349_65EE_40FB_82DF_25FFBCBDFC6E__INCLUDED_)

BinaryTree.cpp

// BinaryTree.cpp: implementation of the BinaryTree class.

//

//////////////////////////////////////////////////////////////////////

#include "BinaryTree.h"

#include<stdlib.h>

#include "queue.h"

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

void BinaryTree::CreateBinTree(BinTreeNode * &subTree)       /////////建立二叉树

 T item;

 cin>>item;

 if(item!=RefValue)

 

  subTree=new BinTreeNode(item);

  if(subTree==NULL)

  

   cerr<<"存储分配错误！"<<endl;

   exit(1);

  

        CreateBinTree(subTree->leftChild);

        CreateBinTree(subTree->rightChild);

  

 

 else subTree=NULL;

void BinaryTree::destroy(BinTreeNode *& subTree)        ////删除二叉树

 if(subTree!=NULL)

 

  destroy(subTree->leftChild);

  destroy(subTree->rightChild);

  delete subTree;

 

BinTreeNode* BinaryTree::Parent(BinTreeNode *subTree, BinTreeNode *current)  //找父母结点  

 if(subTree==NULL)  return NULL;

 if(subTree->leftChild==current||subTree->rightChild==current) 

  return subTree;

 BinTreeNode *p;

 if((p=Parent(subTree->leftChild,current))!=NULL)  return p;

 else return Parent(subTree->rightChild,current);

void BinaryTree::preOrder( BinTreeNode * &subTree)   //前序遍历

 if(subTree!=NULL)

 

  cout<<subTree->data<<" ";

  preOrder(subTree->leftChild);

  preOrder(subTree->rightChild);

 

void BinaryTree::inOrder( BinTreeNode * &subTree)    //中序遍历

 if(subTree!=NULL)

 

  inOrder(subTree->leftChild);

  cout<<subTree->data<<" ";

  inOrder(subTree->rightChild);

 

void BinaryTree::postOrder( BinTreeNode *&subTree )   // 后序遍历

 if(subTree!=NULL)

   

  postOrder(subTree->leftChild);

  postOrder(subTree->rightChild);

  cout<<subTree->data<<" ";

 

void BinaryTree::levelOrder(BinTreeNode *&subtree)   //层序遍历

 if(root==NULL)return;

 queue<BinTreeNode*> Q;

 BinTreeNode *p=root;

 Q.EnQueue(p);

 while(!Q.Isempty())

 

  Q.DeQueue(p);

  cout<<p->data<<" ";

  if(p->leftChild)

   Q.EnQueue(p->leftChild);

  if(p->rightChild)

   Q.EnQueue(p->rightChild);

 

int BinaryTree::Size(BinTreeNode *subTree)               //求结点个数

 if(subTree==NULL) return 0;

 else return 1+Size(subTree->leftChild)+Size(subTree->rightChild);

int BinaryTree::Height(BinTreeNode *subTree)     //求数的深度

 if(subTree==NULL) return 0;

    else 

 

  int i=Height(subTree->leftChild);

  int j=Height(subTree->rightChild);

  return (i>j)?i+1:j+1;

 

 int BinaryTree::leaves(BinTreeNode * &subTree)       //求叶子节点个数

  

  if(subTree==NULL) return 0;

  else if(subTree->leftChild==NULL&&subTree->rightChild==NULL)return 1;

  else

  

   int i=leaves(subTree->leftChild);

   int j=leaves(subTree->rightChild);

   return i+j;

  

 

主函数：

#include "BinaryTree.h"

int main_menu()

 char option;

 while(1)

 

  cout<<"    主菜单"<<endl;

  cout<<endl;

  cout<<"    请选择操作:"<<endl;

  cout<<"   1 建立树:"<<endl;

  cout<<"   2 清空树"<<endl;

  cout<<"   3 退出"<<endl;

  cin>>option;

  switch(option)

  

  case '1':

   return 1;

  case '2':

   return 2;

  case '3':

   return 3;

  default:

   cout<<"输入错误，请检查输入!"<<endl;

   break;

  

 

int tree_menu(BinaryTree &btn)

 char option;

 while(1)

 

  cout<<"   树的相关操作:"<<endl;

  cout<<"    请选择操作:"<<endl;

  //cout<<"  1 输入节点"<<endl;

  cout<<"  2 按前序输出"<<endl;

  cout<<"  3 按中序输出"<<endl;

  cout<<"  4 按后序输出"<<endl;

  cout<<"  5 按层序输出"<<endl;

  cout<<"  6 求节点个数"<<endl;

  cout<<"  7 求树的深度"<<endl;

  cout<<"  8 求树的高度"<<endl;

  cout<<"  9 返回主菜单"<<endl;

  cin>>option;

  switch(option)

  

//   case '1':

//    

//     cout<<"输入节点,-1为结束标志"<<endl;

//     btn.CreateBinTree();

//     break;

//    

  case '2':

   

    cout<<"按前序输出为:"<<endl;

    btn.preOrder();

    break;

   

  case '3':

   

    cout<<"按中序输出为:"<<endl;

    btn.inOrder();

    break;

   

  case '4':

   

    cout<<"按后序输出为:"<<endl;

    btn.postOrder();

    break;

   

  case '5':

   

    cout<<"按层序输出为:"<<endl;

    btn.levelOrder();

    break;

   

  case '6':

   

    cout<<"节点个数为:"<<btn.Size()<<endl;

    break;

   

  case '7':

   

    cout<<"求树的深度为:"<<btn.Height()<<endl;

    break;

   

  case '8':

   

    cout<<"求树的高度为:"<<btn.Height()<<endl;

    break;

   

  case '9':

   return 9;

  default:

   cout<<"输入有误，请检查输入!"<<endl;

   break;

  

 

int main()

 bool bCreated=false;

 int op;

 BinaryTree btn(-1);

 while(1)

 

  op=main_menu();

  switch(op)

  

  case 1:

   

    if(!bCreated)

    

     cout<<"1 输入节点,-1为结束标志"<<endl;

     btn.CreateBinTree();

    

    bCreated=true;

    tree_menu(btn);

    break;

   

  case 2:

   

    btn.destroy();

    bCreated=false;

    break;

   

  case 3:

   return 0;

  

 

 return 0;

参考技术A 其实c语言和C++在我们用数据结构的时候，可简单的区别为输入输出的区别，所以用vc6.0编是完全可以的，我们都是用vc6.0做这个实验的，代码如下：
//==========================================定义头部
#include <iostream>
using namespace std;
struct BiTNode
char data;
struct BiTNode *lchild, *rchild;//左右孩子
;
BiTNode*T;
void CreateBiTree(BiTNode* &T);
void Inorder(BiTNode* &T);
void PreOrderTraverse(BiTNode* &T);
void Posorder(BiTNode* &T);
//===========================================主函数
int main()
cout<<"创建一颗树，其中A->Z字符代表树的数据，用“#”表示空树:"<<endl;
CreateBiTree(T);
cout<<"先序递归遍历："<<endl;
PreOrderTraverse(T);
cout<<endl;
cout<<"中序递归遍历："<<endl;
Inorder(T);
cout<<endl;
cout<<"后序递归遍历："<<endl;
Posorder(T);
cout<<endl;
return 1;
//=============================================先序递归创建二叉树树
void CreateBiTree(BiTNode* &T)
//按先序输入二叉树中结点的值（一个字符），空格字符代表空树，
//构造二叉树表表示二叉树T。
char ch;
if((ch=getchar())=='#')T=NULL;//其中getchar（）为逐个读入标准库函数
else
T=new BiTNode;//产生新的子树
T->data=ch;//由getchar（）逐个读入来
CreateBiTree(T->lchild);//递归创建左子树
CreateBiTree(T->rchild);//递归创建右子树

//CreateTree
//===============================================先序递归遍历二叉树
void PreOrderTraverse(BiTNode* &T)
//先序递归遍历二叉树
if(T)//当结点不为空的时候执行
cout<<T->data;
PreOrderTraverse(T->lchild);//
PreOrderTraverse(T->rchild);

else cout<<"";
//PreOrderTraverse
//================================================中序遍历二叉树
void Inorder(BiTNode* &T)//中序递归遍历二叉树
if(T)//bt=null退层
Inorder(T->lchild);//中序遍历左子树
cout<<T->data;//访问参数
Inorder(T->rchild);//中序遍历右子树

else cout<<"";
//Inorder
//=================================================后序递归遍历二叉树
void Posorder(BiTNode* &T)
if(T)
Posorder(T->lchild);//后序递归遍历左子树
Posorder(T->rchild);//后序递归遍历右子树
cout<<T->data;//访问根结点

else cout<<"";

//=================================================

这是我自己做的，有什么不好的地方，欢迎纠错本回答被提问者采纳 参考技术B #include <iostream>
#include <vector>
using namespace std;

template <typename elemType>
class BinaryTree;

template <typename elemType>
class BTnode;

template <typename valType>
ostream&
foo( ostream &os, const BTnode<valType> &bt );

template <typename valType>
class BTnode
friend class BinaryTree<valType>;
friend ostream&
// foo<valType>( ostream&, const BTnode<valType>& );
foo( ostream&, const BTnode<valType>& );
public:
BTnode( const valType &val );

const valType& value() const return _val;
int occurs() const return _cnt;

void remove_value( const valType&, BTnode*& );
void insert_value( const valType& );
bool find_value( const valType& ) const;

void preorder ( BTnode*, ostream& ) const;
void inorder ( BTnode*, ostream& ) const;
void postorder( BTnode*, ostream& ) const;

static void lchild_leaf( BTnode *leaf, BTnode *subtree );
private:
int _cnt; // occurrence count
valType _val;
BTnode *_lchild;
BTnode *_rchild;

void display_val( BTnode *pt, ostream &os ) const;
BTnode( const BTnode& );
BTnode& operator=( const BTnode& );
;

template <typename valType>
inline
BTnode<valType>::
BTnode( const valType &val )
: _val( val )

_cnt = 1;
_lchild = _rchild = 0;


template <typename valType>
void
BTnode<valType>::
insert_value( const valType &val )

if ( val == _val )

_cnt++;

(*BinaryTree<valType>::os()) << "BTnode::insert_value: increment count( "
<< val << " : " << _cnt << " )\n";

return;


if ( val < _val )
if ( ! _lchild )
_lchild = new BTnode( val );
(*BinaryTree<valType>::os()) << "ok: BTnode::insert_value at left child( " << val << " )\n";

else _lchild->insert_value( val );

else
if ( ! _rchild )
_rchild = new BTnode( val );
(*BinaryTree<valType>::os()) << "ok: BTnode::insert_value at right child( " << val << " )\n";

else _rchild->insert_value( val );



template <typename valType>
bool
BTnode<valType>::
find_value( const valType &val ) const

if ( val == _val )
return true;

if ( val < _val )
if ( ! _lchild )
return false;
else return _lchild->find_value( val );

else
if ( ! _rchild )
return false;
else return _rchild->find_value( val );



template <typename valType>
void
BTnode<valType>::
lchild_leaf( BTnode *leaf, BTnode *subtree )

while ( subtree->_lchild )
subtree = subtree->_lchild;
subtree->_lchild = leaf;


template <typename valType>
void
BTnode<valType>::
remove_value( const valType &val, BTnode *&prev )

if ( val < _val )

if ( ! _lchild )
return; // not present
else _lchild->remove_value( val, _lchild );

else
if ( val > _val )

if ( ! _rchild )
return; // not present
else _rchild->remove_value( val, _rchild );

else
// ok: found it
// reset the tree then delete this node
if ( _rchild )

prev = _rchild;
if ( _lchild )
if ( ! prev->_lchild )
prev->_lchild = _lchild;
else BTnode<valType>::lchild_leaf( _lchild, prev->_lchild );

else prev = _lchild;
delete this;



template <typename valType>
inline void BTnode<valType>::
display_val( BTnode *pt, ostream &os ) const

os << pt->_val;
if ( pt->_cnt > 1 )
os << "( " << pt->_cnt << " ) ";
else os << ' ';


template <typename valType>
void BTnode<valType>::
preorder( BTnode *pt, ostream &os ) const

if ( pt )

display_val( pt, os );
if ( pt->_lchild ) preorder( pt->_lchild, os );
if ( pt->_rchild ) preorder( pt->_rchild, os );



template <typename valType>
void BTnode<valType>::
inorder( BTnode *pt, ostream &os ) const

if ( pt )

if ( pt->_lchild ) inorder( pt->_lchild, os );
display_val( pt, os );
if ( pt->_rchild ) inorder( pt->_rchild, os );



template <typename valType>
void BTnode<valType>::
postorder( BTnode *pt, ostream &os ) const

if ( pt )

if ( pt->_lchild ) postorder( pt->_lchild, os );
if ( pt->_rchild ) postorder( pt->_rchild, os );
display_val( pt, os );



template <typename elemType>
class BinaryTree
public:
BinaryTree();
BinaryTree( const vector< elemType >& );
BinaryTree( const BinaryTree& );
~BinaryTree();
BinaryTree& operator=( const BinaryTree& );

void insert( const vector< elemType >& );
void insert( const elemType& );
void remove( const elemType& );
void clear() clear( _root ); _root = 0; // remove entire tree ...

bool empty() return _root == 0;

void inorder( ostream &os = *_current_os ) const _root->inorder( _root, os );
void postorder( ostream &os = *_current_os ) const _root->postorder( _root, os );
void preorder( ostream &os = *_current_os ) const _root->preorder( _root, os );

bool find( const elemType& ) const;
ostream& print( ostream &os = *_current_os,
void (BinaryTree<elemType>::*traversal)( ostream& ) const =
&BinaryTree<elemType>::inorder ) const;

static void current_os( ostream *os ) if ( os ) _current_os = os;
static ostream* os() return _current_os;

private:
BTnode<elemType> *_root;
static ostream *_current_os;

// copy a subtree addressed by src to tar
void copy( BTnode<elemType>*&tar, BTnode<elemType>*src );
void clear( BTnode<elemType>* );
void remove_root();
;

template <typename elemType>
ostream *BinaryTree<elemType>::_current_os = &cout;

template <typename elemType>
inline
BinaryTree<elemType>::
BinaryTree()
: _root( 0 )

template <typename elemType>
inline
BinaryTree<elemType>::
BinaryTree( const BinaryTree &rhs )
copy( _root, rhs._root );

template <typename elemType>
inline
BinaryTree<elemType>::
~BinaryTree() clear();

template <typename elemType>
inline BinaryTree<elemType>&
BinaryTree<elemType>::
operator=( const BinaryTree &rhs )

if ( this != &rhs )

clear();
copy( _root, rhs._root );



template <typename elemType>
inline void
BinaryTree<elemType>::
insert( const elemType &elem )

if ( ! _root )
(*BinaryTree<elemType>::os()) << "BinaryTree::insert: root( " << elem << " )\n";
_root = new BTnode<elemType>( elem );

else _root->insert_value( elem );


template <typename elemType>
BinaryTree<elemType>::
BinaryTree( const vector< elemType > &vec )

_root = 0;
for ( int ix = 0; ix < vec.size(); ++ix )
insert( vec[ ix ] );


template <typename elemType>
void
BinaryTree<elemType>::
insert( const vector< elemType > &vec )

for ( int ix = 0; ix < vec.size(); ++ix )
insert( vec[ ix ] );


template <typename elemType>
inline void
BinaryTree<elemType>::
remove( const elemType &elem )

if ( _root )

if ( _root->_val == elem )
remove_root();
else _root->remove_value( elem, _root );



template <typename elemType>
void
BinaryTree<elemType>::
remove_root()

if ( ! _root ) return;
BTnode<elemType> *tmp = _root;

if ( _root->_rchild )

_root = _root->_rchild;
BTnode<elemType> *lc = tmp->_lchild;
BTnode<elemType> *newlc = _root->_lchild;

// if left child of root is non-null
// attach it as leaf to left subtree
if ( lc )
if ( ! newlc )
_root->_lchild = lc;
else BTnode<elemType>::lchild_leaf( lc, newlc );

else _root = _root->_lchild;

delete tmp;


template <typename elemType>
void
BinaryTree<elemType>::
clear( BTnode<elemType> *pt )

if ( pt )
clear( pt->_lchild );
clear( pt->_rchild );
delete pt;



template <typename elemType>
ostream&
BinaryTree<elemType>::
print( ostream &os,
void (BinaryTree::*traversal)( ostream& ) const ) const

(this->*traversal)( os );
return os;


template <typename elemType>
inline ostream&
operator<<( ostream &os, const BinaryTree<elemType> &bt )

os << "Tree: " << endl;
bt.print( os, &BinaryTree<elemType>::inorder );
return os;


template <typename elemType>
inline bool
BinaryTree<elemType>::
find( const elemType &elem ) const

return ! _root
? false
: _root->find_value( elem );


template <typename elemType>
void
BinaryTree<elemType>::
copy( BTnode<elemType> *&tar, BTnode<elemType> *src )

if ( src )
tar = new BTnode<elemType>( src->_val );
if ( src->_lchild ) copy( tar->_lchild, src->_lchild );
if ( src->_rchild ) copy( tar->_rchild, src->_rchild );



#include <string>
#include <algorithm>
#include <fstream>
using namespace std;

main()

/*
BinaryTree< int > bt;

bt.insert( 7 );
bt.insert( 5 );
bt.insert( 9 );
bt.insert( 6 );
bt.insert( 3 );
*/

/*
BinaryTree< string > bt;
bt.insert( "Piglet" );
bt.insert( "Pooh" );
bt.insert( "Eeyore" );
bt.insert( "Kanga" );
bt.insert( "Tigger" );
*/

ofstream log( "logfile.txt" );
if ( ! log )
cerr << "error: unable to open file!\n";
return -1;

else BinaryTree<string>::current_os( &log );

/*
int ia[] = 24, 18, 36, 12, 14, 8, 24, 1, 42, 24, 8, 8, 16, 55 ;
vector< int > ivec( ia, ia + 14 );
BinaryTree<int> bt( ivec );

log << "preorder traversal: \n";
// cout << should see\n\t ";
bt.preorder( log );

bt.clear();
log << "\nbt is now " << ( bt.empty() ? " empty! " : " oops -- not empty!" ) << endl;

sort( ivec.begin(), ivec.end() );
bt.insert( ivec );

log << "\n\ninorder traversal:\n";
bt.inorder( log );

bt.insert( ivec );

log << "\n\npostorder traversal:\n";
bt.postorder( log );

log << endl << endl;
*/

BinaryTree<string> bt;
bt.insert( "Piglet" );
bt.insert( "Eeyore" );
bt.insert( "Roo" );

bt.insert( "Tigger" );
bt.insert( "Chris" );
bt.insert( "Pooh" );
bt.insert( "Kanga" );

log << "preorder traversal: \n";
bt.preorder( log );

log << "\n\nabout to remove root: Piglet\n";
bt.remove( "Piglet" );

log << "\n\npreorder traversal after Piglet removal: \n";
bt.preorder( log );

log << "\n\nabout to remove Eeyore\n";
bt.remove( "Eeyore" );

log << "\n\npreorder traversal after Piglet removal: \n";
bt.preorder( log );

// log << "\n\ninorder traversal:\n";
// bt.inorder( log );

// log << "\n\npostorder traversal:\n";
// bt.postorder( log );
//
return 0;
参考技术C 新建个win32控制台应用的工程，添加c++源文件, 里面有开始写程序，写完后debug，直接把你写的程序和生成的exe拷给老师就行。你写的程序叫TOY PROGRAM，只能在DOS下面跑，你理解的那个估计是要写个界面，就你现在的水平看，基本的VC都还不是很懂。所以你按照上面人说的写就是了。分就不用给了 参考技术D 比对着书上的写，书上不是有好几个例子吗，前序 中序 后序遍历 ，用递归或者普通方法都可以追问

把书上的直接写到C++程序软件里？那↑怎么输入啊？完全不会！
你能不能给个完整的C++程序让我复制粘贴到软件里就能用啊？

追答

你问->怎么输入吗，↑是什么符号，
代码
#include "stdio.h"
#include "malloc.h"
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;

typedef char ElemType;
typedef struct BiTNode
ElemType data;
struct BiTNode *lchild,*rchild;//左右孩子指针
BiTNode,*BiTree;

Status CreateBiTree(BiTree &T)
// 按先序次序输入二叉树中结点的值（一个字符），’#’字符表示空树，
// 构造二叉链表表示的二叉树T。
char ch;
scanf("%c",&ch);
if (ch=='#') T = NULL;
else
if (!(T = (BiTNode *)malloc(sizeof(BiTNode)))) return ERROR;
T->data=ch; // 生成根结点
CreateBiTree(T->lchild); // 构造左子树
CreateBiTree(T->rchild); // 构造右子树

return OK;
// CreateBiTree

Status PrintElement( ElemType e ) // 输出元素e的值
printf("%c", e );
return OK;
// PrintElement

Status PreOrderTraverse( BiTree T, Status(*Visit)(ElemType) )

if(T)
if (Visit(T->data))
if (PreOrderTraverse(T->lchild,Visit))
if (PreOrderTraverse(T->rchild,Visit)) return OK;
return ERROR;


else return OK;

// PreOrderTraverse

Status InOrderTraverse( BiTree T, Status(*Visit)(ElemType) )

if (T)
if (InOrderTraverse(T->lchild,Visit))
if (Visit(T->data))
if (InOrderTraverse(T->rchild,Visit)) return OK;
return ERROR;

else return OK;

// InOrderTraverse

Status PostOrderTraverse( BiTree T, Status(*Visit)(ElemType) )
if (T)
if (PostOrderTraverse(T->lchild,Visit))
if (PostOrderTraverse(T->rchild,Visit))
if (Visit(T->data)) return OK;

return ERROR;
else return OK;

// PostOrderTraverse

int main() //主函数


BiTree T;

CreateBiTree(T);
PreOrderTraverse(T,PrintElement);
printf("\n");
InOrderTraverse(T,PrintElement);
printf("\n");
PostOrderTraverse(T,PrintElement);

追问

这明显是C语言麼……C++怎么写啊……我都快疯了，都看不懂，啥也不会……
我就想问出一套语句，我把它复制粘贴到程序软件里，然后交上去，就结束。
现在看来，我把你的这个复制粘贴一下，用我们用的C++的软件都不能Build，不知道为什么
还有，老师说是要做出一个程序……程序到底是什么？是一个.exe的文件？
要疯了要疯了……

追答

C和C++对于你要实现的东西来说差别不大，程序就是编译出来一个exe，你们老师是让你们出一个黑屏类似dos界面的exe程序。光图省事，老师是让你们好好学习
这样给你一个网址http://edu.codepub.com/2009/0805/12310.php，把这里面的代码粘贴到C++里面，注意分成三个文件，.h .cpp 还有个包含main函数的文件。