Adjust search for two wrong nodes in a binary tree _ two fork tree

Source: Internet
Author: User
Tags static class stringbuffer

Adjust the search binary tree in two wrong nodes import Java.util.Stack;
		public class Recoverbst {public static class Node {public int value;
		Public Node left;

		public Node right;
		public Node (int data) {this.value = data;
		}//Get two error node public static node[] gettwoerrnodes (node head) {node[] errs = new node[2];
		if (head = = null) {return errs;
		} stack<node> Stack = new stack<node> ();
		Node pre = NULL;
				while (!stack.isempty () | | | |-head!= NULL) {if (head!= null) {Stack.push (head);
			head = Head.left;
				else {head = Stack.pop ();
					if (pre!= null && pre.value > Head.value) {errs[0] = errs[0] = = null? Pre:errs[0];
				Errs[1] = head;
				Pre = head;
			head = Head.right;
	} return errs;
		public static node[] gettwoerrparents (node Head, node e1, node E2) {node[] parents = new NODE[2];
		if (head = = null) {return parents;
		} stack<node> Stack = new stack<node> (); 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;
		}//Advanced problem solution (total 14 cases) public static node Recovertree (node head) {node[] errs = Gettwoerrnodes (head);
		node[] parents = gettwoerrparents (head, errs[0), errs[1]);
		Node e1 = errs[0];
		Node e1p = parents[0];
		Node e1l = E1.left;
		Node e1r = e1.right;
		Node e2 = errs[1];
		Node e2p = parents[1];
		Node e2l = E2.left;
		Node e2r = e2.right;
				if (e1 = = head) {if (e1 = = e2p) {//situation one e1.left = e2l;
				E1.right = E2R;
				E2.right = E1;
			E2.left = e1l;
				else if (E2p.left = = E2) {//Case two e2p.left = E1;
				E2.left = e1l;
				E2.right = e1r;
				E1.left = e2l;
			E1.right = E2R;
				else {//Case three e2p.right = E1;
				E2.left = e1l; E2.right = E1R;
				E1.left = e2l;
			E1.right = E2R;
		Head = E2;
				else if (e2 = head) {if (e2 = = e1p) {//Case four e2.left = e1l;
				E2.right = e1r;
				E1.left = E2;
			E1.right = E2R;
				else if (E1p.left = = e1) {//Case five e1p.left = E2;
				E1.left = e2l;
				E1.right = E2R;
				E2.left = e1l;
			E2.right = e1r;
				else {//case six 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) {//Case VII E1p.left = E2;
					E1.left = e2l;
					E1.right = E2R;
					E2.left = e1l;
				E2.right = E1;
					else {//case eight e1p.right = E2;
					E1.left = e2l;
					E1.right = E2R;
					E2.left = e1l;
				E2.right = E1;
					} else if (e2 = = e1p) {if (E2p.left = = E2) {//Case nine e2p.left = E1;
					E2.left = e1l;
					E2.right = e1r;
					E1.left = E2;
				E1.right = E2R;
					else {//case 10 e2p.right = E1;
					E2.left = e1l; E2.right =E1R;
					E1.left = E2;
				E1.right = E2R;
						} else {if (E1p.left = = e1) {if (E2p.left = = E2) {//Case 11 e1.left = e2l;
						E1.right = E2R;
						E2.left = e1l;
						E2.right = e1r;
						E1p.left = E2;
					E2p.left = E1;
						else {//case 12 e1.left = e2l;
						E1.right = E2R;
						E2.left = e1l;
						E2.right = e1r;
						E1p.left = E2;
					E2p.right = E1;
						} else {if (E2p.left = E2) {//Case 13 e1.left = e2l;
						E1.right = E2R;
						E2.left = e1l;
						E2.right = e1r;
						E1p.right = E2;
					E2p.left = E1;
						else {//case 14 e1.left = e2l;
						E1.right = E2R;
						E2.left = e1l;
						E2.right = e1r;
						E1p.right = E2;
					E2p.right = E1;
	}}} return head;
		//For test-the print tree public static void Printtree (Node head) {System.out.println ("Binary tree:");
		Printinorder (head, 0, "H", 17);
	System.out.println (); public static void Printinorder (Node head, int heIght, String to, int len) {if (head = = null) {return;
		Printinorder (head.right, height + 1, "V", Len);
		String val = to + Head.value + 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 ();
		}//For test public static Boolean Isbst (Node head) {if (head = = null) {return false;
		} stack<node> Stack = new stack<node> ();
		Node pre = NULL;
				while (!stack.isempty () | | | |-head!= NULL) {if (head!= null) {Stack.push (head);
			head = Head.left;
				else {head = Stack.pop ();
				if (pre!= null && pre.value > Head.value) {return false;
				}Pre = head;
			head = Head.right;
	} return true;
		public static void Main (string[] args {node head = new Node (5);
		Head.left = new Node (3);
		Head.right = new Node (7);
		Head.left.left = new Node (2);
		Head.left.right = new Node (4);
		Head.right.left = new Node (6);
		Head.right.right = new Node (8);
		Head.left.left.left = new Node (1);
		Printtree (head);

		System.out.println (head) (ISBST);
		Conditions 1, 7-> E1, 5-> E2 SYSTEM.OUT.PRINTLN ("Situation 1");
		Node Head1 = new node (7);
		Head1.left = new Node (3);
		Head1.right = new Node (5);
		Head1.left.left = new Node (2);
		Head1.left.right = new Node (4);
		Head1.right.left = new Node (6);
		Head1.right.right = new Node (8);
		Head1.left.left.left = new Node (1);
		Printtree (HEAD1);
		System.out.println (Isbst (HEAD1));
		Node res1 = Recovertree (HEAD1);
		Printtree (RES1);

		System.out.println (Isbst (res1));
		Conditions 2, 6-> E1, 5-> E2 SYSTEM.OUT.PRINTLN ("Situation 2");
		Node head2 = new node (6); Head2.left = NEW Node (3);
		Head2.right = new Node (7);
		Head2.left.left = new Node (2);
		Head2.left.right = new Node (4);
		Head2.right.left = new Node (5);
		Head2.right.right = new Node (8);
		Head2.left.left.left = new Node (1);
		Printtree (HEAD2);
		System.out.println (Isbst (head2));
		Node res2 = Recovertree (head2);
		Printtree (Res2);

		System.out.println (Isbst (res2));
		Conditions 3, 8-> E1, 5-> E2 SYSTEM.OUT.PRINTLN ("Situation 3");
		Node Head3 = new node (8);
		Head3.left = new Node (3);
		Head3.right = new Node (7);
		Head3.left.left = new Node (2);
		Head3.left.right = new Node (4);
		Head3.right.left = new Node (6);
		Head3.right.right = new Node (5);
		Head3.left.left.left = new Node (1);
		Printtree (HEAD3);
		System.out.println (Isbst (HEAD3));
		Node Res3 = Recovertree (HEAD3);
		Printtree (RES3);

		System.out.println (Isbst (RES3));
		Conditions 4, 5-> E1, 3-> E2 SYSTEM.OUT.PRINTLN ("Situation 4");
		Node Head4 = new node (3);
		Head4.left = new Node (5);
		Head4.right = new Node (7); Head4.left. left = new Node (2);
		Head4.left.right = new Node (4);
		Head4.right.left = new Node (6);
		Head4.right.right = new Node (8);
		Head4.left.left.left = new Node (1);
		Printtree (HEAD4);
		System.out.println (Isbst (HEAD4));
		Node res4 = Recovertree (HEAD4);
		Printtree (RES4);

		System.out.println (Isbst (RES4));
		Conditions 5, 5-> E1, 2-> E2 SYSTEM.OUT.PRINTLN ("Situation 5");
		Node HEAD5 = new node (2);
		Head5.left = new Node (3);
		Head5.right = new Node (7);
		Head5.left.left = new Node (5);
		Head5.left.right = new Node (4);
		Head5.right.left = new Node (6);
		Head5.right.right = new Node (8);
		Head5.left.left.left = new Node (1);
		Printtree (HEAD5);
		System.out.println (Isbst (HEAD5));
		Node res5 = Recovertree (HEAD5);
		Printtree (RES5);

		System.out.println (Isbst (RES5));
		Conditions 6, 5-> E1, 4-> E2 SYSTEM.OUT.PRINTLN ("Situation 6");
		Node Head6 = new node (4);
		Head6.left = new Node (3);
		Head6.right = new Node (7);
		Head6.left.left = new Node (2); Head6.left.right = new Node (5);
		Head6.right.left = new Node (6);
		Head6.right.right = new Node (8);
		Head6.left.left.left = new Node (1);
		Printtree (HEAD6);
		System.out.println (Isbst (HEAD6));
		Node res6 = Recovertree (HEAD6);
		Printtree (RES6);

		System.out.println (Isbst (RES6));
		Conditions 7, 4-> E1, 3-> E2 SYSTEM.OUT.PRINTLN ("Situation 7");
		Node Head7 = new node (5);
		Head7.left = new Node (4);
		Head7.right = new Node (7);
		Head7.left.left = new Node (2);
		Head7.left.right = new Node (3);
		Head7.right.left = new Node (6);
		Head7.right.right = new Node (8);
		Head7.left.left.left = new Node (1);
		Printtree (HEAD7);
		System.out.println (Isbst (HEAD7));
		Node Res7 = Recovertree (HEAD7);
		Printtree (RES7);

		System.out.println (Isbst (RES7));
		Conditions 8, 8-> E1, 7-> E2 SYSTEM.OUT.PRINTLN ("Situation 8");
		Node Head8 = new node (5);
		Head8.left = new Node (3);
		Head8.right = new Node (8);
		Head8.left.left = new Node (2);
		Head8.left.right = new Node (4);
		Head8.right.left = new Node (6); Head8.right.right = new Node (7);
		Head8.left.left.left = new Node (1);
		Printtree (HEAD8);
		System.out.println (Isbst (Head8));
		Node Res8 = Recovertree (HEAD8);
		Printtree (RES8);

		System.out.println (Isbst (RES8));
		Conditions 9, 3-> E1, 2-> E2 SYSTEM.OUT.PRINTLN ("Situation 9");
		Node head9 = new node (5);
		Head9.left = new Node (2);
		Head9.right = new Node (7);
		Head9.left.left = new Node (3);
		Head9.left.right = new Node (4);
		Head9.right.left = new Node (6);
		Head9.right.right = new Node (8);
		Head9.left.left.left = new Node (1);
		Printtree (HEAD9);
		System.out.println (Isbst (HEAD9));
		Node RES9 = Recovertree (HEAD9);
		Printtree (RES9);

		System.out.println (Isbst (RES9));
		The situation was 7-> E1, 6-> E2 SYSTEM.OUT.PRINTLN ("Situation 10");
		Node HEAD10 = new node (5);
		Head10.left = new Node (3);
		Head10.right = new Node (6);
		Head10.left.left = new Node (2);
		Head10.left.right = new Node (4);
		Head10.right.left = new Node (7);
		Head10.right.right = new Node (8); Head10.left.left.left = new Node (1);
		Printtree (HEAD10);
		System.out.println (Isbst (HEAD10));
		Node Res10 = Recovertree (HEAD10);
		Printtree (RES10);

		System.out.println (Isbst (RES10));
		Situation one, 6-> E1, 2-> E2 System.out.println ("Situation 11");
		Node Head11 = new node (5);
		Head11.left = new Node (3);
		Head11.right = new Node (7);
		Head11.left.left = new Node (6);
		Head11.left.right = new Node (4);
		Head11.right.left = new Node (2);
		Head11.right.right = new Node (8);
		Head11.left.left.left = new Node (1);
		Printtree (HEAD11);
		System.out.println (Isbst (HEAD11));
		Node RES11 = Recovertree (HEAD11);
		Printtree (RES11);

		System.out.println (Isbst (RES11));
		Situation 8-> E1, 2-> E2 SYSTEM.OUT.PRINTLN ("Situation 12");
		Node head12 = new node (5);
		Head12.left = new Node (3);
		Head12.right = new Node (7);
		Head12.left.left = new Node (8);
		Head12.left.right = new Node (4);
		Head12.right.left = new Node (6);
		Head12.right.right = new Node (2);
		Head12.left.left.left = new Node (1); prInttree (HEAD12);
		System.out.println (Isbst (head12));
		Node res12 = Recovertree (HEAD12);
		Printtree (RES12);

		System.out.println (Isbst (RES12));
		Situation 6-> E1, 4-> E2 SYSTEM.OUT.PRINTLN ("Situation 13");
		Node HEAD13 = new node (5);
		Head13.left = new Node (3);
		Head13.right = new Node (7);
		Head13.left.left = new Node (2);
		Head13.left.right = new Node (6);
		Head13.right.left = new Node (4);
		Head13.right.right = new Node (8);
		Head13.left.left.left = new Node (1);
		Printtree (HEAD13);
		System.out.println (Isbst (HEAD13));
		Node Res13 = Recovertree (HEAD13);
		Printtree (RES13);

		System.out.println (Isbst (RES13));
		Situation 8-> E1, 4-> E2 SYSTEM.OUT.PRINTLN ("Situation 14");
		Node HEAD14 = new node (5);
		Head14.left = new Node (3);
		Head14.right = new Node (7);
		Head14.left.left = new Node (2);
		Head14.left.right = new Node (8);
		Head14.right.left = new Node (6);
		Head14.right.right = new Node (4);
		Head14.left.left.left = new Node (1);
		Printtree (HEAD14); SYstem.out.println (Isbst (HEAD14));
		Node res14 = Recovertree (HEAD14);
		Printtree (RES14);

	System.out.println (Isbst (RES14));
 }

}


Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.