package class14;

import java.util.Stack;

// 本题测试链接 : https://leetcode.com/problems/recover-binary-search-tree/
public class Code05_RecoverBinarySearchTree {

	// 不要提交这个类
	public static class TreeNode {
		public int val;
		public TreeNode left;
		public TreeNode right;

		public TreeNode(int v) {
			val = v;
		}
	}

	// 如果能过leetcode，只需要提交这个方法即可
	// 但其实recoverTree2才是正路，只不过leetcode没有那么考
	public static void recoverTree(TreeNode root) {
		TreeNode[] errors = twoErrors(root);
		if (errors[0] != null && errors[1] != null) {
			int tmp = errors[0].val;
			errors[0].val = errors[1].val;
			errors[1].val = tmp;
		}
	}

	public static TreeNode[] twoErrors(TreeNode head) {
		TreeNode[] ans = new TreeNode[2];
		if (head == null) {
			return ans;
		}
		TreeNode cur = head;
		TreeNode mostRight = null;
		TreeNode pre = null;
		TreeNode e1 = null;
		TreeNode e2 = null;
		while (cur != null) {
			mostRight = cur.left;
			if (mostRight != null) {
				while (mostRight.right != null && mostRight.right != cur) {
					mostRight = mostRight.right;
				}
				if (mostRight.right == null) {
					mostRight.right = cur;
					cur = cur.left;
					continue;
				} else {
					mostRight.right = null;
				}
			}
			if (pre != null && pre.val >= cur.val) {
				e1 = e1 == null ? pre : e1;
				e2 = cur;
			}
			pre = cur;
			cur = cur.right;
		}
		ans[0] = e1;
		ans[1] = e2;
		return ans;
	}

	// 以下的方法，提交leetcode是通过不了的，但那是因为leetcode的验证方式有问题
	// 但其实！以下的方法，才是正路！在结构上彻底交换两个节点，而不是值交换
	public static TreeNode recoverTree2(TreeNode head) {
		TreeNode[] errs = getTwoErrNodes(head);
		TreeNode[] parents = getTwoErrParents(head, errs[0], errs[1]);
		TreeNode e1 = errs[0];
		TreeNode e1P = parents[0];
		TreeNode e1L = e1.left;
		TreeNode e1R = e1.right;
		TreeNode e2 = errs[1];
		TreeNode e2P = parents[1];
		TreeNode e2L = e2.left;
		TreeNode e2R = e2.right;
		if (e1 == head) {
			if (e1 == e2P) {
				e1.left = e2L;
				e1.right = e2R;
				e2.right = e1;
				e2.left = e1L;
			} else if (e2P.left == e2) {
				e2P.left = e1;
				e2.left = e1L;
				e2.right = e1R;
				e1.left = e2L;
				e1.right = e2R;
			} else {
				e2P.right = e1;
				e2.left = e1L;
				e2.right = e1R;
				e1.left = e2L;
				e1.right = e2R;
			}
			head = e2;
		} else if (e2 == head) {
			if (e2 == e1P) {
				e2.left = e1L;
				e2.right = e1R;
				e1.left = e2;
				e1.right = e2R;
			} else if (e1P.left == e1) {
				e1P.left = e2;
				e1.left = e2L;
				e1.right = e2R;
				e2.left = e1L;
				e2.right = e1R;
			} else {
				e1P.right = e2;
				e1.left = e2L;
				e1.right = e2R;
				e2.left = e1L;
				e2.right = e1R;
			}
			head = e1;
		} else {
			if (e1 == e2P) {
				if (e1P.left == e1) {
					e1P.left = e2;
					e1.left = e2L;
					e1.right = e2R;
					e2.left = e1L;
					e2.right = e1;
				} else {
					e1P.right = e2;
					e1.left = e2L;
					e1.right = e2R;
					e2.left = e1L;
					e2.right = e1;
				}
			} else if (e2 == e1P) {
				if (e2P.left == e2) {
					e2P.left = e1;
					e2.left = e1L;
					e2.right = e1R;
					e1.left = e2;
					e1.right = e2R;
				} else {
					e2P.right = e1;
					e2.left = e1L;
					e2.right = e1R;
					e1.left = e2;
					e1.right = e2R;
				}
			} else {
				if (e1P.left == e1) {
					if (e2P.left == e2) {
						e1.left = e2L;
						e1.right = e2R;
						e2.left = e1L;
						e2.right = e1R;
						e1P.left = e2;
						e2P.left = e1;
					} else {
						e1.left = e2L;
						e1.right = e2R;
						e2.left = e1L;
						e2.right = e1R;
						e1P.left = e2;
						e2P.right = e1;
					}
				} else {
					if (e2P.left == e2) {
						e1.left = e2L;
						e1.right = e2R;
						e2.left = e1L;
						e2.right = e1R;
						e1P.right = e2;
						e2P.left = e1;
					} else {
						e1.left = e2L;
						e1.right = e2R;
						e2.left = e1L;
						e2.right = e1R;
						e1P.right = e2;
						e2P.right = e1;
					}
				}
			}
		}
		return head;
	}

	public static TreeNode[] getTwoErrNodes(TreeNode head) {
		TreeNode[] errs = new TreeNode[2];
		if (head == null) {
			return errs;
		}
		Stack<TreeNode> stack = new Stack<TreeNode>();
		TreeNode pre = null;
		while (!stack.isEmpty() || head != null) {
			if (head != null) {
				stack.push(head);
				head = head.left;
			} else {
				head = stack.pop();
				if (pre != null && pre.val > head.val) {
					errs[0] = errs[0] == null ? pre : errs[0];
					errs[1] = head;
				}
				pre = head;
				head = head.right;
			}
		}
		return errs;
	}

	public static TreeNode[] getTwoErrParents(TreeNode head, TreeNode e1, TreeNode e2) {
		TreeNode[] parents = new TreeNode[2];
		if (head == null) {
			return parents;
		}
		Stack<TreeNode> stack = new Stack<TreeNode>();
		while (!stack.isEmpty() || head != null) {
			if (head != null) {
				stack.push(head);
				head = head.left;
			} else {
				head = stack.pop();
				if (head.left == e1 || head.right == e1) {
					parents[0] = head;
				}
				if (head.left == e2 || head.right == e2) {
					parents[1] = head;
				}
				head = head.right;
			}
		}
		return parents;
	}

	// for test -- print tree
	public static void printTree(TreeNode head) {
		System.out.println("Binary Tree:");
		printInOrder(head, 0, "H", 17);
		System.out.println();
	}

	public static void printInOrder(TreeNode head, int height, String to, int len) {
		if (head == null) {
			return;
		}
		printInOrder(head.right, height + 1, "v", len);
		String val = to + head.val + to;
		int lenM = val.length();
		int lenL = (len - lenM) / 2;
		int lenR = len - lenM - lenL;
		val = getSpace(lenL) + val + getSpace(lenR);
		System.out.println(getSpace(height * len) + val);
		printInOrder(head.left, height + 1, "^", len);
	}

	public static String getSpace(int num) {
		String space = " ";
		StringBuffer buf = new StringBuffer("");
		for (int i = 0; i < num; i++) {
			buf.append(space);
		}
		return buf.toString();
	}

	// 为了测试
	public static boolean isBST(TreeNode head) {
		if (head == null) {
			return false;
		}
		Stack<TreeNode> stack = new Stack<TreeNode>();
		TreeNode pre = null;
		while (!stack.isEmpty() || head != null) {
			if (head != null) {
				stack.push(head);
				head = head.left;
			} else {
				head = stack.pop();
				if (pre != null && pre.val > head.val) {
					return false;
				}
				pre = head;
				head = head.right;
			}
		}
		return true;
	}

	public static void main(String[] args) {
		TreeNode head = new TreeNode(5);
		head.left = new TreeNode(3);
		head.right = new TreeNode(7);
		head.left.left = new TreeNode(2);
		head.left.right = new TreeNode(4);
		head.right.left = new TreeNode(6);
		head.right.right = new TreeNode(8);
		head.left.left.left = new TreeNode(1);
		printTree(head);
		System.out.println(isBST(head));

		System.out.println("situation 1");
		TreeNode head1 = new TreeNode(7);
		head1.left = new TreeNode(3);
		head1.right = new TreeNode(5);
		head1.left.left = new TreeNode(2);
		head1.left.right = new TreeNode(4);
		head1.right.left = new TreeNode(6);
		head1.right.right = new TreeNode(8);
		head1.left.left.left = new TreeNode(1);
		printTree(head1);
		System.out.println(isBST(head1));
		TreeNode res1 = recoverTree2(head1);
		printTree(res1);
		System.out.println(isBST(res1));

		System.out.println("situation 2");
		TreeNode head2 = new TreeNode(6);
		head2.left = new TreeNode(3);
		head2.right = new TreeNode(7);
		head2.left.left = new TreeNode(2);
		head2.left.right = new TreeNode(4);
		head2.right.left = new TreeNode(5);
		head2.right.right = new TreeNode(8);
		head2.left.left.left = new TreeNode(1);
		printTree(head2);
		System.out.println(isBST(head2));
		TreeNode res2 = recoverTree2(head2);
		printTree(res2);
		System.out.println(isBST(res2));

		System.out.println("situation 3");
		TreeNode head3 = new TreeNode(8);
		head3.left = new TreeNode(3);
		head3.right = new TreeNode(7);
		head3.left.left = new TreeNode(2);
		head3.left.right = new TreeNode(4);
		head3.right.left = new TreeNode(6);
		head3.right.right = new TreeNode(5);
		head3.left.left.left = new TreeNode(1);
		printTree(head3);
		System.out.println(isBST(head3));
		TreeNode res3 = recoverTree2(head3);
		printTree(res3);
		System.out.println(isBST(res3));

		System.out.println("situation 4");
		TreeNode head4 = new TreeNode(3);
		head4.left = new TreeNode(5);
		head4.right = new TreeNode(7);
		head4.left.left = new TreeNode(2);
		head4.left.right = new TreeNode(4);
		head4.right.left = new TreeNode(6);
		head4.right.right = new TreeNode(8);
		head4.left.left.left = new TreeNode(1);
		printTree(head4);
		System.out.println(isBST(head4));
		TreeNode res4 = recoverTree2(head4);
		printTree(res4);
		System.out.println(isBST(res4));

		System.out.println("situation 5");
		TreeNode head5 = new TreeNode(2);
		head5.left = new TreeNode(3);
		head5.right = new TreeNode(7);
		head5.left.left = new TreeNode(5);
		head5.left.right = new TreeNode(4);
		head5.right.left = new TreeNode(6);
		head5.right.right = new TreeNode(8);
		head5.left.left.left = new TreeNode(1);
		printTree(head5);
		System.out.println(isBST(head5));
		TreeNode res5 = recoverTree2(head5);
		printTree(res5);
		System.out.println(isBST(res5));

		System.out.println("situation 6");
		TreeNode head6 = new TreeNode(4);
		head6.left = new TreeNode(3);
		head6.right = new TreeNode(7);
		head6.left.left = new TreeNode(2);
		head6.left.right = new TreeNode(5);
		head6.right.left = new TreeNode(6);
		head6.right.right = new TreeNode(8);
		head6.left.left.left = new TreeNode(1);
		printTree(head6);
		System.out.println(isBST(head6));
		TreeNode res6 = recoverTree2(head6);
		printTree(res6);
		System.out.println(isBST(res6));

		System.out.println("situation 7");
		TreeNode head7 = new TreeNode(5);
		head7.left = new TreeNode(4);
		head7.right = new TreeNode(7);
		head7.left.left = new TreeNode(2);
		head7.left.right = new TreeNode(3);
		head7.right.left = new TreeNode(6);
		head7.right.right = new TreeNode(8);
		head7.left.left.left = new TreeNode(1);
		printTree(head7);
		System.out.println(isBST(head7));
		TreeNode res7 = recoverTree2(head7);
		printTree(res7);
		System.out.println(isBST(res7));

		System.out.println("situation 8");
		TreeNode head8 = new TreeNode(5);
		head8.left = new TreeNode(3);
		head8.right = new TreeNode(8);
		head8.left.left = new TreeNode(2);
		head8.left.right = new TreeNode(4);
		head8.right.left = new TreeNode(6);
		head8.right.right = new TreeNode(7);
		head8.left.left.left = new TreeNode(1);
		printTree(head8);
		System.out.println(isBST(head8));
		TreeNode res8 = recoverTree2(head8);
		printTree(res8);
		System.out.println(isBST(res8));

		System.out.println("situation 9");
		TreeNode head9 = new TreeNode(5);
		head9.left = new TreeNode(2);
		head9.right = new TreeNode(7);
		head9.left.left = new TreeNode(3);
		head9.left.right = new TreeNode(4);
		head9.right.left = new TreeNode(6);
		head9.right.right = new TreeNode(8);
		head9.left.left.left = new TreeNode(1);
		printTree(head9);
		System.out.println(isBST(head9));
		TreeNode res9 = recoverTree2(head9);
		printTree(res9);
		System.out.println(isBST(res9));

		System.out.println("situation 10");
		TreeNode head10 = new TreeNode(5);
		head10.left = new TreeNode(3);
		head10.right = new TreeNode(6);
		head10.left.left = new TreeNode(2);
		head10.left.right = new TreeNode(4);
		head10.right.left = new TreeNode(7);
		head10.right.right = new TreeNode(8);
		head10.left.left.left = new TreeNode(1);
		printTree(head10);
		System.out.println(isBST(head10));
		TreeNode res10 = recoverTree2(head10);
		printTree(res10);
		System.out.println(isBST(res10));

		System.out.println("situation 11");
		TreeNode head11 = new TreeNode(5);
		head11.left = new TreeNode(3);
		head11.right = new TreeNode(7);
		head11.left.left = new TreeNode(6);
		head11.left.right = new TreeNode(4);
		head11.right.left = new TreeNode(2);
		head11.right.right = new TreeNode(8);
		head11.left.left.left = new TreeNode(1);
		printTree(head11);
		System.out.println(isBST(head11));
		TreeNode res11 = recoverTree2(head11);
		printTree(res11);
		System.out.println(isBST(res11));

		System.out.println("situation 12");
		TreeNode head12 = new TreeNode(5);
		head12.left = new TreeNode(3);
		head12.right = new TreeNode(7);
		head12.left.left = new TreeNode(8);
		head12.left.right = new TreeNode(4);
		head12.right.left = new TreeNode(6);
		head12.right.right = new TreeNode(2);
		head12.left.left.left = new TreeNode(1);
		printTree(head12);
		System.out.println(isBST(head12));
		TreeNode res12 = recoverTree2(head12);
		printTree(res12);
		System.out.println(isBST(res12));

		System.out.println("situation 13");
		TreeNode head13 = new TreeNode(5);
		head13.left = new TreeNode(3);
		head13.right = new TreeNode(7);
		head13.left.left = new TreeNode(2);
		head13.left.right = new TreeNode(6);
		head13.right.left = new TreeNode(4);
		head13.right.right = new TreeNode(8);
		head13.left.left.left = new TreeNode(1);
		printTree(head13);
		System.out.println(isBST(head13));
		TreeNode res13 = recoverTree2(head13);
		printTree(res13);
		System.out.println(isBST(res13));

		System.out.println("situation 14");
		TreeNode head14 = new TreeNode(5);
		head14.left = new TreeNode(3);
		head14.right = new TreeNode(7);
		head14.left.left = new TreeNode(2);
		head14.left.right = new TreeNode(8);
		head14.right.left = new TreeNode(6);
		head14.right.right = new TreeNode(4);
		head14.left.left.left = new TreeNode(1);
		printTree(head14);
		System.out.println(isBST(head14));
		TreeNode res14 = recoverTree2(head14);
		printTree(res14);
		System.out.println(isBST(res14));
	}

}