/*
 *二叉樹的節(jié)點對象
 */
function Node() {
  this.text = '';      //節(jié)點的文本
  this.leftChild = null;  //節(jié)點的左孩子引用
  this.rightChild = null;  //節(jié)點右孩子引用
}

var charecters = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];
function buildTree(node, i) {
    var leftIndex = 2*i+1,             //左孩子節(jié)點的索引
      rightIndex = 2*i+2;             //右孩子節(jié)點的索引
    if(leftIndex < charecters.length) {       //判斷索引的長度是否超過了charecters數(shù)組的大小
      var childNode = new Node();         //創(chuàng)建一個新的節(jié)點對象
      childNode.text = charecters[leftIndex];   //給節(jié)點賦值
      node.leftChild = childNode;         //給當前節(jié)點node加入左孩子節(jié)點
      buildTree(childNode, leftIndex);      //遞歸創(chuàng)建左孩子
    }
    if(rightIndex < charecters.length) {      //下面注釋參照上面的構(gòu)建左孩子的節(jié)點
      var childNode = new Node();
      childNode.text = charecters[rightIndex];
      node.rightChild = childNode;
      buildTree(childNode, rightIndex);
    }
}
//下面構(gòu)造二叉樹
var node = new Node();
node.text = charecters[0];
buildTree(node, 0);  //索引i是從0開始構(gòu)建

var root;
function createBinaryTree() {
    var len = charecters.length,        //數(shù)組的長度
      index = 0,               //索引從0開始
      nodes = new Array();          //創(chuàng)建一個臨時數(shù)組，用于存放二叉樹節(jié)點
    //循環(huán)創(chuàng)建二叉樹節(jié)點存放到數(shù)組中
    for (var i = 0 ; i < charecters.length ; i++) {
      var node = new Node();
      node.text = charecters[i];
      nodes.push(node);
    }
    //循環(huán)建立二叉樹子節(jié)點的引用
    while(index < len) {
      var leftIndex = 2*index+1,       //當前節(jié)點左孩子索引
        rightIndex = 2*index+2;       //當前節(jié)點右孩子索引
      //給當前節(jié)點添加左孩子
      nodes[index].leftChild = nodes[leftIndex];
      //給當前節(jié)點添加右孩子
      nodes[index].rightChild = nodes[rightIndex];
      index++;
    }
    root = nodes[0];
}

function Stack() {
    var stack = new Array();        //存放棧的數(shù)組
    //壓棧
    this.push = function(o) {
      stack.push(o);
    };
    //出棧
    this.pop = function() {
      var o = stack[stack.length-1];
      stack.splice(stack.length-1, 1);
      return o;
    };
    //檢查棧是否為空
    this.isEmpty = function() {
      if(stack.length <= 0) {
        return true;
      }
      else {
        return false;
      }
    };
}
//使用方式如下
var stack = new Stack();
stack.push(1);    //現(xiàn)在棧中有一個元素
stack.isEmpty();   //false , 棧不為空
alert(stack.pop()); //出棧, 打印1
stack.isEmpty();   //true, 此時棧為空，因為在調(diào)用了stack.pop()之后元素出棧了，所以為空

function firstIteration(node) {
    if(node.leftChild) {          //判斷當前節(jié)點是否有左孩子
      firstIteration(node.leftChild);  //遞歸左孩子
    }
    if(node.rightChild) {         //判斷當前節(jié)點是否有右孩子
      firstIteration(node.rightChild);  //遞歸右孩子
    }
}
//遞歸遍歷二叉樹
firstIteration(root);

function notFirstIteration(node) {
    var stack = new Stack(),         //開辟一個新的棧對象
      resultText = '';           //存放非遞歸遍歷之后的字母順序
    stack.push(root);            //這個root在上面非遞歸方式構(gòu)建二叉樹的時候已經(jīng)構(gòu)建好的
    var node = root;
    resultText += node.text;
    while(!stack.isEmpty()) {
      while(node.leftChild) {       //判斷當前節(jié)點是否有左孩子節(jié)點
        node = node.leftChild;      //取當前節(jié)點的左孩子節(jié)點
        resultText += node.text;     //訪問當前節(jié)點
        stack.push(node);        //將當前節(jié)點壓入棧中
      }
      stack.pop();             //出棧
      node = stack.pop().rightChild;    //訪問當前節(jié)點的兄弟節(jié)點（右孩子節(jié)點）
      if(node) {              //當前節(jié)點的兄弟節(jié)點不為空
        resultText += node.text;     //訪問當前節(jié)點
        stack.push(node);        //將當前節(jié)點壓入棧中
      }
      else {                //當前節(jié)點的兄弟節(jié)點為空
        node = stack.pop();       //在回溯到上一層
      }
    }
}
//非遞歸先序遍歷
notFirstIteration(root);

var strText = "";
function secondIteration(node) {
    //訪問左節(jié)點
    if(node.leftChild) {
      if(node.leftChild.leftChild) {
        secondIteration(node.leftChild);
      }
      else {
        strText += node.leftChild.text;
      }
    }
    //訪問根節(jié)點
    strText += node.text;
    //訪問右節(jié)點
    if(node.rightChild) {
      if(node.rightChild.leftChild) {
        secondIteration(node.rightChild);
      }
      else {
        strText += node.rightChild.text;
      }
    }
}
secondIteration(root);
alert(strText);

function notSecondIteration() {
    var resultText = '',
      stack = new Stack(),
      node = root;
    stack.push(node);
    while(!stack.isEmpty()) {
      //從根節(jié)點一直往下找左孩子節(jié)點直到最后一個左孩子節(jié)點，然后保存在棧中
      while(node.leftChild) {
        node = node.leftChild;
        stack.push(node);
      }
      //彈出棧
      var tempNode = stack.pop();
      //訪問臨時節(jié)點
      resultText += tempNode.text;
      if(tempNode.rightChild) {
        node = tempNode.rightChild;
        stack.push(node);
      }
    }
    alert(resultText);
}

var strText = '';
function lastIteration(node) {
    //首先訪問左孩子節(jié)點
    if(node.leftChild) {
      if(node.leftChild.leftChild) {
        lastIteration(node.leftChild);
      }
      else {
        strText += node.leftChild.text;
      }
    }
    //然后再訪問右孩子節(jié)點
    if(node.rightChild) {
      if(node.rightChild.rightChild) {
        lastIteration(node.rightChild);
      }
      else {
        strText += node.rightChild.text;
      }
    }
    //最后訪問根節(jié)點
    strText += node.text;
}
//中序遞歸遍歷
lastIteration(root);
alert(strText);

function notLastIteration() {
    var strText = '',
    stack = new Stack();
    nodo = root;
    stack.push(node);
    while(!stack.isEmpty()) {
      while(node.leftChild) {
        node = node.leftChild;
        stack.push(node);
      }
      //彈出棧
      var tempNode = stack.pop();
      //訪問左孩子節(jié)點
      strText += tempNode.text;
      //訪問右孩子節(jié)點
      if(tempNode.rightChild) {
        if(tempNode.rightChild.leftChild || tempNode.rightChild.rightChild) { //判斷最后一個左孩子節(jié)點的兄弟節(jié)點是否為頁節(jié)點
          stack.push(tempNode.rightChild);
        }
        else {
          strText += tempNode.rightChild.text;
        }
      }
    }
    alert(strText);
}