数据结构之二叉树

　　第一篇：数据结构之链表

　　第二篇：数据结构之栈和队列

 

　　在这篇文章里面，我们主要探讨和树相关的话题。

　　首先，我们来对树进行定义：树是n（n>= 0）个节点的有限集。在任何一个非空树中：（1）有且仅有一个特定的称为“根”的节点；（2）当n>1时，其余节点可分为m（m>0）个互相相关的有限集T1、T2、T3……，其中每一个集合本身又是一棵树，并且称为根的子树。

　　对于我们这篇文章里讨论的二叉树，它是一种特殊的树形结构，每个节点至多只有两颗子树，并且子树有左右之分，其次序不能随意颠倒。

　　接下来，我们使用java代码来定义一棵树：

public class BinNode {
    private int m_Value;
    private BinNode m_Left;
    private BinNode m_Right;
    public void setValue(int m_Value) {
        this.m_Value = m_Value;
    }
    public int getValue() {
        return m_Value;
    }
    public void setLeft(BinNode m_Left) {
        this.m_Left = m_Left;
    }
    public BinNode getLeft() {
        return m_Left;
    }
    public void setRight(BinNode m_Right) {
        this.m_Right = m_Right;
    }
    public BinNode getRight() {
        return m_Right;
    }
    
    public boolean isLeaf()
    {
        return m_Left == null && m_Right == null;
    }
}

　　下面，开始讨论和二叉树相关的话题

• 构造二叉树，给出一个已排序的整型数组，如何根据它来构造一个BST（二叉搜索树）。
  思路：二叉搜索树的特点是左子树的值<=父节点的值<=右子树的值。我们可以从下标0开始遍历数组，然后依次创建树节点，这样下来，对于树的根节点来说，只有右子树，没有左子树，整个树不是平衡二叉树。为了优化这一点，我们可以将数组的中间元素作为根节点，前半部分的值作为树的左子树，后半部分的值作为树的右子树，然后使用递归依次构建。
  

  public static BinNode buildTree(int[] arrValue)
  {
      if(arrValue == null) return null;
      BinNode root = new BinNode();
      buildTree(arrValue, 0, arrValue.length - 1, root);
      return root;
  }
  
  private static void buildTree(int[] arrValue, int startPos, int endPos, BinNode tree)
  {
      if (startPos > endPos) return;
      
      int midPos = startPos + (endPos - startPos)/2;
      if (tree == null)
      {
          tree = new BinNode();                
      }
      tree.setValue(arrValue[midPos]);
      
      if (midPos - 1 >= startPos)
      {
          BinNode left = new BinNode();
          tree.setLeft(left);
          buildTree(arrValue, startPos, midPos - 1, left);
      }
      if (endPos >= midPos + 1)
      {
          BinNode right = new BinNode();
          tree.setRight(right);
          buildTree(arrValue, midPos + 1, endPos, right);
      }
  }

• 树的遍历（前序遍历、中序遍历、后序遍历、层次遍历）
  思路：可以采用递归或者非递归的方式进行遍历
  前序遍历
  

  public static void preOrder(BinNode tree)
  {
      if (tree == null)
      {
          return;
      }
      System.out.println(tree.getValue());
      preOrder(tree.getLeft());
      preOrder(tree.getRight());
  }

  public static void preOrder2(BinNode tree)
  {
      if (tree == null) return;
      Stack stack = new Stack(10);
      BinNode temp = tree;
      while(temp != null)
      {
          System.out.println(temp.getValue());
          if (temp.getRight() != null) stack.push(temp.getRight());
          temp = temp.getLeft();
      }
      while(stack.get_Count() > 0)
      {
          temp = (BinNode)stack.pop();
          System.out.println(temp.getValue());
          while(temp != null)
          {
              if (temp.getRight() != null)
              {
                  stack.push(temp.getRight());
              }
              temp = temp.getLeft();
          }
      }
  }

  中序遍历

  public static void inOrder(BinNode tree)
  {
      if (tree == null)
      {
          return;
      }
      inOrder(tree.getLeft());
      System.out.println(tree.getValue());
      inOrder(tree.getRight());
  }

  public static void inOrder2(BinNode tree)
  {
      if (tree == null) return;
      Stack stack = new Stack(10);
      BinNode temp = tree;
      while(temp != null)
      {
          stack.push(temp);
          temp = temp.getLeft();
      }
      while(stack.get_Count() > 0)
      {
          temp = (BinNode)stack.pop();
          System.out.println(temp.getValue());
          if (temp.getRight() != null)
          {
              temp = temp.getRight();
              stack.push(temp);
              while(temp != null)
              {
                  if (temp.getLeft() != null)
                  {
                      stack.push(temp.getLeft());
                  }
                  temp = temp.getLeft();
              }
          }            
      }        
  }

  后序遍历

  public static void postOrder(BinNode tree)
  {
      if (tree == null)
      {
          return;
      }
      postOrder(tree.getLeft());
      postOrder(tree.getRight());
      System.out.println(tree.getValue());
  }

  public static void postOrder2(BinNode tree)
  {
      if (tree == null) return;
      Stack stack = new Stack(10);
      BinNode temp = tree;
      while(temp != null)
      {
          stack.push(temp);
          temp = temp.getLeft();
      }
      
      while(stack.get_Count() > 0)
      {
          BinNode lastVisited = temp;
          temp = (BinNode)stack.pop();
          if (temp.getRight() == null || temp.getRight() == lastVisited)
          {
              System.out.println(temp.getValue());
          }
          else if (temp.getLeft() == lastVisited)
          {
              stack.push(temp);
              temp = temp.getRight();
              stack.push(temp);
              while(temp != null)
              {
                  if (temp.getLeft() != null)
                  {
                      stack.push(temp.getLeft());
                  }
                  temp = temp.getLeft();
              }
          }
      }        
  }

  层次遍历

  public static void printTree(BinNode tree)
  {
      if (tree == null)
      {
          return;
      }
      Queue queue = new Queue(10);
      queue.enQueue(tree);
      while(queue.get_Count() > 0)
      {
          BinNode temp = (BinNode) queue.deQueue();
          System.out.println(temp.getValue());
          if (temp.getLeft() != null) queue.enQueue(temp.getLeft());
          if (temp.getRight() != null) queue.enQueue(temp.getRight());
      }        
  }

• 判断二叉树是否是平衡二叉树
  思路：平衡二叉树的特点是左右子树的深度差不能大于1，采用递归的方式。
  

  public static boolean isBalance(BinNode tree)
  {
      if (tree == null)
      {
          return true;
      }
      int lDepth = getDepth(tree.getLeft());
      int rDepth = getDepth(tree.getRight());
      if (lDepth - rDepth > 1 || lDepth - rDepth < -1)
      {
          return false;
      }
      return isBalance(tree.getRight()) && isBalance(tree.getLeft());
  }
  
  
  public static int getDepth(BinNode tree)
  {
      if(tree == null)
      {
          return 0;
      }        
      int lLength = getDepth(tree.getLeft());
      int rLength = getDepth(tree.getRight());
      
      return lLength > rLength ? lLength + 1 : rLength + 1; 
  }

• 找出任何两个节点的最近的共同父节点
  思路：用1表示根节点，2、3表示第二层节点，4、5、6、7表示第三层节点，以此类推，对于编号为n的节点，它的子节点编号为（2*n和2*n+1），通过这种方式重新标记树后，我们分别找到两个节点对应的编号，然后分别进行除2操作，直到找到相同的节点，这个节点就是最近的共同父节点。
  

  public static BinNode findParentNode2(BinNode tree, BinNode node1, BinNode node2)
  {
      if (tree == null) return null;
      BinNode result = null;
      int pos1 = 1, pos2 = 1;
      int i = 1;
      java.util.HashMap<Integer, BinNode> table = new java.util.HashMap<Integer, BinNode>();        
      BinNode temp = tree;
      table.put(i, temp);
      Queue queue = new Queue(10);
      queue.enQueue(i);
      int count = 0;
      while(queue.get_Count() > 0)
      {
          i = Integer.valueOf(queue.deQueue().toString());
          if (table.get(i) != null && table.get(i).getValue() == node1.getValue())
          {
              pos1 = i;
              count++;
          }
          if (table.get(i) != null && table.get(i).getValue() == node2.getValue())
          {
              pos2 = i;
              count++;
          }
          if(count == 2) break;
          
          if(table.get(i) == null)
          {
              table.put(2*i, null);
              table.put(2*i + 1, null);
          }
          else
          {
              table.put(2*i, table.get(i).getLeft());
              table.put(2*i + 1, table.get(i).getRight());
          }
          queue.enQueue(2*i);
          queue.enQueue(2*i + 1);
          
      }
      if (pos1 == pos2)
      {
          result = table.get(pos1);
      }
      else if(pos1 > pos2)
      { 
          while(pos1 > pos2) pos1 = pos1/2;
      }
      else
      {
          while(pos2 > pos1) pos2 = pos2/2;
      }
      if(pos1 == pos2 || pos1/2 == pos2 || pos2/2 == pos1) 
      {
          result = table.get(pos1 > pos2 ? pos2 : pos1);
      }
      else
      {
          while(pos1 != pos2) 
          {
              pos1 = pos1/2;
              pos2 = pos2/2;
          }
      }
      result = table.get(pos1);
      
      return result;
  }

  如果我们已知树是二叉排序树，那么我们可以利用二叉排序树的特点，分别寻找两个节点，在寻找过程中，将扫描过的节点放入stack中，这样可以获得两个stack，然后分别对两个stack进行pop操作，得到的第一个相同的节点就是最近的共同父节点。

  public static BinNode findParentNode(BinNode tree, BinNode node1, BinNode node2)
  {
      if (tree == null)
      {
          return null;
      }
      
      BinNode result = null;
      Stack stack1 = new Stack(10);
      Stack stack2 = new Stack(10);
      stack1.push(tree);
      stack2.push(tree);
      BinNode temp = tree;
      while(temp != null && temp.getValue() != node1.getValue())
      {
          stack1.push(temp);
          if (temp.getValue()> node1.getValue())
          {
              temp = temp.getLeft();
          }
          else
          {
              temp = temp.getRight();
          }
      }
      temp = tree;
      while(temp != null && temp.getValue() != node2.getValue())
      {
          stack2.push(temp);
          if (temp.getValue()> node2.getValue())
          {
              temp = temp.getLeft();
          }
          else
          {
              temp = temp.getRight();
          }
      }
      if (stack1.get_Count() > stack2.get_Count())
      {
          while(stack1.get_Count() > stack2.get_Count())
          {
              stack1.pop();
          }
      }
      if (stack2.get_Count() > stack1.get_Count())
      {
          while(stack2.get_Count()>stack1.get_Count())
          {
              stack2.pop();
          }
      }
      while(stack1.get_Count() > 0 && stack2.get_Count() > 0)
      {
          if (stack1.peek() == stack2.peek())
          {
              result = (BinNode)stack1.peek();
              break;
          }
          stack1.pop();
          stack2.pop();
      }
      
      return result;
  }

• 找出树中节点值得和为某一值得所有路径
  思路：肯定是需要使用递归来实现，使用stack来存储扫描过的路径。
  

  public static void findSum(BinNode tree, int sum, Stack stack)
  {
      if (tree == null) return;
      stack.push(tree);        
      if (tree.getValue() == sum)
      {
          Stack temp = new Stack(stack.get_Count());
          while(stack.get_Count()>0)
          {
              temp.push(stack.pop());
          }
          StringBuffer sb = new StringBuffer();
          while(temp.get_Count() > 0)
          {
              sb.append(((BinNode)temp.peek()).getValue()).append("->");
              stack.push(temp.pop());
          }
          System.out.println(sb.substring(0, sb.length() - 2));
      }
      else if (tree.getValue() < sum)
      {
          if (tree.getLeft() != null) findSum(tree.getLeft(), sum - tree.getValue(), stack);
          if (tree.getRight() != null) findSum(tree.getRight(), sum - tree.getValue(), stack);
      }
      stack.pop();
  }

• 判断给定数组是否是二叉搜索树后序遍历的结果
  思路：观察二叉搜索树后序遍历的特点，根节点在最后，从下标0开始扫描，直到第一个大于根节点值得下标m，[0,(m-1)]的元素是节点的左子树，[m, n]是节点的右子树，并且右子树中任何节点的值都大于根节点。这样可以使用递归的方式以此判断。
  
• 给定一颗BST，另f=(max+min)/2，寻找距离f最近但大于f的节点
  思路：对于BST，最小值是最左边的叶子节点，最大值是最右边的叶子节点。
  

  public static BinNode findAvgInBST(BinNode tree)
  {
      if (tree == null) return null;
      BinNode temp = tree;
      while(temp.getLeft() != null) temp = temp.getLeft();
      int minValue = temp.getValue();
      temp = tree;
      while(temp.getRight() != null) temp = temp.getRight();
      int maxValue = temp.getValue();
      int avgValue = (minValue + maxValue)/2;
      return findNode(tree, avgValue);
  }
  
  private static BinNode findNode(BinNode tree, int value)
  {
      if (tree == null) return null;
      if (tree.getValue() >= value)
      {
          if (tree.getLeft() == null)
          {
              return tree;
          }
          else
          {
              BinNode temp = findNode(tree.getLeft(), value);
              return temp.getValue() < tree.getValue() ? temp:tree;
          }
      }
      else
      {
          if (tree.getRight() == null)
          {
              return tree;
          }
          else
          {
              BinNode temp = findNode(tree.getRight(), value);
              return temp.getValue() < tree.getValue() ? temp:tree;
          }
      }
  }

• 给出一棵树，得到这棵树的镜像
  思路：我们可以考虑前序遍历的结果：父节点->左子树->右子树，而镜像之后的结果：父节点->右子树->左子树，我们可以采用递归前序遍历的方式来实现
  

  public static void imageTree(BinNode tree)
  {
      if (tree == null) return;
      BinNode temp = tree.getLeft();
      tree.setLeft(tree.getRight());
      tree.setRight(temp);
      if (tree.getLeft() != null) imageTree(tree.getLeft());
      if (tree.getRight() != null) imageTree(tree.getRight());
  }

  我们也可以采用循环+栈的方式来实现

  public static void imageTrees(BinNode tree)
  {
      if (tree == null) return;
      Stack stack = new Stack(10);
      BinNode temp = tree;
      stack.push(temp);
      while(stack.get_Count() > 0)
      {
          temp = (BinNode)stack.pop();
          BinNode temp1 = temp.getLeft();
          temp.setLeft(temp.getRight());
          temp.setRight(temp1);            
          if (temp.getLeft() != null)
          {
              stack.push(temp.getLeft());
          }
          if (temp.getRight() != null)
          {
              stack.push(temp.getRight());
          }
      }
  }

• 将BST转换为排序的双向链表
  思路：对于BST来说，中序遍历的结果就是元素按照从小到大进行排序的结果
  

  public static DoubleLink convertTreeToList(BinNode tree)
  {
      if (tree == null) return null;
      
      DoubleLink list = new DoubleLink();
      list.setValue(null);
      list.setPre(null);
      DoubleLink listNode = list;
      
      BinNode treeNode = tree;
      Stack stack = new Stack(10);
      
      while(treeNode != null)
      {
          stack.push(treeNode);
          treeNode = treeNode.getLeft();
      }
      
      while(stack.get_Count() > 0)
      {
          treeNode = (BinNode)stack.pop();
          DoubleLink tempListNode = new DoubleLink();
          tempListNode.setValue(treeNode);
          listNode.setNext(tempListNode);
          tempListNode.setPre(listNode);
          listNode = tempListNode;
          if (treeNode.getRight() != null)
          {
              treeNode = treeNode.getRight();
              stack.push(treeNode);
              while(treeNode != null)
              {
                  if (treeNode.getLeft() != null)
                  {
                      stack.push(treeNode.getLeft());
                  }
                  treeNode = treeNode.getLeft();
              }
          }
      }
      
      listNode.setNext(null);
      
      return list;
  }

  其中DoubleLink的定义如下

  public class DoubleLink {
      private Object value;
      private DoubleLink next;
      private DoubleLink pre;
      public void setValue(Object value) {
          this.value = value;
      }
      public Object getValue() {
          return value;
      }
      public void setNext(DoubleLink next) {
          this.next = next;
      }
      public DoubleLink getNext() {
          return next;
      }
      public void setPre(DoubleLink pre) {
          this.pre = pre;
      }
      public DoubleLink getPre() {
          return pre;
      }    
  } 

• 向BST中插入节点
  思路：对BST中插入节点，首先按照遍历BST，找出所插接点的父节点，然后创建新节点
  

  public static void addValueToBST(BinNode tree, int value)
  {
      if (tree == null)
      {
          tree = new BinNode();
          tree.setValue(value);
          return;
      }
      
      BinNode temp = tree;
      while(true)
      {            
          if (temp.getValue() >= value)
          {
              if (temp.getLeft() == null) break;
              temp = temp.getLeft();
          }
          else
          {            
              if (temp.getRight() == null) break;
              temp = temp.getRight();
          }
      }
      
      BinNode node = new BinNode();
      node.setValue(value);
      if (temp.getValue() >= value)
      {
          temp.setLeft(node);
      }
      else
      {
          temp.setRight(node);
      }
  }

• 向BST中删除节点
  思路：首先是要能够找到需要删除的节点，然后根据节点是否有子节点分情况处理，如果没有子树，那么直接删除该节点（从父节点上解除关联）；如果只有左子树或者右子树，那么删除节点后将左子树或者右子树直接挂在父节点下；如果左右子树均存在，那么需要找出左子树的最大值或者右子树的最小值作为父节点的直接子节点，然后将这个节点的左右子树分别设置为删除节点的左右子树。
  

  public static void delValueFromBST(BinNode tree, int value)
  {
      if (tree == null) return;
      BinNode deleteNode = findNodeInBST(tree, value);
      BinNode parentNode = findParentNodeInBST(tree, value);
      if (parentNode == null || deleteNode == null) return;
      if (deleteNode.isLeaf())
      {
          if (parentNode.getLeft() == deleteNode) parentNode.setLeft(null);
          else parentNode.setRight(null);
      }
      else if (deleteNode.getLeft() == null && deleteNode.getRight() != null)
      {
          if (parentNode.getValue() >= deleteNode.getRight().getValue()) parentNode.setLeft(deleteNode.getRight());
          else parentNode.setRight(deleteNode.getRight());
          deleteNode.setRight(null);
      }
      else if (deleteNode.getLeft() != null && deleteNode.getRight() == null)
      {
          if (parentNode.getValue() >= deleteNode.getLeft().getValue()) parentNode.setLeft(deleteNode.getLeft());
          else parentNode.setRight(deleteNode.getLeft());
          deleteNode.setLeft(null);
      }
      else
      {
          BinNode temp = deleteNode.getRight();
          BinNode parent = deleteNode.getRight();
          while(temp.getLeft() != null) 
          {
              parent = temp; 
              temp = temp.getLeft();
          }
          if (parent != temp)
          {
              parent.setLeft(null);
          }
          temp.setLeft(deleteNode.getLeft());
          temp.setRight(deleteNode.getRight());
          if (parentNode.getValue() >= temp.getValue()) parentNode.setLeft(temp);
          else parentNode.setRight(temp);
          deleteNode.setLeft(null);
          deleteNode.setRight(null);
      }
  }
  
  private static BinNode findNodeInBST(BinNode tree, int value)
  {
      if (tree == null) return null;
      if (tree.getValue() == value) return tree;
      else if (tree.getValue() > value) return findNodeInBST(tree.getLeft(), value);
      else return findNodeInBST(tree.getRight(), value);
  }
  
  private static BinNode findParentNodeInBST(BinNode tree, int value)
  {
      if (tree == null) return null;
      if (tree.getValue() == value) return null;
      if ((tree.getLeft() != null && tree.getLeft().getValue() == value) || 
              (tree.getRight() != null &&tree.getRight().getValue() == value)) return tree;
      else if (tree.getValue() > value) return findParentNodeInBST(tree.getLeft(), value);
      else return findParentNodeInBST(tree.getRight(), value);
  }

　　最后，欢迎大家提出更多和二叉树相关的面试题目，我们可以一起讨论。