第壹步:選擇省市。您可以選擇單個城市，選中多個城市，或者單擊全選以選擇所有城市。
第二步:選擇相應的類型。您可以同時選擇其中的壹個或兩個，也可以全部選中。
第三步:設置生成數字的數量。您可以設置不同的數字級別，並且生成的數字不會重復。
第四步:點擊並開始生成。
-分界線。
# include & ltiostream & gt
使用命名空間std
# include & ltstdlib.h & gt
模板& ltT類>。
結構綁定treenode {//鏈式二叉樹節點結構
測試數據；
BinTreeNode & ltT & gt*leftChild，* rightChild
BinTreeNode（）:left child（NULL），right child（NULL）{ }
BinTreeNode（T x，BinTreeNode & ltT & gt*l=NULL，BinTreeNode & ltT & gt* r =空值）
:data（x），left child（l），right child（r）{ }
};
模板& ltT類>。
類BinaryTree{//鏈式二叉樹類
公共:
binary tree（）:root（null）{ }/構造函數
二叉樹（tvalue）:引用值（value），根（NULL）{ }//構造函數（空節點標誌值）
~ binary tree（）{ if（root）destroy（root）；}//析構函數
朋友團隊。操作員& gt& gt& ltT & gt（istream & ampin，BinaryTree & ltT & gt& amp樹）；
虛空？preOrder（void（* visit）（BinTreeNode & lt；T & gt* & ampp））//Preorder遍歷，visit是訪問函數。
{ preOrder（root，visit）；}
虛空？in order（void（* visit）（BinTreeNode & lt；T & gt* & ampp）//遍歷
{ in order（root，visit）；}
void post order（void（* visit）（BinTreeNode & lt；T & gt* & ampp）//後序遍歷
{ post order（root，visit）；}?
binary tree（binary tree & lt；T & gt& amps）{ root = Copy（s . root）；}//復制構造函數並調用Copy。
bool IsEmpty（）{ return root = = NULL；}//判斷樹是否為空
BinTreeNode & ltT & gt* Parent（BinTreeNode & lt；T & gt* current）{//返回父節點。
if（root = = NULL | | root = = current）返回NULL；//調用同名的保護成員函數。
else返回Parent（根，當前）；
}
BinTreeNode & ltT & gt* left child（BinTreeNode & lt；T & gt* current）//返回左側子級。
{ return（當前！=NULL）？當前-& gt；left child:NULL；}
BinTreeNode & ltT & gt* right child（BinTreeNode & lt；T & gt* current）//返回正確的子級。
{ return（當前！=NULL）？當前-& gt；right child:NULL；}
int Height（）{ return Height（root）；}//返回樹的高度並調用同名的保護成員函數。
int Size（）{ return Size（root）；}//返回樹中的節點數，並調用同名的保護成員函數。
BinTreeNode & ltT & gt* getRoot（）const { return root；}//生根
void createBinaryTree（）；
受保護:
BinTreeNode & ltT & gt*根；//二叉樹的根指針
T RefValue//數據輸入停止標誌，標記空節點。
void銷毀（BinTreeNode & ltT & gt* & amp子樹）；//p196刪除樹以使其為空。
void CreateBinTree（istream & amp；在，BinTreeNode & ltT & gt* & amp子樹）；//P202構建二叉樹的前言
void preOrder（BinTreeNode & lt；T & gt* & amp子樹，void（* visit）（BinTreeNode & lt；T & gt* & ampp）；//p199前序遍歷，訪問的是訪問函數。
void in order（BinTreeNode & lt；T & gt* & amp子樹，void（* visit）（BinTreeNode & lt；T & gt* & ampp）；//p199中間順序遍歷，訪問的是訪問函數。
void post order（BinTreeNode & lt；T & gt* & amp子樹，void（* visit）（BinTreeNode & lt；T & gt* & ampp）；//p200後序遍歷，訪問的是訪問函數。
BinTreeNode & ltT & gt*復制（BinTreeNode & ltT & gt*);//p201 copy-？
BinTreeNode & ltT & gt* Parent（BinTreeNode & lt；T & gt*，BinTreeNode & ltT & gt*);
//p196返回父節點，重載函數-？
int Height（BinTreeNode & lt；T & gt*）常量；//p200返回樹的高度，重載函數-？
int Size（BinTreeNode & lt；T & gt*）常量；//p200返回樹中的節點數。重載函數-？
牡蠣之友。操作員& lt& lt& ltT & gt（牡蠣公司；out，BinaryTree & ltT & gt& amp樹）；
void遍歷（BinTreeNode & ltT & gt*、ostream & amp);//p196前言遍歷輸出-？
友布爾運算符= = & ltT & gt（const BinaryTree & ltT & gt& amps，const BinaryTree & ltT & gt& ampt）；//確定二叉樹是否相等
BinTreeNode & ltT & gt* createBinaryTree（T * inlist，T* postlist，int i，int j，int k，int l）；
};
模板& ltT類>。
伊斯特蘭公司。操作員& gt& gt（istream & ampin，BinaryTree & ltT & gt& amp樹）
{樹。CreateBinTree（in，tree . root）；返回；}//重載操作，輸入
模板& ltT類>。//後序遍歷刪除
void BinaryTree & ltT & gt* destroy（BinTreeNode & lt；T & gt* & amp子樹）{
if（subTree = = NULL）返回；
銷毀（子樹-》；left child）；
銷毀（子樹-》；right child）；
刪除子樹；子樹= NULL
}
//CreateBinTree的實現（遞歸前序遍歷構建二叉樹，P202）；
模板& ltT類>。
void BinaryTree & ltT & gt* CreateBinTree（istream & amp；在，BinTreeNode & ltT & gt* & amp子樹）
{
測試項目；
如果(！in.eof（）中
{
在& gt& gt項目；
if（item！=RefValue）
{
subTree = new BinTreeNode & ltT & gt（項）；
if（子樹==NULL）
{ cerr & lt& lt“存儲分配錯誤！“& lt& ltendl退出（1）；}
create bintree（in，subTree-& gt；left child）；
create bintree（in，subTree-& gt；right child）；？
}
else子樹= NULL
}
};
//實現前序（遞歸前序遍歷，p 199）；
模板& ltT類>。
void BinaryTree & ltT & gt*預訂（BinTreeNode & ltT & gt* & amp子樹，void（* visit）（BinTreeNode & lt；T & gt* & ampp）
{
if（子樹！=NULL）
{
訪問（子樹）；
前序（子樹-》；leftChild，訪問）；
前序（子樹-》；rightChild，訪問）；
}
};
//（in order，p 199）；
模板& ltT類>。
void BinaryTree & ltT & gt* in order（BinTreeNode & lt；T & gt* & amp子樹，void（* visit）（BinTreeNode & lt；T & gt* & ampp）
{
if（子樹！=NULL）
{
有序（子樹-& gt；leftChild，訪問）；
訪問（子樹）；
有序（子樹-& gt；rightChild，訪問）；
}
};
//後序的實現（遞歸後序遍歷，p200）。
模板& ltT類>。
void BinaryTree & ltT & gt* post order（BinTreeNode & lt；T & gt* & amp子樹，void（* visit）（BinTreeNode & lt；T & gt* & ampp）
{
if（子樹！=NULL）
{
後序（子樹-& gt；leftChild，訪問）；
後序（子樹-& gt；rightChild，訪問）；
訪問（子樹）；
}
};
//copy的實現（copy，p 201）；
模板& ltT類>。
BinTreeNode & ltT & gt*BinaryTree<T & gt* Copy（BinTreeNode & lt；T & gt* origin node）
{
if（origin node = = NULL）返回NULL；
BinTreeNode & ltT & gt* temp = new BinTreeNode & ltT & gt；
溫度-& gt；data = origin node-& gt；數據；
溫度-& gt；left child = Copy（origin node-& gt；left child）；
溫度-& gt；right child = Copy（origin node-& gt；right child）；
返回溫度；
};
//parent的實現（返回父節點，p 196）；
模板& ltT類>。
BinTreeNode & ltT & gt*雙星樹& ltT & gt* Parent（BinTreeNode & lt；T & gt*子樹，BinTreeNode & ltT & gt*當前）
{
if（subTree = = NULL）返回NULL；
if（子樹-》；leftChild = = current | |子樹-& gt；rightChild==current）
返回子樹；
BinTreeNode & ltT & gt* p；
if（（p = Parent（subTree-& gt；leftChild，當前）！=NULL）返回p；
否則返回父節點（子樹-& gt；rightChild，現任）；
};
//執行高度（返回樹高，p200）；
模板& ltT類>。
int BinaryTree & ltT & gt*高度（BinTreeNode & ltT & gt*子樹）常量
{
if（subTree = = NULL）返回0；
其他
{
int i=Height（子樹-》；left child）；
int j=Height（子樹-》；right child）；
return（I & lt；j）？j+1:I+1；
}
};
//Size（返回樹中的節點數，p200）的實現；
模板& ltT類>。
int BinaryTree & ltT & gt*大小（BinTreeNode<。T & gt*子樹）常量
{
if（subTree = = NULL）返回0；
否則返回1+大小（子樹-》；left child）+Size（子樹-& gt；right child）；
};
//輸出樹，重載
模板& ltT類>。
牡蠣和牡蠣。操作員& lt& lt（牡蠣公司；out，BinaryTree & ltT & gt& amp樹）{
out & lt& lt”二叉樹的有序遍歷\ n”；
樹。遍歷（Tree.root，out）；
out & lt& ltendl
返回出去；
}
//實現//遍歷（前序遍歷輸出，p 196）；
模板& ltT類>。
void BinaryTree & ltT & gt*遍歷（BinTreeNode & ltT & gt*subTree、ostream & ampout）
{
if（子樹！=NULL）
{
out & lt& lt子樹-& gt；數據& lt& lt' ';
遍歷（子樹-》；leftChild，out）；
遍歷（子樹-》；rightChild，out）；
}
};
//確定二叉樹是否相等
模板& ltT類>。
bool運算符= =（const binary tree & lt；T & gt& amps，const BinaryTree & ltT & gt& ampt)
{
return（equal（s根，t根））？真:假；
};
//判斷節點是否相等
模板& ltT類>。
bool equal（BinTreeNode & lt；T & gt*a，BinTreeNode & ltT & gt*b）
{
if（a = = NULL & amp；& ampb==NULL）返回true
如果(a！= NULL & amp& ampb！= NULL & amp& ampa-& gt；data = = b-& gt；數據
& amp& amp相等（a-》；leftChild，b-& gt；leftChild）
& amp& amp相等（a-》；rightChild，b-& gt；rightChild））
返回true
否則返回false
};
模板& ltT類>。
//主調程序:利用中序和後序構造二叉樹。
void BinaryTree & ltT & gt* createBinaryTree（）
{
int n；
cout & lt& lt“輸入二叉樹中的節點數n =“；
CIN & gt；& gtn；
T * inlist = new T【n+1】；
cout & lt& lt”輸入二叉樹的中間序列:“；
CIN & gt；& gtinlist
T * post list = new T【n+1】；
cout & lt& lt”輸入二叉樹的後序序列:“；
CIN & gt；& gt後置列表；
root = createBinaryTree（inlist，postlist，int i，int j，int k，int l）；
};
模板& ltT類>。
BinTreeNode & ltT & gt* createBinaryTree（T * inlist，T* postlist，int i，int j，int k，int l）
{
int n；
BintreeNode * p；
p =（BinTreeNode *）malloc（大小為（BinTreeNode））；
p-》；data = *（postlist+1）；//從後續遍歷序列中讀取節點信息
n = 1；
for(；*（inlist+n）！= *（postlist+1）；n++；）//確定節點在中間序列遍歷序列中的位置
if（n = = I）p-》；leftChild = NULL
其他
p-》；left child = * createBinaryTree（inlist，postlist，I，n-1，k，k+n-I-1）；//遞歸調用左邊的子樹
如果（n==j）
p-》；rightChild = NULL
其他
p-》；right child = * createBinaryTree（inlist，postlist，n+1，j，k+n-i，l-1）；//遞歸調用右邊的子樹
return p；
}
。cpp如下所示:
# include & ltiostream & gt
使用命名空間std
#包含“aaaa.h”
模板& ltT類>。//輸出二叉樹節點的數據
無效訪問（BinTreeNode & ltT & gt* & ampp）{ cout & lt；& ltp-》；數據；}
void main（）
{
雙星樹& ltchar & gtBT；
Bt . createbinarytree（）；
cout & lt& lt”前言遍歷輸出二叉樹:\ n”；
BT.preOrder（訪問）；
cout & lt& ltendl
}