neues

Programmierung2/src/BinaryTree/BinaryBaumList.java

@@ -7,8 +7,7 @@ import java.util.Queue;
 public class BinaryBaumList {
 	Node root;
 
-	
+	// -----------------------------------------------------------------
-	//-----------------------------------------------------------------
 	private int findTreeHeightRekursiv(Node temp) {
 		if (temp == null)
 			return -1;
@@ -26,8 +25,8 @@ public class BinaryBaumList {
 		return findTreeHeightRekursiv(root);
 	}
 
-	//-----------------------------------------------------------------
+	// -----------------------------------------------------------------
-  	private void additerativ(int value) {
+	private void additerativ(int value) {
 		// erzeuge eine neue knote
 		Node newNode = new Node();
 		// setze in knote einen Wert
@@ -122,7 +121,7 @@ public class BinaryBaumList {
 
 	}
 
-	//-----------------------------------------------------------------
+	// -----------------------------------------------------------------
 	private int findMinRekursiv(Node temp) {
 
 		if (temp.left == null)
@@ -143,9 +142,9 @@ public class BinaryBaumList {
 		return findMinRekursiv(root);
 		// return findMinIterativ(root);
 	}
-	//-----------------------------------------------------------------
+	// -----------------------------------------------------------------
 
-	//-----------------------------------------------------------------
+	// -----------------------------------------------------------------
 	private int findMaxRekursiv(Node temp) {
 		// // Wenn es kein rechtes Kind gibt, ist dies das Maximum
 		if (temp.right == null)
@@ -175,17 +174,16 @@ public class BinaryBaumList {
 		return findMaxIterativ(root);
 	}
 
-	
+	// -----------------------------------------------------------------
-	//-----------------------------------------------------------------
+	private void printPreorder(Node temp) {// [root][left][right]
-	private void printPreorder(Node temp) {//[root][left][right]
 		if (temp == null)
 			return;
-		System.out.print(  temp.value+ " " );
+		System.out.print(temp.value + " ");
 		printPreorder(temp.left);
 		printPreorder(temp.right);
 	}
 
-	private void printInorder(Node temp) {//[left][root][right]
+	private void printInorder(Node temp) {// [left][root][right]
 		if (temp == null) {
 			return;
 		}
@@ -195,13 +193,13 @@ public class BinaryBaumList {
 
 	}
 
-	private void printPostoder(Node temp) {//[left][right][root]
+	private void printPostoder(Node temp) {// [left][right][root]
 		if (temp == null)
 			return;
 
 		printPreorder(temp.left);
 		printPreorder(temp.right);
-		System.out.print(  temp.value+ " " );
+		System.out.print(temp.value + " ");
 	}
 
 	private void BreadthFirst() {
@@ -245,13 +243,211 @@ public class BinaryBaumList {
 		}
 	}
 
-	
 	public void printDepth() {
-		//printPreorder(root);
+		// printPreorder(root);
-		//printInorder(root);
+		// printInorder(root);
 		BreadthFirst();
 	}
-	//-----------------------------------------------------------------
+	// -----------------------------------------------------------------
 	
+	/*
+	 * Löschen von Knoten: 
+	 * - wenn eine Knote gelöscht werden soll, sollen erst 4 wichtige Eigenschaften betrachtet werden: 
+	 * 		1. ob die Knote überhaupt igrendwo im Baum liegt (suchen)
+	 * 		2. ob die Knote ein Blatt (leaf Node) ist,das heißt die Knote hat weder rechte Knote noch linke Knote 
+	 * 		3. ob die Knote nur ein einziges Kind hat 
+	 * 		4. ob die Knote zwei Kinder hat
+	 * 			4.1 hier entscheidt man, was er nehmen möchte:
+	 * 				. Inorder-Vorgänger: Suche nach dem größten Knoten im linken Teilbaum
+	 * 				. Inorder-Nachfolger: Suche nach dem kleinsten Knoten im rechten Teilbaum.
+	 * 
+	 */
+
+	// 1. Suchen
+	private boolean searchNummberIterativ(int value) {
+		if (root == null)
+			return false;
+		
+		Node temp = root;
+		while (temp.value != value) {
+			if (value < temp.value && temp.left != null)
+				temp = temp.left;
+
+			else if (value >= temp.value && temp.right != null)
+				temp = temp.right;
+
+			else
+				break;
+		}
+		if (temp.value == value)
+			return true;
+
+		return false;
+
+	}
+	
+	private boolean searchNummberRekursiv(Node temp , int value) {
+		if (temp == null)
+			return false;
+		
+		if (temp.value == value)
+			return true;
+		
+		else if(value < temp.value)
+			return	searchNummberRekursiv(temp.left , value);
+		
+		else
+			return searchNummberRekursiv(temp.right , value);
+			
+	}
+	
+	public void searchNummber(int value) {
+		
+		if(searchNummberRekursiv(root,value))
+			System.out.println("Ist gefunden: " + value);
+		else
+			System.out.println("Ist nicht gefunden!");
+	}
+  
+	
+	//2. löschen als leaf Node
+	private void removeleafNode(int value) {
+		if (!searchNummberIterativ(value)) {
+			System.out.println("Die zahl befindet sich nicht im Baum!");
+			return;
+		}
+		Node temp = root;
+		Node merker = null;
+		while( temp.value != value) {
+			merker = temp;
+			if (value < temp.value)
+				temp = temp.left;
+			
+			else if (value >= temp.value)
+				temp = temp.right;
+		}
+		if (temp.value < merker.value)
+			merker.left = null;
+		
+		else
+			merker.right = null;
+	}
+	
+	//3. lösche eine Knote mit einem einzigen Kind
+	private void removeWithOneChild(int value) {
+		if (!searchNummberIterativ(value)) {
+			System.out.println("Die zahl befindet sich nicht im Baum!");
+			return;
+		}
+		Node temp = root;
+		Node merker = null;
+		while( temp.value != value) {
+			merker = temp;
+			if (value < temp.value)
+				temp = temp.left;
+			
+			else if (value >= temp.value)
+				temp = temp.right;
+		}
+		
+		if (temp.left != null)
+			merker.left = temp.left;
+		else
+			merker.right = temp.right;
+		
+	}
+	
+	//4. lösche eine Knote mit zwei Kindern
+	private void removeWithTwoChildern(int value) {
+		if (!searchNummberIterativ(value)) {
+			System.out.println("Die zahl befindet sich nicht im Baum!");
+			return;
+		}
+		Node temp = root;
+		Node merker = null;
+		while( temp.value != value) {
+			if (value < temp.value)
+				temp = temp.left;
+			
+			else if (value >= temp.value)
+				temp = temp.right;
+			
+			merker = temp;
+		}
+		temp = temp.left;
+		Node merker2 = temp;
+		while(temp.right != null) {
+			merker2 = temp;
+			temp = temp.right;
+		}
+		merker.value = temp.value;
+		merker2.right = null;
+	}
+	
+	//2,3,4 Cases
+	private void removWithAllCases(int value) {
+		if (!searchNummberIterativ(value)) {
+			System.out.println("Die zahl befindet sich nicht im Baum!");
+			return;
+		}
+
+		Node temp = root;
+		Node merker = null;
+		while (temp.value != value) {
+			merker = temp;
+			if (value < temp.value)
+				temp = temp.left;
+
+			else if (value >= temp.value)
+				temp = temp.right;
+
+		}
+
+		// Die knote ist ein Blatt (leaf Node)
+		if (temp.left == null && temp.right == null) {
+			if (merker == null)
+				root =null;
+			else if (merker.left == temp)
+				merker.left = null;
+			else
+				merker.right = null;
+		}
+		
+		// Die Knote hat genau ein Kind entweder links oder rechts
+		if (temp.left == null || temp.right == null) {
+			if (temp.left != null && temp.right == null)
+				merker.left = temp.left;
+
+			else
+				merker.right = temp.right;
+
+			return;
+		}
+
+		// Die Knote hat zwei Kinder
+		else {
+			merker = temp;
+			// weg(1): nach links gehen und ganz nach unten rechts gehen
+			temp = temp.left;
+			Node merker2 = temp;
+			while (temp.right != null) {
+				merker2 = temp;
+				temp = temp.right;
+			}
+			merker.value = temp.value;
+			merker2.right = null;
+		}
+		
+		
+		
+		
+
+	}
+	public void removNode(int value) {
+		// removeleafNode(value); 
+		//removeWithOneChild(value);
+		//removeWithTwoChildern(value);
+		 removWithAllCases(value);
+	}
 	
 }

Programmierung2/src/BinaryTree/Test.java

@@ -4,21 +4,36 @@ public class Test {
 
 	public static void main(String[] args) {
 		BinaryBaumList b1 = new BinaryBaumList();
-		b1.addElement(15);
+		b1.addElement(50);
-		b1.addElement(6);
+		b1.addElement(30);
-		b1.addElement(3);
+		b1.addElement(70);
-		b1.addElement(9);
-		b1.addElement(8);
 		b1.addElement(20);
+		b1.addElement(40);
+		b1.addElement(60);
+		b1.addElement(80);
+		b1.addElement(15);
+		b1.addElement(22);
+		b1.addElement(35);
+		b1.addElement(45);
+		b1.addElement(21);
 		b1.addElement(25);
 
 
-		System.out.print("[ ");
+	
+		
+		System.out.print("[");
 		b1.printDepth();
-		System.out.print(" ]");
+		System.out.print("]");
+		System.out.println();
+		b1.removNode(30);
+		System.out.print("[");
+		b1.printDepth();
+		System.out.print("]");
 
 	}
 	
 
 	
+	
+
 }