二叉算法
1. 二叉树算法是什么
二叉树是每个节点最多有两个子树的有序树。通常子树被称作“左子树”(left subtree)和“右子树”(right subtree)。二叉树常被用于实现二叉查找树和二叉堆。
性质
1、在二叉树中，第i层的结点总数不超过2^(i-1)。
2、深度为h的二叉树最多有2^h-1个结点（h>=1)，最少有h个结点。
3、对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1。
2. 二叉树 算法
原因就在于Status CreatBitTree(BitTree e) 这个函数的参数BitTree e，既然e是参数，因此你在函数体内用e=NULL; 及e=(BitTree)malloc(sizeof(BitNode)); 来给e赋值都是没有用的，赋值不会返回给调用处。修改的话改成引用就可以了。也就是把Status CreatBitTree(BitTree e) 这一行改成Status CreatBitTree(BitTree &e) 就行了。
还有：二叉树算法递归中序输入是abc##de#g##f### （你这应该是前序输入吧？）
3. 请写出计算二叉树的深度的算法
typedef struct tree//二叉树的定义
{ char data; struct tree *lchild,*rchild; }TREE,*Tree;
void create(Tree t)//创建一棵二叉树
{ char ch; scanf("%c",&ch); if(ch=='#') t=NULL;
else { t->data=ch; create(t->lchild); create(t->rchild); }
}
int deep(Tree t)//深度算法
{ if(!t) return 0; else { ld=deep(t->lchild); rd=deep(t->rchild);
if(ld>rd) return rd+1; else return ld+1;
}
void main()//主函数
{ Tree t; create(t); printf("%d\n",deep(t)); }
4. 二叉树结点的算法
一个结点的度是指该结点的子树个数。
度为1就是指只有1个子树（左子树或者右子树）。
度为2的结点个数=叶结点个数-1=69
该二叉树的总结点数=70+80+69=219
5. 二叉树算法如何学习
理解是关键，多看书，有条件上机，对理解有帮助，慢慢就会了！！！
加油啊！！！
6. 建立二叉树的二叉链表算法
CreateBinTree(BiTree *T) *T 是一个指针， 指向T 。 输入 0 不就退出了。不过需要多输入几次。
7. 编写一个递归算法，将二叉链表表示的二叉树，判断两个二叉树是否相同的算法
判断二叉树是否为完全二叉树。完全二叉树的定义是，前n-1层都是满的，第n层如有空缺，则是缺在右边，即第n层的最右边的节点，它的左边是满的，右边是空的。以3层二叉树为例，以下情况为完全二叉树：[方法一]这个问题的描述已经提示了解法，采用广度优先遍历，从根节点开始，入队列，如果队列不为空，循环。遇到第一个没有左儿子或者右儿子的节点，设置标志位，如果之后再遇到有左/右儿子的节点，那么这不是一颗完全二叉树。这个方法需要遍历整棵树，复杂度为O(N)，N为节点的总数。//二叉树结点定义typedefstructNode{intdata;structNode*left;structNode*right;}Node;//实现广度遍历需要队列Queuequeue;//第n层最右节点标志boolleftMost=false;boolProcessChild(Node*child){if(child){if(!leftMost){queue.push(child);}else{returnfalse;}}else{leftMost=true;}returntrue;}boolIsCompleteBinaryTree(Node*root){//空树也是完全二叉树if(!root)returntrue;//首先根节点入队列queue.push(root);while(!queue.empty()){Node*node=queue.pop();//处理左节点if(!ProcessChild(node->left))returnfalse;//处理右节点if(!ProcessChild(node->right))returnfalse;}//广度优先遍历完毕，此乃完全二叉树returntrue;}[方法二]根据完全二叉树的定义，左边的深度>=右边的深度。从根节点开始，分别沿着最左最右分支下去，找到最左和最右的深度。如果左边比右边深1，再分别检查以左儿子和右儿子为根的两根树。有点递归的感觉了。[Tobecontinued]
8. 二叉树的算法
用栈来实现。
9. 二叉树深度的算法
#include"stdio.h"
#include"alloc.h"
typedef
char
datatype;
typedef
struct
node
{
datatype
data;
struct
node
*lchild,
*rchild;
}
bitree;
int
k
=
1;
bitree
*Q[10];
bitree
*CREAT()
{
char
ch;
int
front,
rear;
bitree
*root,
*s;
root
=
NULL;
front
=
1;
rear
=
0;
printf("\n
=======二叉树的建立和遍历=======\n");
printf("
请输入字符:
");
ch
=
getchar();
while
(ch
!=
'$')
{
s
=
NULL;
if
(ch
!=
'@')
{
s
=
malloc(sizeof(bitree));
s
->
data
=
ch;
s
->
lchild
=
NULL;
s
->
rchild
=
NULL;
}
rear++;
k
=
k++;
Q[rear]
=
s;
if
(rear
==
1)
root
=
s;
else
{
if
(s
&&
Q[front])
if
(rear
%
2
==
0)
Q[front]
->
lchild
=
s;
else
Q[front]
->
rchild
=
s;
if
(rear
%
2
==
1)
front++;
}
ch
=
getchar();
}
return
root;
}
int
COUNTER(t)
bitree
*t;
{
if
(t
==
NULL)
return
0;
else
if
(t->lchild
!=
NULL
&&
t->rchild
==
NULL
||
t->lchild
==
NULL
&&
t->rchild
!=
NULL)
return
1;
else
return
COUNTER(t->lchild)
+
COUNTER(t->rchild);
}
main()
{
int
i;
bitree
*p;
p
=
CREAT();
printf("
建立的二叉树为:
");
for
(i
=
0;
i
<
k;
i++)
{
printf("%c
",
Q[i]
->
data);
}
printf("\n
度为1的节点数为:
");
printf("%d
",
COUNTER(p));
}
这是二叉树的建立
遍历
加二叉树的度为1的结点的算法
10. 二叉排序算法的实现
#include<iostream>
#include<deque>
#include<algorithm>
using namespace std;
struct BinaryNode
{
char ch;//数据域
BinaryNode *leftChild;//左子节点
BinaryNode *rightChild;//右子节点
BinaryNode(BinaryNode *left=NULL,BinaryNode *right=NULL)
{
rightChild=right;
leftChild=left;
}
BinaryNode(char chz,BinaryNode *left=NULL,BinaryNode *right=NULL)
{
ch=chz;
leftChild=left;
rightChild=right;
}
};
class BinaryTree
{
private:
BinaryNode *root; //根节点
char ref;
void preOrder(BinaryNode *p); //前序遍历
void levelOrder(BinaryNode *p); //层序遍历
void CreateTree(BinaryNode *&p); //根据前序遍历建立二叉树
void deleteTree(BinaryNode *p); //释放二叉树
BinaryNode* CreateBinary(char *VLR,char *LVR,int preStart,int inStart,int n); //根据二叉树的前序遍历和中序遍历建立二叉树
public:
BinaryTree(){root=NULL;ref='#';} //建立空二叉树
~BinaryTree(); //析构函数
void preOrder(); //前序遍历
void levelOrder(); //层序遍历
void CreateTree(); //根据前序遍历建立二叉树
void CreateBinary(char *VLR,char *LVR,int n); //用二叉树的前序遍历与后序遍历建立二叉树
};
void BinaryTree::deleteTree(BinaryNode *p)
//私有函数,释放二叉树
{
if(p!=NULL)
{
deleteTree(p->leftChild);
deleteTree(p->rightChild);
delete p;
}
}
BinaryTree::~BinaryTree() //析构函数
{
deleteTree(root);
}
void BinaryTree::preOrder(BinaryNode *p) //私有函数，前序遍历
{
if(p!=NULL)
{
cout<<p->ch<<" ";
preOrder(p->leftChild);
preOrder(p->rightChild);
}
}
void BinaryTree::preOrder() //前序遍历
{
preOrder(root);
}
void BinaryTree::levelOrder(BinaryNode *p) //私有函数，层序遍历
{
deque<BinaryNode*> level; //利用队列实现
BinaryNode *q=NULL;
if(p!=NULL)
{
level.push_back(p);
}
while(!level.empty())
{
q=level.front();
cout<<q->ch<<" ";
level.pop_front();
if(q->leftChild!=NULL)
level.push_back(q->leftChild); //左子树入队列
if(q->rightChild!=NULL)
level.push_back(q->rightChild); //右子树入队列
}
}
void BinaryTree::levelOrder() //层序遍历
{
levelOrder(root);
}
void BinaryTree::CreateTree(BinaryNode *&p) //引用型参数的的用法*&p
{
char item;
cout<<"请输入节点值: ";
cin>>item;
if(item!=ref) //结束标记ref
{
p=new BinaryNode(item);
CreateTree(p->leftChild); //递归建立左子树
CreateTree(p->rightChild); //递归建立右子树
}
else
p=NULL;
}
void BinaryTree::CreateTree()
{
CreateTree(root);
}
BinaryNode* BinaryTree::CreateBinary(char* VLR,char* LVR,int preStart,int inStart,int n) //私有函数，利用二叉树的前序遍历与中序遍历建立二叉树
{
BinaryNode *p=NULL;
if(n>0)
{
char elem=VLR[preStart];
p=new BinaryNode(elem);
int i=0;
while(i<n&&elem!=LVR[inStart+i])
i++;
p->leftChild=CreateBinary(VLR,LVR,preStart+1,inStart,i);
p->rightChild=CreateBinary(VLR,LVR,preStart+i+1,inStart+i+1,n-i-1);
}
return p;
}
void BinaryTree::CreateBinary(char *VLR,char *LVR,int n) //利用二叉树的前序遍历与中序遍历建立二叉树
{
root=CreateBinary(VLR,LVR,0,0,n);
}
int main()
{
BinaryTree tree;
tree.CreateTree();
cout<<"该二叉树的前序遍历为: ";
tree.preOrder();
cout<<endl;
cout<<"该二叉树的层遍序历为: ";
tree.levelOrder();
cout<<endl;
return 0;
}