[JAVA] Mémorandum bifurqué pour débutants (Partie 3 Réalisation à l'aide de cours)

Part 2 est ici

Réalisation de dichotomies à l'aide de classes

Cette fois, réalisons la dichotomie d'une manière différente qu'avant. Un arbre bifurqué est une collection de nœuds et de côtés. En d'autres termes, si vous pouvez créer un objet qui représente un nœud et une arête, vous pouvez réaliser une dichotomie en les connectant. En d'autres termes, il vous suffit de créer une classe qui contient des données de nœud et des enfants gauche et droit dans les champs.

Exemple d'implémentation

C++

BinaryTree.cpp

#include <iostream>
using namespace std;

class BinaryTree
{
	int value;
	BinaryTree *left;
	BinaryTree *right;

public:
 	BinaryTree(int);
	~BinaryTree();
	void insertNode(int);
	void inorder() const;
};

BinaryTree::BinaryTree(int value):value(value), left(0), right(0){}

BinaryTree::~BinaryTree()
{
	delete left;
	delete right;
}

void BinaryTree::insertNode(int value)
{
	if (this->value == value) {
		return;
	}

	else if (this->value > value) {
		if (this->left == 0) {
			this->left = new BinaryTree(value);
			return;
		}
		else {
			this->left->insertNode(value);
		}
	}

	else {
		if (this->right == 0) {
			this->right = new BinaryTree(value);
			return;
		}
		else {
			this->right->insertNode(value);
		}
	}
}

void BinaryTree::inorder() const
{
	if (this->left != 0) {
		this->left->inorder();
	}
	cout << this->value << " ";
	if (this->right != 0) {
		this->right->inorder();
	}

	return;
}

int main()
{
	BinaryTree root(20);
	root.insertNode(10);
	root.insertNode(26);
	root.insertNode(5);
	root.insertNode(14);
	root.insertNode(23);
	root.insertNode(25);

	root.inorder();
	cout << endl;
}

Java

BinaryTree.java

public class BinaryTree {
	int value;
	BinaryTree left;
	BinaryTree right;

	BinaryTree(int value) {
		this.value = value;
		this.left = null;
		this.right = null;
	}

	void insertNode(int value) {
		if (this.value == value) {
			return;
		}

		else if (this.value > value) {
			if (this.left == null) {
				this.left = new BinaryTree(value);
				return;
			}
			else {
				this.left.insertNode(value);
			}
		}

		else {
			if (this.right == null) {
				this.right = new BinaryTree(value);
				return;
			}
			else {
				this.right.insertNode(value);
			}
		}
	}

	void inorder() {
		if (this.left != null) {
			this.left.inorder();
		}
		System.out.print(this.value + " ");
		if (this.right != null) {
			this.right.inorder();
		}

		return;
	}

	public static void main(String[] args) {
		BinaryTree root = new BinaryTree(20);
		root.insertNode(10);
		root.insertNode(26);
		root.insertNode(5);
		root.insertNode(14);
		root.insertNode(23);
		root.insertNode(25);

		root.inorder();
		System.out.println();
	}
}

Explication sur la mise en œuvre

La dichotomie formée par la fonction insertNode dans ce programme est surtout appelée l'arbre de dichotomie (ne réfléchissez pas à la fonction insertNode car ce n'est pas important cette fois). Un arbre de dichotomie est une dichotomie spéciale dans laquelle les données de l'enfant de gauche sont toujours plus petites que les données du parent, et les données de l'enfant de droite sont toujours plus grandes que les données du parent. ). Les résultats de la recherche des dichotomies créées dans l'ordre de passage sont les suivants.

5 10 14 20 23 25 26

Avez-vous compris comment implémenter à l'aide de classes?

Part 4 est ici