3009594
/
Programmierung2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

neues

master
obaya 2024-08-21 20:55:37 +02:00
parent 45d95a70a4
commit 7052e9e82c
2 changed files with 244 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

230
Programmierung2/src/BinaryTree/BinaryBaumList.java
View File

@ -7,8 +7,7 @@ import java.util.Queue;
public class BinaryBaumList {
Node root;
//-----------------------------------------------------------------
// -----------------------------------------------------------------
private int findTreeHeightRekursiv(Node temp) {
if (temp == null)
return -1;
@ -26,7 +25,7 @@ public class BinaryBaumList {
return findTreeHeightRekursiv(root);
}
//-----------------------------------------------------------------
// -----------------------------------------------------------------
private void additerativ(int value) {
// erzeuge eine neue knote
Node newNode = new Node();
@ -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);
//printInorder(root);
// printPreorder(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);
}
}

29
Programmierung2/src/BinaryTree/Test.java
View File

@ -4,21 +4,36 @@ public class Test {
public static void main(String[] args) {
BinaryBaumList b1 = new BinaryBaumList();
b1.addElement(15);
b1.addElement(6);
b1.addElement(3);
b1.addElement(9);
b1.addElement(8);
b1.addElement(50);
b1.addElement(30);
b1.addElement(70);
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("]");
}
}