算法体系-11 第十一节：二叉树基本算法（上）

一两链表相交

1.1 题目描述

给定两个可能有环也可能无环的单链表，头节点head1和head2。请实现一个函数，如果两个链表相交，请返回相交的第一个节点。如果不相交，返回null

【要求】

如果两个链表长度之和为N，时间复杂度请达到O(N)，额外空间复杂度请达到O(1)。

1.2 判断一个单链表是否有环

情况：假如一个单链表，给你一个头节点，如果有环的话返回第一个入环的节点，如果无环的话返回null？

1.2.1 方案一容器的办法 Set<>集合

1.2.1.1 假如链表无环，走到null的时候，在hashset里面都没有找到重复的

假如链表是有环的，遍历链表的判断当前链表每个节点，判断当前节点是否在hashset里面，如果在就说明有环，如果不在将该节点放入set里面，如果遍历到最后一个null后m都没找到有在hash里面的节点说明无环

1.2.1.2 代码

//快慢指针public boolean hasCycle(ListNode head) {if (head == null) {return false;}ListNode slow = head;ListNode fast = head.next;while (slow != fast) {if (fast == null || fast.next == null) {return false;}slow = slow.next;fast = fast.next.next;}return true;}
}
/*** 通过Set集合记录值的方式，如果有重复的数据，就代表有环* @param node* @return*/private boolean hasCycle2(Node node) {Set<Node> nodeSet = new HashSet<>();//此字段仅用来记录遍历次数int traverseCount = 0;while (node != null) {if (nodeSet.contains(node)) {Log.d(TAG, "hasCycle2==>有环...traverseCount="+traverseCount);return true;}traverseCount ++;Log.d(TAG, "hasCycle2==>traverseCount="+traverseCount);nodeSet.add(node);node = node.next;}Log.d(TAG, "hasCycle2==>无环");return false;}

1.2.1.3 总结

链表的环可能有很多，但单链表只有一个next指针，不会出现分叉的情况

1.2.2 使用快慢指针遍历链表

思路：使用快慢指针遍历链表，快指针一旦走到

null，则该单链表一定无环（快指针一次走两步），如果存在环的话，快指针与慢指针一定会在环上相遇。

当快慢指针相遇时，让快指针重新指向初始节点；慢指针原地不变；两个指针都每次走一步，一定会在链表的入环节点相遇

1.2.2.1 分析

情况一如果快指针走到null了说明无环

如下情况图解找到相遇的点，但不是相交的入口节点，再做图二的解析，当相遇的时候，快指针去到链表的头，慢指针留在原地继续走，这个时候快慢指针都只走一步，这样再次往前走的话他两一定会在入口节点相遇，这个相遇的点就为入口的交点

1.2.2.2 代码

public static class Node {public int value;  public Node next;    public Node(int data) {this.value = data;   }
}
// 找到链表第一个入环节点，如果无环，返回nullpublic static Node getLoopNode(Node head) {if (head == null || head.next == null || head.next.next == null) {return null;}// n1 慢  n2 快Node slow = head.next; // n1 -> slowNode fast = head.next.next; // n2 -> fastwhile (slow != fast) {if (fast.next == null || fast.next.next == null) {return null;}fast = fast.next.next;slow = slow.next;}// slow fast  相遇fast = head; // n2 -> walk again from headwhile (slow != fast) {slow = slow.next;fast = fast.next;}return slow;}

1.2.2.3 总结

快慢指针找链表入环的节点

1、找到相遇点

2、快指针去到链表头再都分别往前走就能找到

1.3 本题分析

情况一两个链表都无环的情况-存在相交，

情况二如果两个链表一个无环，一个有环-不存在相交，因为相交后只存在一个next，只有一个有环需要两个next

情况三两个都有环的情况，这个环在相交节点后成一个环

情况一

情况二

情况三两个链表有环的情况

1.3.1 情况一两个链表都无环的情况-存在相交，

1.3.1.1 hashset

先判断两个链表都没环的情况，先通过上面的方法判断每个链表是否有环，再利用hashset，先将一个链表放入hashset里面，再遍历宁一个链表是否有节点在haseset里面

1.3.1.2 二不使用hashset

分析

先都让两个无环的链表走到最后，看是最后一个节点的内存地址是否相等，不相等一定不相交，end1==end2那么他们是一定相交的，end1和end2是他们相交的最后一个节点，要求的是第一个相交的节点，让长的一个走先他多出来的节点，再让短的和他们一起走，当有相等的时候那么这个点就是他们相交的第一个节点；

代码

// 如果两个链表都无环，返回第一个相交节点，如果不想交，返回nullpublic static Node noLoop(Node head1, Node head2) {if (head1 == null || head2 == null) {return null;}Node cur1 = head1;Node cur2 = head2;int n = 0;while (cur1.next != null) {n++;cur1 = cur1.next;}while (cur2.next != null) {n--;cur2 = cur2.next;}//判断是否相交if (cur1 != cur2) {return null;}// n  :  链表1长度减去链表2长度的值cur1 = n > 0 ? head1 : head2; // 谁长，谁的头变成cur1cur2 = cur1 == head1 ? head2 : head1; // 谁短，谁的头变成cur2n = Math.abs(n);while (n != 0) {n--;cur1 = cur1.next;}while (cur1 != cur2) {cur1 = cur1.next;cur2 = cur2.next;}return cur1;}

1.3.2 情况二

分析如果两个链表一个无环，一个有环-不存在相交，因为相交后只存在一个next，要一个有环需要两个next

1.3.3 情况三

情况三两个都有环的情况，这个环在相交节点后成一个环

当loop1 和loop2相等的化就是情况三的第二种

当loop1 和loop2不相等的化就是情况三的第一种和第三种

1.3.3.1 loop1 == loop2

当loop1 和loop2相等的化、话就是情况三的第二种,求第一个交点

分析当loop1 和loop2终止点时，就和情况一中的求无环链表的第一个交点一样

1.3.3.2 loop1 != loop2

当loop1 和loop2不相等的化就是情况三的第一种和第二种

分析 loop1环节点开始，我转一圈的过程中如果越到loop2说明是情况三， loop1 和 loop2都是他两的相交节点

没有越到说明是情况1，没有相交节点情况1返回null

1.3.3 代码

// 两个有环链表，返回第一个相交节点，如果不想交返回nullpublic static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) {Node cur1 = null;Node cur2 = null;if (loop1 == loop2) {cur1 = head1;cur2 = head2;int n = 0;while (cur1 != loop1) {n++;cur1 = cur1.next;}while (cur2 != loop2) {n--;cur2 = cur2.next;}cur1 = n > 0 ? head1 : head2;cur2 = cur1 == head1 ? head2 : head1;n = Math.abs(n);while (n != 0) {n--;cur1 = cur1.next;}while (cur1 != cur2) {cur1 = cur1.next;cur2 = cur2.next;}return cur1;} else {cur1 = loop1.next;while (cur1 != loop1) {if (cur1 == loop2) {return loop1;}cur1 = cur1.next;}return null;}}

1.3.4 主函数调用

public static Node getIntersectNode(Node head1, Node head2) {if (head1 == null || head2 == null) {return null;    }Node loop1 = getLoopNode(head1);   Node loop2 = getLoopNode(head2);   if (loop1 == null && loop2 == null) {return noLoop(head1, head2);   }if (loop1 != null && loop2 != null) {return bothLoop(head1, loop1, head2, loop2);   }return null;}

二二叉树的先序、中序、后序遍历

2.1 递归实现

2.1.1 前中后遍历的讲解

先序中序后序都可以由以下函数改出来，把打印放在第一次，第二次，第三次就是对应的前中后遍历；

递归序

充分理解递归点过程，根据递归的实现原理，

2.1.2 代码

package class10;public class Code02_RecursiveTraversalBT {public static class Node {public int value;public Node left;public Node right;public Node(int v) {value = v;}}public static void f(Node head) {if (head == null) {return;}// 1f(head.left);// 2f(head.right);// 3}// 先序打印所有节点public static void pre(Node head) {if (head == null) {return;}System.out.println(head.value);pre(head.left);pre(head.right);}public static void in(Node head) {if (head == null) {return;}in(head.left);System.out.println(head.value);in(head.right);}public static void pos(Node head) {if (head == null) {return;}pos(head.left);pos(head.right);System.out.println(head.value);}public static void main(String[] args) {Node head = new Node(1);head.left = new Node(2);head.right = new Node(3);head.left.left = new Node(4);head.left.right = new Node(5);head.right.left = new Node(6);head.right.right = new Node(7);pre(head);System.out.println("========");in(head);System.out.println("========");pos(head);System.out.println("========");}}

2.2 非递归实现-

2.2.1 前序遍历

2.2.1.1 分析

2.2.1.2 代码

public static class Node {public int value;public Node left;public Node right;public Node(int v) {value = v;}}public static void pre(Node head) {System.out.print("pre-order: ");if (head != null) {Stack<Node> stack = new Stack<Node>();stack.add(head);while (!stack.isEmpty()) {head = stack.pop();System.out.print(head.value + " ");if (head.right != null) {stack.push(head.right);}if (head.left != null) {stack.push(head.left);}}}System.out.println();}

2.2.2 中序遍历

2.2.2.1 分析

2.2.2.2 代码

public static void in(Node cur) {System.out.print("in-order: ");if (cur != null) {Stack<Node> stack = new Stack<Node>();//cur == null 还需要继续保证往下，通过!stack.isEmpty()while (!stack.isEmpty() || cur != null) {if (cur != null) {stack.push(cur);cur = cur.left;//1、假如上面的最后一个节点 cur = d.left;} else {//2、cur == null ，弹出  cur = stack.pop(); 为d，//3、找cur = cur.right;还是空，还是来到这个循环，//4、弹出的就是b了，cur = stack.pop();为e了继续往下走//5、e的左右都为空再弹出的就是a了cur = stack.pop();System.out.print(cur.value + " ");cur = cur.right;}}}System.out.println();}

2.2.3 后续遍历

2.2.3.1 在先序遍历的基础上进行修改，先改出一个头右左去压栈（压栈的时候先左再右，弹出来就对了），从新栈出来就是左右头就是后续遍历

先在压栈头左右基础上改出一个压栈为头右左的形式，弹出的时候不立马打印，而是先压入一个栈里面最后再弹出就是后续遍历

左右头

2.2.3.2 代码

public static void pos1(Node head) {System.out.print("pos-order: ");if (head != null) {Stack<Node> s1 = new Stack<Node>();Stack<Node> s2 = new Stack<Node>();s1.push(head);while (!s1.isEmpty()) {head = s1.pop(); // 头 右 左s2.push(head);if (head.left != null) {s1.push(head.left);}if (head.right != null) {s1.push(head.right);}}// 左 右 头while (!s2.isEmpty()) {System.out.print(s2.pop().value + " ");}}System.out.println();}