js:数据结构笔记9--二叉树

树：以分层的方式存储数据；节点：根节点，子节点，父节点，叶子节点（没有任何子节点的节点）；层：根节点开始0层；

二叉树：每个节点子节点不超过两个；查找快（比链表），添加，删除快（比数组）；

BST：二叉树查找：

• 设置根节点为当前节点；
• 如果要插入的节点小于当前节点，则设置其左节点为新的当前节点；大于的话选右节点；
• 如果如果选择的节点为null，则将要插入的节点放在这个位置，退出；否则继续向下查找；

实现的基本代码：

 function Node (data,left,right) {
   this.data = data;
   this.show = show;
   this.left = left;
   this.right = right;
 }
 function show() {
   console.log(this.data);
 }
 function BST() {
   this.root = root;
   this.insert = insert;
 }
 function insert(data) {
   var n = new Node(data,null,null);
   if(this.root === null) {
     this.root = n;
  } else {
     var currNode =  this.root,parent;
     while(true) {
       parent = currNode;
       if(data == currNode.data) {
         break; 
     } else if(data < currNode.data) {
         currNode = currNode.left;
         if(currNode === null) {
           parent.left = n;
           break;
         }
       } else {
         currNode = currNode.right;
         if(currNode === null) {
           parent.right = n;
           break;
         }
       }
     }
   }
 }

　遍历查找：（名字即为要查找的节点的输出顺序）

• 中序遍历：升序遍历要查找的节点及其子孙节点；

//10，22，30，56，77，81，92

 function inOrder(node) {
  if(!(node == null)) {
    inOrder(node.left);
    node.show();
    inOrder(node.right);
  }
 }

　　操作：demo:

• 先序遍历：先输出要查找的节点，然后从左边的子节点开始依照先左后右输出；

//50，10，5，15，70，60，80

 function preOrder(node) {
  if(!(node == null)) {
    node.show();
    preOrder(node.left);
    preOrder(node.right);
  }
 }

　　操作：demo:

• 后序遍历：从要查找的节点的左节点最左边的子孙节点开始，按照左右各一次的顺序输出直到其左子节点；然后从其右节点的最左边的子孙节点开始；最后输出要查找的节点；

//3，22，16，37，99，45，23

 function postOrder(node) {
  if(!(node == null)) {
    postOrder(node.left);
    postOrder(node.right);
    node.show();
  }
 }

在二叉树上查找：

• 最大值：即遍历右子树

 function getMax() {
   var currNode = this.root;
   while(!(currNode.right == null)) {
     currNode = currNode.right;
   }
   console.log(currNode.data);
   return currNode;
 }

• 最小值：即遍历左子树

function getMin() {
   var currNode = this.root;
   while(!(currNode.left == null)) {
     currNode = currNode.left;
   }
   console.log(currNode.data);
   return currNode;
}

• 查找给定值：

 function find(data) {
  var currNode = this.root;
  while(currNode != null) {
    if(currNode.data === data) {
      return currNode;
    } else if(data < currNode.data) {
      currNode = currNode.left;
    } else {
      currNode = currNode.right;
    }
  }
  return null;
 }

操作：demo:

• 删除节点：
  • 先判断，如果当前节点包括则删除节点；如果不包括，则比较大小向下一层查找；
  • 删除节点的时候，如果是叶子节点，则将其父节点指向它的引用指向null；
  • 如果只包含一个子节点，则将其父节点指向它的引用指向这个子节点；
  • 如果包含两个子节点，那么可以
    • 查找待删节点的左子树的最大值；
    • 查找待删节点的右子树的最小值；（这里选这种）
  • 找到最小值之后，会用这个最小值创建一个一个临时节点，并将临时节点值复制到待删节点，最后删除临时节点；//等价于取小最小值节点替换掉待删节点；

function remove(data) {
   root = removeNode(this.root,data);
 }
 function getSmallest(node) {
   if (node.left == null) {
      return node;
   }
   else {
      return getSmallest(node.left);
   }
}
 function removeNode(node,data) {
   if(node == null) {
     return null;
  }
  if(data === node.data) {
    //not child node;
    if(node.left == null && node.right == null) {
      return null;
    }
    //not left child node;
    if(node.left == null) {
      return node.right;
    }
    //not right child node;
    if(node.right == null) {
      return node.left;
    }
    //all have
    var tempNode = getSmallest(node.right);
    node.data = tempNode.data;
    node.right = removeNode(node.right,tempNode.data);
    return node;
  } else if(data < node.data) {
    node.left = removeNode(node.left,data);//set parent.left null to delete this node;
    return node;
  } else {
    node.right = removeNode(node.right,data);
    return node;
  }
 }

　　操作：demo:

• 计数：可以给Node添加this.count = 1;在添加数值的时候，虽然相同的数值不会重复加入，但可以记录其被添加的次数；