You are on page 1of 6

ARBRE

Un graphe est un ensemble de sommets relis par des artes (arcs).


-Un graphe connexe (existe un chemin entre nimporte quelle paire de sommets).
-Un cycle est une suite dartes commenant et finissant par le mme sommet.

Un arbre est un graphe connexe qui ne contient pas de cycles. Cette dfinition nous indique
quun nud de larbre dpend dun seul autre nud que nous appelons son pre qui est son
prdcesseur direct.

En gnral, lorsquon dsigne un sommet quelconque comme la racine de larbre, ce dernier


sera appel structure arborescente.

Le pre dun nud est son anctre direct. La racine dun arbre n'a videmment pas de pre.

Les fils d'un nud sont ses descendants directs.

Un nud est une feuille sil na aucun descendant.

Une BinarySearchTreebranche d'un arbre est un chemin de la racine vers une feuille.

La hauteur dun arbre est le niveau maximal de ses nuds.

Le degr dun nud est le nombre de fils de ce nud. Le degr dun arbre est le degr maximal
parmi les degrs de ses nuds.

La taille dun arbre est le nombre de nuds de cet arbre.

L'arit de l'arbre est le nombre maximum de fils que peuvent avoir ses nuds.

Un arbre dgnr (ou arbre filiforme) est un arbre dont les nuds ne possde qu'un et un seul
fils. Cet arbre est donc tout simplement une liste chane. Il est viter.
ARBRE BINAIRE :
Dans un arbre binaire, les nuds ont au maximum 2 fils : un fils gauche et un fils droit.

Dans un arbre binaire plein, tout nud possde exactement 2 fils ( lexception des feuilles) et
toutes les feuilles sont de mme niveau.

Cest un arbre binaire de hauteur h qui est plein jusquau niveau h-1 et le niveau h est rempli de
gauche droite.
Arbre binaire de recherche (ABR) :
Un arbre binaire de recherche est un arbre binaire vide ou compos dune racine et de deux
sous-arbres gauche et droit tels que :
- Tout lment du sous-arbre gauche a une valeur infrieure la valeur de la racine.
- Tout lment du sous-arbre droit a une valeur suprieure la valeur de la racine.
- Les sous-arbres gauche et droit sont aussi des arbres binaires de recherche.

Il est possible dimplmenter un arbre :en utilisant un tableau ou bien dune manire
dynamique

Deux types de parcours :


-le parcours en profondeur(branche par branche) en ordre, pr-ordre, post-ordre.
- le parcours en largeur(niveau par niveau) bas sur l'utilisation d'une file

le parcours en profondeur :.

En Java :

public class BinarySearchTree {


class Node {
int data; // l'information stocker
Node left = null; // rfrence du fils gauche
Node right = null; // rfrence du fils droit

Node(int value) {
data = value;
left = right = null;}}
private Node root = null;
public static final int NOT_FOUND = -1;

public BinarySearchTree() {
root = null;}

public boolean isEmpty() {


return root == null;}

public int getSize() {


return getSize(root);}

private int getSize(Node root) {


if (root != null)
return 1 + getSize(root.left) + getSize(root.right);
else
return 0;}

public int getHeight() {


if (isEmpty())
return 0;
else
return getHeight(root);}

private int getHeight(Node root) {


if (root == null)
return 0;
int leftHeight = getHeight(root.left);
int rightHeight = getHeight(root.right);
int max = leftHeight > rightHeight ? leftHeight : rightHeight;
return 1 + max;}

public boolean isPerfect() {


if (root == null)
return true;

int size = getSize();


int height = getHeight();

return (size == Math.pow(2, height)-1);}

public void displayInOrder() {


if (isEmpty())
System.out.println("Empty Tree.");
else {
System.out.println("Tree : ");
displayInOrder(root);}}

private void displayInOrder(Node root) {


if (root != null) {
displayInOrder(root.left);
System.out.println(root.data);
displayInOrder(root.right);}}
public void displayPostOrder() {
if (isEmpty())
System.out.println("Empty Tree.");
else {
System.out.println("Tree : ");
displayPostOrder(root);}}

private void displayPostOrder(Node root) {


if (root != null) {
displayPostOrder(root.left);
displayPostOrder(root.right);
System.out.println(root.data);}}

public void displayPreOrder() {


if (isEmpty())
System.out.println("Empty Tree.");
else {
System.out.println("Tree : ");
displayPreOrder(root);}}

private void displayPreOrder(Node root) {


if (root != null) {
System.out.println(root.data);
displayPreOrder(root.left);
displayPreOrder(root.right);}}

public void insert(int value) {


// cration dynamique d'un noeud
Node tmp = new Node(value);
//cas d'un arbre vide
if (isEmpty())
this.root = tmp;
else
insert(this.root, tmp);}

private void insert(Node father, Node son){


if (father.data > son.data){
if (father.left == null)
father.left = son;
else
insert(father.left, son);}
else{
if (father.right == null)
father.right = son;
else
insert(father.right, son);}}

public Node search(int value) {


return search(this.root, value);}

private Node search(Node current, int value) {


if (current == null)
return null;
else if (current.data == value)
return current;
else if (current.data > value)
return search(root.left, value);
else
return search(root.right, value);}

public boolean isInABR(int value) {


return search(root, value) != null;}

public void remove(int value) {


Node newRoot = remove(this.root, value);
this.root = newRoot;}

private static Node remove(Node root, int value) {


if (root != null) {
if (value == root.data)
root = removeFromRoot(root);
else if (value < root.data) {
Node subTreeRoot = remove(root.left, value);
root.left = subTreeRoot;}
else { // value > root.data
Node subTreeRoot = remove(root.right, value);
root.right = subTreeRoot;}}
return root;}

private static Node removeFromRoot(Node root) {


if (root.left != null && root.right != null) {
Node maxLeft = findMax(root.left);
root.data = maxLeft.data;
root.left = removeMax(root.left);}
else if (root.right != null)
root = root.right;
else if (root.left != null)
root = root.left;

return root;}

private static Node removeMax(Node root){


if (root.right != null){
Node node = removeMax(root.right);
root.right = node;}
else
root = root.left;

return root;}

private static Node findMax(Node root){


if (root.right != null)
return findMax(root.right);
else
return root;}}