数据结构二叉树的递归与非递归遍历之java,javascript,php实现可编译（1）java

前一段时间，学习数据结构的各种算法，概念不难理解，只是被C++的指针给弄的犯糊涂，于是用java，web,javascript,分别去实现数据结构的各种算法。

二叉树的遍历，本分享只是以二叉树中的先序遍历为例进行说明，中序遍历和后序遍历，以此类推！

二叉树递归与非递归遍历的区别，虽然递归遍历，跟容易读懂，代码量少，运算快，但是却容易出现溢出的问题，所以所以非递归遍历，在处理千万级的运算量时会先的很有用处。

二叉树的先序遍历：先访问根节点，再访问先后访问左右节点。如图：

二叉树的递归遍历之java：

package rest;

//构造节点，生成一颗树
 class Node
{
     Node(String Letter){   //构造函数
         value=Letter;
    }
    public Node left;    //左节点
    public Node right;   //右节点
    public String  value; 
}
public class Test   
{
    public static void main(String[] args) 
    {
         //以下是构建上图中的二叉树，从根节点起一层一层的构建
           Node root  = new Node("A");
           Node first = new Node("B");
           Node second = new Node("C");
           Node third  = new Node("D");
           Node foth  = new Node("E");
           Node fifth  = new Node("F");
           Node sixth  = new Node("G");
           Node seventh  = new Node("H");
           Node eghit  = new Node("I");
           Node nineth  = new Node("G");
        //以下是建立二叉树之间的关系  
           root.left=first;
           root.right=second;
           first.left=third;
                   second.left=foth;
                   second.right=fifth;
                   third.right=seventh;
                   third.left=nineth;
                   foth.right=eghit;
                   

        //   Node root.left.left = new Node("D");
           Recursive(root);
        
    }

    //以下是二叉树递归遍历的主题代码算法函数
    public static void Recursive(Node node){
        if(node.value==""){
            System.out.println("这是一颗空树！");    //测试根节点是否为空，并且为程序的出口
        }else{
            System.out.print(node.value);
        }
        if(node.left!=null){
             Recursive(node.left);                  //递归左子树的节点
        }
        if(node.right!=null){
             Recursive(node.right);                 //递归右子树的节点
        }

    }
     
}

打印查来的结果为：

run:
ABDGHCEIF成功构建 (总时间: 0 秒)

二叉树非递归遍历,不用栈使O(1)之java：

package rest;

//构造节点，生成一颗树
 class Nod
{
     Nod(String Letter){   //构造函数
         value=Letter;
    }
    public Nod per;   //为了实现不用栈，使O(1),记录他的父节点
    public Nod left;    //左节点
    public Nod right;   //右节点
    public String  value; 
    public int flag=0;   //访问标志位
}
public class Cycles   
{
    public static void main(String[] args) 
    {
         //以下是构建上图中的二叉树，从根节点起一层一层的构建
           Nod root  = new Nod("A");
           Nod first = new Nod("B");
           Nod second = new Nod("C");
           Nod third  = new Nod("D");
           Nod foth  = new Nod("E");
           Nod fifth  = new Nod("F");      
           Nod sixth  = new Nod("G");
           Nod seventh  = new Nod("H");
           Nod eghit  = new Nod("I");
           Nod set    =new Nod("sdfsa");
        //以下是建立二叉树之间的关系  
                    root.left=first;
                    root.right=second;
                    first.per = root;
                    first.left=third;
               
                    
                    second.per=root;
                    second.left=foth;
                    second.right=fifth;
                    
                    third.per=first;
                    third.right=seventh;
                    third.left=sixth;
                    
                    foth.per=second;
                    foth.right=eghit;
                    fifth.per=second;
                 
                    sixth.per=third;
                    seventh.per=third;
                    eghit.per=foth;
                    
                      if(root==null){
             System.out.println("这是一颗空树");        
        }
        
        Nod index=root;
        while(index!=null){
            if(index.flag==0){
            System.out.print(index.value);
                
            index.flag=1;
            }
            if(index.left!=null&&index.left.flag==0){
                   index=index.left;  
               }else{
                     if(index.right!=null&&index.right.flag==0){
                         index=index.right;
                     }else{
                          index = index.per;    //回溯自己的父节点
                     }    
                   
               }
        }
        
        
                    
    }
}

run:
ABDGHCEIF成功构建 (总时间: 0 秒)

总结：我在调试这个的时候出现的几点问题：

我在回溯父节点的那段代码时，一开始尝试的是通过回溯父节点，然后再指向自己的子节点，判断是否为空，来测试代码是否运行到该行下，但是却行不通.

代码如下：

if(index.right==null){

System.out.print("代码可运行至此");

}else{

System.out.print("代码无法判断右节点");

}

但是结果却是，什么都没有显示，尼玛真的什么都没有显示。。。。我就无语了，好在不影响代码实现。

2.但是我在测试System.out.print(index.right.value);居然可以！居然可以！这一点还不太明白。

二叉树非递归遍历，使用栈之java：

 既然要用到栈，那就要说明一下栈是什么？？？栈无非就是先进后出的数据结构，我们可以引进import java.util.Stack;但是也可以自己写。

栈主要的操作有

1.public Stack()                        创建一个空堆栈类

2.public boolean empty()          带布尔返回值的函数，测试堆栈是否为空;

3.public  pop()                         弹出堆栈顶部的对象，并作为此函数的值返回该对象，输出 ，出栈操作

 4.public  push()                      压栈操作

 5.public  peek()                      查看堆栈顶部的对象，但不从堆栈中移除它。 起标记作用

 6.public boolean full()             满栈

package rest;

/**
 *
 * @author 曹想-
 */
class Stack 
    {
    private Nod2 StackArr[] ;
    private int top;
    public Stack(){
       this.top=-1;                      //之所以是以-1开始是因为数组是以0为开始
       this.StackArr = new Nod2[50];   //限定长度为50
    }
    public void push(Nod2 index){
        StackArr[++top]=index;
    }
    public Nod2 pop(){
                 return StackArr[top--];    //出栈操作
    }
    public boolean isempty(){             //判断是否为空
            return this.top==-1;
    }
  
}

class Nod2
{
     Nod2(String Letter){   //构造函数
         value=Letter;
    }
    public Nod2 left;    //左节点
    public Nod2 right;   //右节点
    public String  value; 
}

public class Test2{
 public static void main(String arg[]){
      //以下是构建上图中的二叉树，从根节点起一层一层的构建
           Nod2 root  = new Nod2("A");
           Nod2 first = new Nod2("B");
           Nod2 second = new Nod2("C");
           Nod2 third  = new Nod2("D");
           Nod2 foth  = new Nod2("E");
           Nod2 fifth  = new Nod2("F");      
           Nod2 sixth  = new Nod2("G");
           Nod2 seventh  = new Nod2("H");
           Nod2 eghit  = new Nod2("I");
           Nod2 set    =new Nod2("sdfsa");
        //以下是建立二叉树之间的关系  
                    root.left=first;
                    root.right=second;
              
                    first.left=third;
               
                  
                    second.left=foth;
                    second.right=fifth;
                   
                    third.right=seventh;
                    third.left=sixth;
                    
                  
                    foth.right=eghit;
                 
                 
                  
     //以下是利用栈的实现    
         Stack st = new Stack();
         if(root==null){
             System.out.println("这是一颗空树");
         }
  
          Nod2 index = root;
           while (index != null || !st.isempty()) {    //如果index为空说明节点遍历完了，栈为空说明已经完成遍历
            while (index != null) {        //先遍历左子树，并打印节点，将节入栈    
                System.out.print(index.value);    
                st.push(index);    
                index = index.left;    
            }    
            if (!st.isempty()) {    //将节点出栈，遍历右节点
                index = st.pop();    
                index = index.right;    
            }    
        }     
    }
}

非递归栈的另一种算法:

  Stack st = new Stack();
         if(root==null){
             System.out.println("这是一颗空树");
         }
       Nod2 index = root;
       int n=9;                       //这里的n是节点的个数，由一开始输入节点的个数决定
        while(n--!=0){  
              System.out.println(index.value);      //输出遍历节点值
              st.push(index);                               //将节点值入栈
             if(index.left!=null){
                  index = index.left;                    //遍历左节点
              }else{
                    while(!st.isempty()){              //栈不为空，则循环
                        Nod2 Tem = st.pop().right; //右节点不为空则设置右节点为index遍历
                        if(Tem!=null){
                            index =Tem;
                            break;
                        }
                    }
              }
      
        }

QQ：1689986723

欢迎批评指正！