非递归建立二叉树
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了非递归建立二叉树相关的知识，希望对你有一定的参考价值。
链栈
//****************标记建立右子树采取标记
//0左右子树都未建立
//1建立左子树
//2建立右子树
void creatBiTree1(BiTree & tree)
char c;
int flag[20] = 0;
stack<BiTree> stack;
if(cin>>c && c!= '#')
tree = (BiTree)malloc(sizeof(BiTNode));//大根节点
tree->data = c;
stack.push(tree);
else
tree = NULL;
while(!stack.empty())//堆栈不为空
BiTree t = stack.top();
if(cin>>c && c!='#')//伸展
BiTree temp = (BiTree)malloc(sizeof(BiTNode));
temp->data = c;
if(flag[stack.size()]==0)//左子树未建立
t->lchild = temp;
flag[stack.size()]=1;
stack.push(temp);
else //已建立左子树
t->rchild = temp;
flag[stack.size()]=2;
stack.push(temp);
else //回缩
if(flag[stack.size()]==1)
t->rchild = NULL;
flag[stack.size()]=0;
stack.pop();
while(flag[stack.size()]==2 && !stack.empty())
flag[stack.size()]=0;
stack.pop();
else
flag[stack.size()]=1;
t->lchild = NULL;
参考技术A / *建立二进制* /
＃包括使用非递归方法“stdio.h中”
＃定义最大100
的typedef char数据类型;
typedef结构节点
数据类型的数据;
结构节点* lchild，* rchild;
二叉树;
二叉树* Q [MAX];
二叉树* CREATREE（）
字符CH;
整型前，后;
*二叉树的根，* S;
根= NULL;
前= 1;后部= 0;
的printf（“\ t \ t按顺序输入序列\ n中完全二叉树结点号”）;
的printf（“\ t \ t请注意：与空结'@'表示进入以'＃'结束\\吨\吨序列”）;
CH = getchar函数（）;
而（ch! ='＃'）
S = NULL;
如果（ch! ='@'）
S =（二叉树*）malloc的（的sizeof（二叉树））;
S->数据= CH;
S-> lchild = NULL;
S-> rchild = NULL;
后+ +;
Q [后] = S;
如果（后== 1）
根= S;
如果（S && Q [前端]）
如果（后部％2 == 0）
Q [前方] - > lchild = S;
Q [前方] - > rchild = S;
如果（后部％2 == 1）前+ +;
CH = getchar函数（）;
返回根;
无效的主要（）
*二叉树树;
树= CREATREE（）;
的printf（“\ n”）;
/ /但是编译器好像有问题VC + +6.0本回答被提问者采纳
超强二叉树解析.必收藏！(数组,链表实现,8种遍历方法,前,中,后序线索化二叉树及其遍历)---风之java
二叉树
链表实现
先创建一个节点类
public class TreeNode {
int value;//数据
TreeNode left;//指向左子树
TreeNode right;//指向右子树
public TreeNode(){}
public TreeNode(int value){
this.value=value;
left=null;
right=null;
}
}
利用数组建立二叉树
利用递归一一将数组中的数全部存储到二叉树中建立二叉树
public TreeNode create(char[] arr,int index){
if(index>=arr.length){
return null;
}else{
TreeNode tmpNode=new TreeNode((int)(arr[index]));
tmpNode.left=create(arr,2*index);
tmpNode.right=create(arr,2*index+1);
return tmpNode;
}
}
整体代码实现
```java
public class BinaryTree {
public TreeNode root;
public TreeNode(){}
public BinaryTree(char[] ch,int index){
root=create(ch,index);
}
//将数组表示法转换为链表表示法
public TreeNode create(char[] arr,int index){
if(index>=arr.length){
return null;
}else{
TreeNode tmpNode=new TreeNode((int)(arr[index]));
tmpNode.left=create(arr,2*index);
tmpNode.right=create(arr,2*index+1);
return tmpNode;
}
}
直接添加元素，建立二叉排序树
public void add(int data){
TreeNode newNode=new TreeNode(data);
//建立树根
if(root==null){
root=newNode;
return;
}
TreeNode cur=root;
while(true){
if(newNode.value<cur.value){
if(cur.left==null){
cur.left=newNode;
return;
}else{
cur=cur.left;
}
}else{
if(cur.right==null){
cur.right=newNode;
return;
}else{
cur=cur.right;
}
}
}
}
二叉树的搜索
可以看到二叉树的搜索是建立在二叉排序树的基础上
//查找该二叉树上是否含有该元素
public boolean findTreeNode(TreeNode root,int value){
if(root==null){
return false;
}else{
if(root.value==value){
return true;
}else{
if(value<root.value){
count++;
return findTreeNode(root.left,value);
}else{
count++;
return findTreeNode(root.right,value);
}
}
}
}
二叉运算树
先创建一个节点类
public class TreeNode {
int value;
TreeNode left;
TreeNode right;
public TreeNode(){}
public TreeNode(int data){
this.value=data;
left=null;
right=null;
}
}
接下来实现二叉运算树
public class BinaryTree {
public TreeNode root;
public BinaryTree(char[] ch,int index){
root=create(ch,index);
}
//添加元素
public void add(int data){
TreeNode newNode=new TreeNode(data);
if(root==null){
root=newNode;
return;
}
TreeNode cur=root;
while(true){
if(newNode.value<cur.value){
if(cur.left==null){
cur.left=newNode;
return;
}else {
cur=cur.left;
}
}else{
if(cur.right==null){
cur.right=newNode;
return;
}else{
cur=cur.right;
}
}
}
}
//将数组表示法转换为链表表示法
public TreeNode create(char[] arr,int index){
if(index>=arr.length){
return null;
}else{
TreeNode tmpNode=new TreeNode((int)(arr[index]));
tmpNode.left=create(arr,2*index);
tmpNode.right=create(arr,2*index+1);
return tmpNode;
}
}
//判断表达式如何运算的方法声明
public int condition(char ch,int n1,int n2){
switch(ch){
case '+': return n1+n2;
case '-': return n1-n2;
case '*': return n1*n2;
case '/': return n1/n2;
case '%': return n1%n2;
default: return -1;
}
}
//计算二叉运算树的值
public int answer(TreeNode root){
int first=0;
int second=0;
if(root.left==null&&root.right==null){
return Character.getNumericValue((char)root.value);
}else{
first=answer(root.left);
second=answer(root.right);
return condition((char)root.value,first,second);
}
}
//中序表示法
public void inOrder(TreeNode root){
if(root!=null){
inOrder(root.left);
System.out.print((char)root.value+" ");
inOrder(root.right);
}
}
//后序表示法
public void postOrder(TreeNode root){
if(root!=null){
postOrder(root.left);
postOrder(root.right);
System.out.print((char)root.value+" ");
}
}
//前序表示法
public void preOrder(TreeNode root){
if(root!=null){
System.out.print((char)root.value+" ");
preOrder(root.left);
preOrder(root.right);
}
}
}
前序遍历递归实现
//前序遍历
public void preOrder1(TreeNode root){
if(root!=null){
System.out.print(root.value+" ");
preOrder1(root.left);//遍历左子树
preOrder1(root.right);//遍历右子树
}
}
前序遍历非递归实现
解法一
利用堆栈的性质
//前序遍历非递归1
public void preOrder2(TreeNode cur){
Stack<TreeNode> stack=new Stack<>();
while(cur!=null||!stack.isEmpty()){
while(cur!=null){
stack.add(cur);
System.out.print(cur.value+" ");
cur=cur.left;
}
cur=stack.pop();
cur=cur.right;
}
}
解法二
将元素按照前序遍历的顺序压入栈中，再依次弹出即可
//前序遍历非递归2
public void preOrder3(TreeNode cur){
Stack<TreeNode> stack=new Stack<>();
stack.add(cur);
while(!stack.isEmpty()){
cur=stack.pop();
System.out.print(cur.value+" ");
if(cur.right!=null)
stack.add(cur.right);
if(cur.left!=null)
stack.add(cur.left);
}
}
中序遍历递归实现
//中序遍历
public void inOrder1(TreeNode root){
if(root!=null){
inOrder1(root.left);//处理左子树
System.out.print(root.value+" ");
inOrder1(root.right);//处理右子树
}
}
中序遍历非递归实现
和前序遍历的非递归实现一样，只不过是交换了打印顺序。
//中序遍历非递归
public void inOrder2(TreeNode cur){
Stack<TreeNode> stack=new Stack<>();
while(cur!=null||!stack.isEmpty()){
while(cur!=null){
stack.add(cur);
cur=cur.left;
}
cur=stack.pop();
System.out.print(cur.value+" ");
cur=cur.right;
}
}
后序遍历递归实现
//后序遍历
public void postOrder1(TreeNode root){
if(root!=null){
postOrder1(root.left);//处理左子树
postOrder1(root.right);//处理右子树
System.out.print(root.value+" ");
}
}
后序遍历非递归实现
后序遍历较为复杂，需要用到栈的性质，且用 cur 来判断打印树叶，用 pre 来记录左或右节点来判断是否打印父节点
public void postOrder2(TreeNode cur){
if(cur==null)
return;
Stack<TreeNode> stack=new Stack<>();
TreeNode pre=null;
stack.add(cur);
while(!stack.isEmpty()){
cur=stack.peek();
if((cur.left==null&&cur.right==null)||(pre!=null&&(pre==cur.left||pre==cur.right))){
System.out.print(cur.value+" ");
stack.pop();
pre=cur;
}else{
if(cur.right!=null)
stack.add(cur.right);
if(cur.left!=null)
stack.add(cur.left);
}
}
}
层序遍历递归实现
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result = new ArrayList<List<Integer>>();
helper(root, 0, result);
return result;
}
public void helper(TreeNode root, int level, List<List<Integer>> lists) {
if (root == null) {
return;
}
if (lists.size() < level + 1) {
lists.add(new ArrayList<Integer>());
}
lists.get(level).add(root.val);
helper(root.left, level + 1, lists);
helper(root.right, level + 1, lists);以上是关于非递归建立二叉树的主要内容，如果未能解决你的问题，请参考以下文章