二叉树之Morris遍历

  • 递归理解以及morris遍历
  • 由morris遍历改成前序遍历
  • 由morris遍历改成中序遍历
  • 由morris遍历改成后续遍历
  • 完整测试代码

递归理解以及morris遍历

  1.     static void rec(Node head) { 
  2.         if (head == null) return;
  3.         System.out.print(head.value + " "); //这里打印就是前序遍历
  4.         rec(head.left);
  5.         System.out.print(head.value + " "); //这里打印就是中序遍历
  6.         rec(head.right);
  7.         System.out.print(head.value + " "); //这里打印就是后续遍历
  8.     }

这是我们用递归写的三种遍历方法，如果是下面的例子，上面程序输出如下：

image.png

程序输出:

  1. 1 2 4 8 8 8 4 4 2 5 5 9 9 9 5 2 1 3 6 10 10 10 6 6 3 7 11 11 11 7 7 3 1
  • 可以看到，每一个结点都会被访问三次，也就是说，访问的过程中，每一个结点都会经过三次；
  • 一个结点如果没有parent指针或者我们在非递归遍历中使用栈，是不能回到它的父节点的；
  • 而morris就是借助叶子结点的空闲指针帮助我们想办法回到父亲结点，省去了递归的空间，或者栈的空间，达到O(1)空间；

每个结点来到三次:

image.png

下面介绍morris遍历规则(现在和前、中、后序无关，就是morris序):

image.png

流程看下图的举例:

image.png

image.png

按照上面的解释可以完全写出下面的morris遍历过程(没有打印)：

  1.     static void morris(Node head){
  2.         if(head == null)return;
  3.         Node cur = head;
  4.         Node mostRight = null;//左子树上最右的结点
  6.         while(cur != null){
  7.             mostRight = cur.left;   //cur的第一个左结点
  8.             if(mostRight != null){  //如果左子树不为空
  10.                 while(mostRight.right != null && mostRight.right != cur){ //找到最右边的结点 有两种情况
  11.                     mostRight = mostRight.right;
  12.                 }
  14.                 if(mostRight.right == null){ //第一次来到这个结点  满足第二大条中的第一条
  15.                     mostRight.right = cur;
  16.                     cur = cur.left;
  17.                     continue; //  cur = cur.left 直接结束所有的
  18.                 }else { //第二次来到这个结点         满足第二大条中的第二条
  19.                     mostRight.right = null;
  20.                 }
  21.             }
  22.             cur = cur.right;  //包括两种情况的 左子树为空和第二次来到这个结点
  23.         }
  24.     }

由morris遍历改成前序遍历

需要注意几点:

  • 首先可以肯定是第一次来到这个结点的时候打印，所以是当mostRight.right == null(第一次来的时候，打印当前的cur)；
  • 其次，如果一个结点没有左子树，相当于只会来到结点一次，就直接打印一遍就可以了；
  • 其实这样的做法等同于在递归的时候把打印的行为放在第一次来到这个结点的时候；
  1.     //先序遍历
  2.     static void morrisPre(Node head){
  3.         if(head == null)return;
  4.         Node cur = head;
  5.         Node mostRight = null;
  7.         while(cur != null){
  8.             mostRight = cur.left;
  9.             if(mostRight != null){
  11.                 while(mostRight.right != null && mostRight.right != cur){
  12.                     mostRight = mostRight.right;
  13.                 }
  15.                 if(mostRight.right == null){
  16.                     mostRight.right = cur;
  17.                     System.out.print(cur.value + " ");   //先序是第一次来到这个结点的时候打印
  18.                     cur = cur.left;
  19.                     continue;
  20.                 }else {
  21.                     mostRight.right = null;
  22.                 }
  23.             }else {    //如果一个结点没有左子树  相当于只会来到这个结点一次  直接打印，然后往右走
  24.                 System.out.print(cur.value + " ");
  25.             }
  26.             cur = cur.right;
  27.         }
  28.         System.out.println();
  29.     }

由morris遍历改成中序遍历

中序更加简单:

  • 如果一个结点有左子树，那么我打印的时机是我遍历完左子树之后的打印，也就是第二次来到这个结点时候打印，也就是mostRight.right = cur的时候打印；
  • 如果一个结点没有左子树，那么本来也要打印一下，打印完就往右边窜了；
  • 本质就是不论怎么样要处理玩左子树才打印根结点；
  1.     //中序遍历
  2.     static void morrisIn(Node head){
  3.         if(head == null)return;
  4.         Node cur = head;
  5.         Node mostRight = null;
  7.         while(cur != null){
  8.             mostRight = cur.left;
  9.             if(mostRight != null){
  11.                 while(mostRight.right != null && mostRight.right != cur){
  12.                     mostRight = mostRight.right;
  13.                 }
  15.                 if(mostRight.right == null){
  16.                     mostRight.right = cur;
  17.                     cur = cur.left;
  18.                     continue;
  19.                 }else {
  20.                     mostRight.right = null;
  21.                 }
  22.             }
  23.             System.out.print(cur.value + " ");//这里包括两种情况 没有左子树和有左子树的第二次来到这里打印
  24.             cur = cur.right;
  25.         }
  26.         System.out.println();
  27.     }

由morris遍历改成后续遍历

后续遍历比较麻烦: 因为morris只会来到一个结点两次，但是递归会来到一个结点三次:

主要看以下几点:

  • 我们只关心那些有左子树，也就是会到一个结点两次的结点；
  • 逆序打印有左子树结点的左子树的右边界；
  • 最后打印整棵树的右边界的逆序；

image.png

  1.     //morris后续
  2.     static void morrisPos(Node head){
  3.         if(head == null)return;
  4.         Node cur = head;
  5.         Node mostRight = null;
  7.         while(cur != null){
  8.             mostRight = cur.left;
  9.             if(mostRight != null){
  11.                 while(mostRight.right != null && mostRight.right != cur){
  12.                     mostRight = mostRight.right;
  13.                 }
  15.                 if(mostRight.right == null){
  16.                     mostRight.right = cur;
  17.                     cur = cur.left;
  18.                     continue;
  19.                 }else { //第二次来的时候
  20.                     mostRight.right = null;
  21.                     printEdge(cur.left); //打印左子树的右边界
  22.                 }
  23.             }
  24.             cur = cur.right;
  25.         }
  26.         printEdge(head); //最后打印整棵树的右边界
  27.         System.out.println();
  28.     }
  30.     //打印边界
  31.     static void printEdge(Node head) {
  32.         //先逆序边界
  33.         Node tail = reverseEdge(head);
  34.         //打印
  35.         Node cur = tail;
  36.         while(cur != null){
  37.             System.out.print(cur.value + " ");
  38.             cur = cur.right;
  39.         }
  40.         //再逆序回来
  41.         reverseEdge(tail);
  42.     }
  44.     //有点类似链表的逆序
  45.     static Node reverseEdge(Node cur) {
  46.         Node pre = null;
  47.         Node next = null;
  48.         while(cur != null){
  49.             next = cur.right;//先保存下一个
  50.             cur.right = pre;
  51.             pre = cur;
  52.             cur = next;
  53.         }
  54.         return pre;
  55.     }

完整测试代码(例子就是上面的例子):

  1. public class Morris {
  3.     static class Node {
  4.         public int value;
  5.         public Node left;
  6.         public Node right;
  8.         public Node(int value) {
  9.             this.value = value;
  10.         }
  11.     }
  14.     static Node createTree(int[] arr, int i) {
  15.         if (i >= arr.length || arr[i] == -1) return null;
  16.         Node head = new Node(arr[i]);
  17.         head.left = createTree(arr, 2 * i + 1);
  18.         head.right = createTree(arr, 2 * i + 2);
  19.         return head;
  20.     }
  23.     static void process(Node head) {
  24.         if (head == null) return;
  25.         System.out.print(head.value + " ");
  26.         process(head.left);
  27.         System.out.print(head.value + " ");
  28.         process(head.right);
  29.         System.out.print(head.value + " ");
  30.     }
  33.     static void pre(Node head) {
  34.         if (head == null) return;
  35.         System.out.print(head.value + " ");
  36.         pre(head.left);
  37.         pre(head.right);
  38.     }
  40.     static void in(Node head) {
  41.         if (head == null) return;
  42.         in(head.left);
  43.         System.out.print(head.value + " ");
  44.         in(head.right);
  45.     }
  47.     static void pos(Node head) {
  48.         if (head == null) return;
  49.         pos(head.left);
  50.         pos(head.right);
  51.         System.out.print(head.value + " ");
  52.     }
  55.     static void morris(Node head) {
  56.         if (head == null) return;
  57.         Node cur = head;
  58.         Node mostRight = null;//左子树上最右的结点
  60.         while (cur != null) {
  61.             mostRight = cur.left;   //cur的第一个左结点
  62.             if (mostRight != null) {  //如果左子树不为空
  64.                 while (mostRight.right != null && mostRight.right != cur) { //找到最右边的结点 有两种情况
  65.                     mostRight = mostRight.right;
  66.                 }
  68.                 if (mostRight.right == null) { //第一次来到这个结点  满足第二大条中的第一条
  69.                     mostRight.right = cur;
  70.                     cur = cur.left;
  71.                     continue; //  cur = cur.left 直接结束所有的
  72.                 } else { //第二次来到这个结点         满足第二大条中的第二条
  73.                     mostRight.right = null;
  74.                 }
  75.             }
  76.             cur = cur.right;  //包括两种情况的 左子树为空和第二次来到这个结点
  77.         }
  78.     }
  81.     //先序遍历
  82.     static void morrisPre(Node head) {
  83.         if (head == null) return;
  84.         Node cur = head;
  85.         Node mostRight = null;
  87.         while (cur != null) {
  88.             mostRight = cur.left;
  89.             if (mostRight != null) {
  91.                 while (mostRight.right != null && mostRight.right != cur) {
  92.                     mostRight = mostRight.right;
  93.                 }
  95.                 if (mostRight.right == null) {
  96.                     mostRight.right = cur;
  97.                     System.out.print(cur.value + " ");   //先序是第一次来到这个结点的时候打印
  98.                     cur = cur.left;
  99.                     continue;
  100.                 } else {
  101.                     mostRight.right = null;
  102.                 }
  103.             } else {    //如果一个结点没有左子树  相当于只会来到这个结点一次  直接打印，然后往右走
  104.                 System.out.print(cur.value + " ");
  105.             }
  106.             cur = cur.right;
  107.         }
  108.         System.out.println();
  109.     }
  111.     //中序遍历
  112.     static void morrisIn(Node head) {
  113.         if (head == null) return;
  114.         Node cur = head;
  115.         Node mostRight = null;
  117.         while (cur != null) {
  118.             mostRight = cur.left;
  119.             if (mostRight != null) {
  121.                 while (mostRight.right != null && mostRight.right != cur) {
  122.                     mostRight = mostRight.right;
  123.                 }
  125.                 if (mostRight.right == null) {
  126.                     mostRight.right = cur;
  127.                     cur = cur.left;
  128.                     continue;
  129.                 } else {
  130.                     mostRight.right = null;
  131.                 }
  132.             }
  133.             System.out.print(cur.value + " ");
  134.             cur = cur.right;
  135.         }
  136.         System.out.println();
  137.     }
  139.     //morris后续
  140.     static void morrisPos(Node head) {
  141.         if (head == null) return;
  142.         Node cur = head;
  143.         Node mostRight = null;
  145.         while (cur != null) {
  146.             mostRight = cur.left;
  147.             if (mostRight != null) {
  149.                 while (mostRight.right != null && mostRight.right != cur) {
  150.                     mostRight = mostRight.right;
  151.                 }
  153.                 if (mostRight.right == null) {
  154.                     mostRight.right = cur;
  155.                     cur = cur.left;
  156.                     continue;
  157.                 } else { //第二次来的时候
  158.                     mostRight.right = null;
  159.                     printEdge(cur.left); //打印左子树的右边界
  160.                 }
  161.             }
  162.             cur = cur.right;
  163.         }
  164.         printEdge(head); //最后打印整棵树的右边界
  165.         System.out.println();
  166.     }
  168.     //打印边界
  169.     static void printEdge(Node head) {
  170.         //先逆序边界
  171.         Node tail = reverseEdge(head);
  172.         //打印
  173.         Node cur = tail;
  174.         while (cur != null) {
  175.             System.out.print(cur.value + " ");
  176.             cur = cur.right;
  177.         }
  178.         //再逆序回来
  179.         reverseEdge(tail);
  180.     }
  182.     //有点类似链表的逆序
  183.     static Node reverseEdge(Node cur) {
  184.         Node pre = null;
  185.         Node next = null;
  186.         while (cur != null) {
  187.             next = cur.right;//先保存下一个
  188.             cur.right = pre;
  189.             pre = cur;
  190.             cur = next;
  191.         }
  192.         return pre;
  193.     }
  196.     public static void main(String[] args) {
  197.         int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, -1, -1, 9, 10, -1, 11, -1};
  198.         Node head = createTree(arr, 0);
  199.         System.out.println("------------递归树每个结点回到三次-----------");
  200.         process(head);
  201.         System.out.println();
  202.         System.out.println();
  204.         System.out.println("---------------------前序----------------");
  205.         pre(head);
  206.         System.out.println();
  207.         morrisPre(head);
  208.         System.out.println();
  211.         System.out.println("---------------------中序----------------");
  212.         in(head);
  213.         System.out.println();
  214.         morrisIn(head);
  215.         System.out.println();
  218.         System.out.println("---------------------后序----------------");
  219.         pos(head);
  220.         System.out.println();
  221.         morrisPos(head);
  222.         System.out.println();
  224.     }
  225. }

测试结果:
二叉树之Morris遍历 - 图7