Implémenter le tas en utilisant un arbre binaire
Cette question a déjà été posée dans Stack Exchange, mais elle est restée sans réponse.
Lien vers la question précédemment posée: Tas binaire implémenté via une structure arborescente binaire
Comment puis-je implémenter tas dans un arbre binaire. Pour implémenter heap, il est important de connaître le dernier nœud rempli et le premier nœud inoccupé. Cela pourrait être fait dans l'ordre des niveaux de l'arborescence, mais la complexité temporelle sera alors O(n) juste pour trouver le premier nœud inoccupé. Alors, comment implémenter le tas dans un arbre binaire dans O (logn)?
Merci Shekhar
Pour implémenter un segment de mémoire avec une arborescence binaire avec une complexité temporelle O (log n), vous devez stocker le nombre total de nœuds en tant que variable d'instance.
Supposons que nous ayons un tas de 10 nœuds au total.
Si nous devions ajouter un noeud ...
Nous incrémentons le nombre total de nœuds de un. Nous avons maintenant 11 nœuds au total. Nous convertissons le nouveau nombre total de nœuds (11) en sa représentation binaire: 1011.
Avec la représentation binaire du nombre total de nœuds (1011), nous nous débarrassons du premier chiffre. Ensuite, nous utilisons 011 pour naviguer dans l’arbre jusqu’au prochain emplacement dans lequel insérer un nœud. 0 signifie aller à gauche et 1 à droite. Par conséquent, avec 011, nous allions à gauche, à droite et à droite ... ce qui nous amène au prochain emplacement à insérer.
Nous avons examiné un nœud par niveau, ce qui rend la complexité temporelle O (log n)
Vous n'implémenterez pas le tas DANS L'ARBORESCENCE BINAIRE, car il s'agit de , UN ARBRE BINAIRE. Le segment de mémoire conserve la propriété d'ordre suivante - dans le cas d'un nœud V, son parent est supérieur ou égal à V. Le segment de mémoire est également complet arbre binaire . Comme je suivais un cours ADS à l’uni, je vous donnerai mon implémentation du tas en Java plus tard dans la réponse. Juste pour lister les principales complexités de méthodes que vous obtenez:
- taille () O (1)
- isEmpty () O (1)
- insert () O (logn)
- removeMin () O (logn)
- min () O (1)
Voici mon fichier Heap.Java:
public class Heap<E extends Comparable<E>> {
private Object S[];
private int last;
private int capacity;
public Heap() {
S = new Object[11];
last = 0;
capacity = 7;
}
public Heap(int cap) {
S = new Object[cap + 1];
last = 0;
capacity = cap;
}
public int size() {
return last;
}
//
// returns the number of elements in the heap
//
public boolean isEmpty() {
return size() == 0;
}
//
// is the heap empty?
//
public E min() throws HeapException {
if (isEmpty())
throw new HeapException("The heap is empty.");
else
return (E) S[1];
}
//
// returns element with smallest key, without removal
//
private int compare(Object x, Object y) {
return ((E) x).compareTo((E) y);
}
public void insert(E e) throws HeapException {
if (size() == capacity)
throw new HeapException("Heap overflow.");
else{
last++;
S[last] = e;
upHeapBubble();
}
}
// inserts e into the heap
// throws exception if heap overflow
//
public E removeMin() throws HeapException {
if (isEmpty())
throw new HeapException("Heap is empty.");
else {
E min = min();
S[1] = S[last];
last--;
downHeapBubble();
return min;
}
}
//
// removes and returns smallest element of the heap
// throws exception is heap is empty
//
/**
* downHeapBubble() method is used after the removeMin() method to reorder the elements
* in order to preserve the Heap properties
*/
private void downHeapBubble(){
int index = 1;
while (true){
int child = index*2;
if (child > size())
break;
if (child + 1 <= size()){
//if there are two children -> take the smalles or
//if they are equal take the left one
child = findMin(child, child + 1);
}
if (compare(S[index],S[child]) <= 0 )
break;
swap(index,child);
index = child;
}
}
/**
* upHeapBubble() method is used after the insert(E e) method to reorder the elements
* in order to preserve the Heap properties
*/
private void upHeapBubble(){
int index = size();
while (index > 1){
int parent = index / 2;
if (compare(S[index], S[parent]) >= 0)
//break if the parent is greater or equal to the current element
break;
swap(index,parent);
index = parent;
}
}
/**
* Swaps two integers i and j
* @param i
* @param j
*/
private void swap(int i, int j) {
Object temp = S[i];
S[i] = S[j];
S[j] = temp;
}
/**
* the method is used in the downHeapBubble() method
* @param leftChild
* @param rightChild
* @return min of left and right child, if they are equal return the left
*/
private int findMin(int leftChild, int rightChild) {
if (compare(S[leftChild], S[rightChild]) <= 0)
return leftChild;
else
return rightChild;
}
public String toString() {
String s = "[";
for (int i = 1; i <= size(); i++) {
s += S[i];
if (i != last)
s += ",";
}
return s + "]";
}
//
// outputs the entries in S in the order S[1] to S[last]
// in same style as used in ArrayQueue
//
}
HeapException.Java:
public class HeapException extends RuntimeException {
public HeapException(){};
public HeapException(String msg){super(msg);}
}
La partie intéressante qui vous donne les performances O(logn) est les méthodes downHeapBubble() et upHeapBubble(). Je vais ajouter une bonne explication à leur sujet sous peu.
upHeapBubble() est utilisé lors de l'insertion d'un nouveau noeud dans le tas. Ainsi, lorsque vous insérez, vous insérez à la dernière position et vous devez ensuite appeler la upHeapBubble() comme ceci:
last++;
S[last] = e;
upHeapBubble();
Ensuite, le dernier élément est comparé à son parent et si le parent est supérieur - swap: cela se fait max logn times où n est le nombre de nœuds. Alors, voici la performance de connexion.
Pour la partie suppression - vous ne pouvez supprimer que min - le nœud le plus élevé. Ainsi, lorsque vous le supprimez, vous devez l'échanger avec le dernier nœud, mais vous devez ensuite conserver la propriété heap et effectuer une opération downHeapBubble(). Si le nœud est plus grand que son échange d'enfants avec le plus petit, et ainsi de suite, jusqu'à ce qu'il ne reste plus aucun enfant ou que vous n'ayez pas d'enfants plus petits. Cela peut être fait au maximum des temps de connexion et voici donc les performances de connexion. Vous pouvez expliquer vous-même pourquoi cette opération peut être effectuée jusqu'à un maximum de fois de connexion en regardant dans les images de l'arbre binaire ici
MISE EN OEUVRE DE L'ARBRE
Je réponds à ma propre question qui prend O (log n), mais la limitation est de garder un pointeur sur le parent. si nous ne gardons pas un pointeur sur le parent, nous avons besoin d'environ O (n). J'ai posté cette question pour obtenir une solution pour O (log n)
Voici les étapes à suivre pour calculer la prochaine feuille inoccupée (nous avons un pointeur sur le nœud parent):
x = last inserted node. We save this after every insertion.
y = tmp node
z = next unoccupied node (next insertion)
if x is left child
z = x -> parent -> rightchild (problem solved.. that was easy)
else if x is right child
go to x's parent, until parent becomes left child. Let this node be y
(subtree rooted at y's sibling will contain the next unoccupied node)
z = y -> parent -> right -> go left until null
C'est O (log n), mais nécessite un pointeur sur le parent.
La solution O (n) serait assez facile, il suffit d’ordonner l’arborescence et on obtient l’emplacement du prochain noeud inoccupé.
Ma question est la suivante: comment localiser le prochain noeud inoccupé dans O (log n) sans utiliser de pointeur parent.
Merci.
En supposant que vous souhaitiez utiliser une arborescencelink binary, sans pointeurs sur les nœuds parents, la seule solution à laquelle je peux penser est de conserver un compteur du nombre d'enfants dans chaque nœud.
availableLeaf(node) {
if( node.left is Empty || node.right is Empty )
return node ;
else
if( node.left.count < node.right.count )
return availableLeaf(node.left)
else
return availableLeaf(node.right)
}
Cette stratégie équilibre également le nombre de nœuds de chaque côté de chaque sous-arbre, ce qui est bénéfique (bien que très légèrement).
C'est O (log n). Pour pouvoir compter sur l'insertion, il faut aller jusqu'au sommet du toit, mais cela ne change pas la nature de l'opération (Lon n). Chose similaire avec la suppression.
Les autres opérations sont habituelles et préservent leurs caractéristiques de performance.
Avez-vous besoin des détails ou préférez-vous les résoudre vous-même?
Si vous souhaitez utiliser une arborescence binaire liée, sans autre information que les pointeurs gauche et droit, je vous conseillerais alors d'initier une prime pour au moins 100 000 points. Je ne dis pas que c'est impossible (parce que je n'ai pas le calcul pour le prouver), mais je dis que cela n'a pas été trouvé depuis plusieurs décennies (ce que je sais).
L'arbre binaire peut être représenté par un tableau:
import Java.util.Arrays;
public class MyHeap {
private Object[] heap;
private int capacity;
private int size;
public MyHeap() {
capacity = 8;
heap = new Object[capacity];
size = 0;
}
private void increaseCapacity() {
capacity *= 2;
heap = Arrays.copyOf(heap, capacity);
}
public int getSize() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public Object top() {
return size > 0 ? heap[0] : null;
}
@SuppressWarnings("unchecked")
public Object remove() {
if (size == 0) {
return null;
}
size--;
Object res = heap[0];
Object te = heap[size];
int curr = 0, son = 1;
while (son < size) {
if (son + 1 < size
&& ((Comparable<Object>) heap[son + 1])
.compareTo(heap[son]) < 0) {
son++;
}
if (((Comparable<Object>) te).compareTo(heap[son]) <= 0) {
break;
}
heap[curr] = heap[son];
curr = son;
son = 2 * curr + 1;
}
heap[curr] = te;
return res;
}
@SuppressWarnings("unchecked")
public void insert(Object e) {
if (size == capacity) { // auto scaling
increaseCapacity();
}
int curr = size;
int parent;
heap[size] = e;
size++;
while (curr > 0) {
parent = (curr - 1) / 2;
if (((Comparable<Object>) heap[parent]).compareTo(e) <= 0) {
break;
}
heap[curr] = heap[parent];
curr = parent;
}
heap[curr] = e;
}
}
Usage:
MyHeap heap = new MyHeap(); // it is a min heap
heap.insert(18);
heap.insert(26);
heap.insert(35);
System.out.println("size is " + heap.getSize() + ", top is " + heap.top());
heap.insert(36);
heap.insert(30);
heap.insert(10);
while(!heap.isEmpty()) {
System.out.println(heap.remove());
}
Mon implémentation de tas
public class Heap <T extends Comparable<T>> {
private T[] arr;
private int size;
public Heap(T[] baseArr) {
this.arr = baseArr;
size = arr.length - 1;
}
public void minHeapify(int i, int n) {
int l = 2 * i + 1;
int r = 2 * i + 2;
int smallest = i;
if (l <= n && arr[l].compareTo(arr[smallest]) < 0) {
smallest = l;
}
if (r <= n && arr[r].compareTo(arr[smallest]) < 0) {
smallest = r;
}
if (smallest != i) {
T temp = arr[i];
arr[i] = arr[smallest];
arr[smallest] = temp;
minHeapify(smallest, n);
}
}
public void buildMinHeap() {
for (int i = size / 2; i >= 0; i--) {
minHeapify(i, size);
}
}
public void heapSortAscending() {
buildMinHeap();
int n = size;
for (int i = n; i >= 1; i--) {
T temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
n--;
minHeapify(0, n);
}
}
}
import Java.util.ArrayList;
import Java.util.List;
/**
* @author Harish R
*/
public class HeapPractise<T extends Comparable<T>> {
private List<T> heapList;
public List<T> getHeapList() {
return heapList;
}
public void setHeapList(List<T> heapList) {
this.heapList = heapList;
}
private int heapSize;
public HeapPractise() {
this.heapList = new ArrayList<>();
this.heapSize = heapList.size();
}
public void insert(T item) {
if (heapList.size() == 0) {
heapList.add(item);
} else {
siftUp(item);
}
}
private void siftUp(T item) {
heapList.add(item);
heapSize = heapList.size();
int currentIndex = heapSize - 1;
while (currentIndex > 0) {
int parentIndex = (int) Math.floor((currentIndex - 1) / 2);
T parentItem = heapList.get(parentIndex);
if (parentItem != null) {
if (item.compareTo(parentItem) > 0) {
heapList.set(parentIndex, item);
heapList.set(currentIndex, parentItem);
currentIndex = parentIndex;
continue;
}
}
break;
}
}
public T delete() {
if (heapList.size() == 0) {
return null;
}
if (heapList.size() == 1) {
T item = heapList.get(0);
heapList.remove(0);
return item;
}
return siftDown();
}
private T siftDown() {
T item = heapList.get(0);
T lastItem = heapList.get(heapList.size() - 1);
heapList.remove(heapList.size() - 1);
heapList.set(0, lastItem);
heapSize = heapList.size();
int currentIndex = 0;
while (currentIndex < heapSize) {
int leftIndex = (2 * currentIndex) + 1;
int rightIndex = (2 * currentIndex) + 2;
T leftItem = null;
T rightItem = null;
int currentLargestItemIndex = -1;
if (leftIndex <= heapSize - 1) {
leftItem = heapList.get(leftIndex);
}
if (rightIndex <= heapSize - 1) {
rightItem = heapList.get(rightIndex);
}
T currentLargestItem = null;
if (leftItem != null && rightItem != null) {
if (leftItem.compareTo(rightItem) >= 0) {
currentLargestItem = leftItem;
currentLargestItemIndex = leftIndex;
} else {
currentLargestItem = rightItem;
currentLargestItemIndex = rightIndex;
}
} else if (leftItem != null && rightItem == null) {
currentLargestItem = leftItem;
currentLargestItemIndex = leftIndex;
}
if (currentLargestItem != null) {
if (lastItem.compareTo(currentLargestItem) >= 0) {
break;
} else {
heapList.set(currentLargestItemIndex, lastItem);
heapList.set(currentIndex, currentLargestItem);
currentIndex = currentLargestItemIndex;
continue;
}
} else {
break;
}
}
return item;
}
public static void main(String[] args) {
HeapPractise<Integer> heap = new HeapPractise<>();
for (int i = 0; i < 32; i++) {
heap.insert(i);
}
System.out.println(heap.getHeapList());
List<Node<Integer>> nodeArray = new ArrayList<>(heap.getHeapList()
.size());
for (int i = 0; i < heap.getHeapList().size(); i++) {
Integer heapElement = heap.getHeapList().get(i);
Node<Integer> node = new Node<Integer>(heapElement);
nodeArray.add(node);
}
for (int i = 0; i < nodeArray.size(); i++) {
int leftNodeIndex = (2 * i) + 1;
int rightNodeIndex = (2 * i) + 2;
Node<Integer> node = nodeArray.get(i);
if (leftNodeIndex <= heap.getHeapList().size() - 1) {
Node<Integer> leftNode = nodeArray.get(leftNodeIndex);
node.left = leftNode;
}
if (rightNodeIndex <= heap.getHeapList().size() - 1) {
Node<Integer> rightNode = nodeArray.get(rightNodeIndex);
node.right = rightNode;
}
}
BTreePrinter.printNode(nodeArray.get(0));
System.out.println(heap.delete());
nodeArray = new ArrayList<>(heap.getHeapList().size());
for (int i = 0; i < heap.getHeapList().size(); i++) {
Integer heapElement = heap.getHeapList().get(i);
Node<Integer> node = new Node<Integer>(heapElement);
nodeArray.add(node);
}
for (int i = 0; i < nodeArray.size(); i++) {
int leftNodeIndex = (2 * i) + 1;
int rightNodeIndex = (2 * i) + 2;
Node<Integer> node = nodeArray.get(i);
if (leftNodeIndex <= heap.getHeapList().size() - 1) {
Node<Integer> leftNode = nodeArray.get(leftNodeIndex);
node.left = leftNode;
}
if (rightNodeIndex <= heap.getHeapList().size() - 1) {
Node<Integer> rightNode = nodeArray.get(rightNodeIndex);
node.right = rightNode;
}
}
BTreePrinter.printNode(nodeArray.get(0));
}
}
public class Node<T extends Comparable<?>> {
Node<T> left, right;
T data;
public Node(T data) {
this.data = data;
}
}
import Java.util.ArrayList;
import Java.util.Collections;
import Java.util.List;
class BTreePrinter {
public static <T extends Comparable<?>> void printNode(Node<T> root) {
int maxLevel = BTreePrinter.maxLevel(root);
printNodeInternal(Collections.singletonList(root), 1, maxLevel);
}
private static <T extends Comparable<?>> void printNodeInternal(
List<Node<T>> nodes, int level, int maxLevel) {
if (nodes.isEmpty() || BTreePrinter.isAllElementsNull(nodes))
return;
int floor = maxLevel - level;
int endgeLines = (int) Math.pow(2, (Math.max(floor - 1, 0)));
int firstSpaces = (int) Math.pow(2, (floor)) - 1;
int betweenSpaces = (int) Math.pow(2, (floor + 1)) - 1;
BTreePrinter.printWhitespaces(firstSpaces);
List<Node<T>> newNodes = new ArrayList<Node<T>>();
for (Node<T> node : nodes) {
if (node != null) {
String nodeData = String.valueOf(node.data);
if (nodeData != null) {
if (nodeData.length() == 1) {
nodeData = "0" + nodeData;
}
}
System.out.print(nodeData);
newNodes.add(node.left);
newNodes.add(node.right);
} else {
newNodes.add(null);
newNodes.add(null);
System.out.print(" ");
}
BTreePrinter.printWhitespaces(betweenSpaces);
}
System.out.println("");
for (int i = 1; i <= endgeLines; i++) {
for (int j = 0; j < nodes.size(); j++) {
BTreePrinter.printWhitespaces(firstSpaces - i);
if (nodes.get(j) == null) {
BTreePrinter.printWhitespaces(endgeLines + endgeLines + i
+ 1);
continue;
}
if (nodes.get(j).left != null)
System.out.print("//");
else
BTreePrinter.printWhitespaces(1);
BTreePrinter.printWhitespaces(i + i - 1);
if (nodes.get(j).right != null)
System.out.print("\\\\");
else
BTreePrinter.printWhitespaces(1);
BTreePrinter.printWhitespaces(endgeLines + endgeLines - i);
}
System.out.println("");
}
printNodeInternal(newNodes, level + 1, maxLevel);
}
private static void printWhitespaces(int count) {
for (int i = 0; i < 2 * count; i++)
System.out.print(" ");
}
private static <T extends Comparable<?>> int maxLevel(Node<T> node) {
if (node == null)
return 0;
return Math.max(BTreePrinter.maxLevel(node.left),
BTreePrinter.maxLevel(node.right)) + 1;
}
private static <T> boolean isAllElementsNull(List<T> list) {
for (Object object : list) {
if (object != null)
return false;
}
return true;
}
}
Notez que BTreePrinter est un code que j’ai pris quelque part dans Stackoverflow et que j’ai modifié pour utiliser des nombres à 2 chiffres. correctif pour les nombres à 3 chiffres: tout doit rester multiple de 3. Aussi crédit dû à Sesh Venugopal pour son excellent tutoriel sur Youtube sur la structure de données Heap