Ordenar árbol
clasificación de árboles es un algoritmo de clasificación que se basa en Árbol de búsqueda binaria estructura de datos. Primero crea un árbol de búsqueda binario a partir de los elementos de la lista o matriz de entrada y luego realiza un recorrido en orden en el árbol de búsqueda binario creado para obtener los elementos en orden.
Algoritmo:
Paso 1: Tome la entrada de elementos en una matriz.Paso 2: Cree un árbol de búsqueda binaria insertando elementos de datos de la matriz en el árbol de búsqueda binaria .Paso 3: Realice un recorrido en orden en el árbol para ordenar los elementos.Aplicaciones de la clasificación de árboles:
- Su uso más común es editar los elementos online: después de cada instalación, un conjunto de objetos vistos hasta el momento está disponible en un programa estructurado.
- Si utiliza un árbol de distribución como árbol de búsqueda binaria, el algoritmo resultante (llamado splaysort) tiene la propiedad adicional de que es una clasificación adaptativa, lo que significa que su tiempo de trabajo es más rápido que O (n log n) para entradas virtuales.
A continuación se muestra la implementación del enfoque anterior:
C++Java// C++ program to implement Tree Sort #includeusing namespace std ; struct Node { int key ; struct Node * left * right ; }; // A utility function to create a new BST Node struct Node * newNode ( int item ) { struct Node * temp = new Node ; temp -> key = item ; temp -> left = temp -> right = NULL ; return temp ; } // Stores inorder traversal of the BST // in arr[] void storeSorted ( Node * root int arr [] int & i ) { if ( root != NULL ) { storeSorted ( root -> left arr i ); arr [ i ++ ] = root -> key ; storeSorted ( root -> right arr i ); } } /* A utility function to insert a new Node with given key in BST */ Node * insert ( Node * node int key ) { /* If the tree is empty return a new Node */ if ( node == NULL ) return newNode ( key ); /* Otherwise recur down the tree */ if ( key < node -> key ) node -> left = insert ( node -> left key ); else if ( key > node -> key ) node -> right = insert ( node -> right key ); /* return the (unchanged) Node pointer */ return node ; } // This function sorts arr[0..n-1] using Tree Sort void treeSort ( int arr [] int n ) { struct Node * root = NULL ; // Construct the BST root = insert ( root arr [ 0 ]); for ( int i = 1 ; i < n ; i ++ ) root = insert ( root arr [ i ]); // Store inorder traversal of the BST // in arr[] int i = 0 ; storeSorted ( root arr i ); } // Driver Program to test above functions int main () { //create input array int arr [] = { 5 4 7 2 11 }; int n = sizeof ( arr ) / sizeof ( arr [ 0 ]); treeSort ( arr n ); for ( int i = 0 ; i < n ; i ++ ) cout < < arr [ i ] < < ' ' ; return 0 ; } Python3// Java program to // implement Tree Sort class GFG { // Class containing left and // right child of current // node and key value class Node { int key ; Node left right ; public Node ( int item ) { key = item ; left = right = null ; } } // Root of BST Node root ; // Constructor GFG () { root = null ; } // This method mainly // calls insertRec() void insert ( int key ) { root = insertRec ( root key ); } /* A recursive function to insert a new key in BST */ Node insertRec ( Node root int key ) { /* If the tree is empty return a new node */ if ( root == null ) { root = new Node ( key ); return root ; } /* Otherwise recur down the tree */ if ( key < root . key ) root . left = insertRec ( root . left key ); else if ( key > root . key ) root . right = insertRec ( root . right key ); /* return the root */ return root ; } // A function to do // inorder traversal of BST void inorderRec ( Node root ) { if ( root != null ) { inorderRec ( root . left ); System . out . print ( root . key + ' ' ); inorderRec ( root . right ); } } void treeins ( int arr [] ) { for ( int i = 0 ; i < arr . length ; i ++ ) { insert ( arr [ i ] ); } } // Driver Code public static void main ( String [] args ) { GFG tree = new GFG (); int arr [] = { 5 4 7 2 11 }; tree . treeins ( arr ); tree . inorderRec ( tree . root ); } } // This code is contributed // by Vibin MC## Python3 program to # implement Tree Sort # Class containing left and # right child of current # node and key value class Node : def __init__ ( self item = 0 ): self . key = item self . left self . right = None None # Root of BST root = Node () root = None # This method mainly # calls insertRec() def insert ( key ): global root root = insertRec ( root key ) # A recursive function to # insert a new key in BST def insertRec ( root key ): # If the tree is empty # return a new node if ( root == None ): root = Node ( key ) return root # Otherwise recur # down the tree if ( key < root . key ): root . left = insertRec ( root . left key ) elif ( key > root . key ): root . right = insertRec ( root . right key ) # return the root return root # A function to do # inorder traversal of BST def inorderRec ( root ): if ( root != None ): inorderRec ( root . left ) print ( root . key end = ' ' ) inorderRec ( root . right ) def treeins ( arr ): for i in range ( len ( arr )): insert ( arr [ i ]) # Driver Code arr = [ 5 4 7 2 11 ] treeins ( arr ) inorderRec ( root ) # This code is contributed by shinjanpatraJavaScript// C# program to // implement Tree Sort using System ; public class GFG { // Class containing left and // right child of current // node and key value public class Node { public int key ; public Node left right ; public Node ( int item ) { key = item ; left = right = null ; } } // Root of BST Node root ; // Constructor GFG () { root = null ; } // This method mainly // calls insertRec() void insert ( int key ) { root = insertRec ( root key ); } /* A recursive function to insert a new key in BST */ Node insertRec ( Node root int key ) { /* If the tree is empty return a new node */ if ( root == null ) { root = new Node ( key ); return root ; } /* Otherwise recur down the tree */ if ( key < root . key ) root . left = insertRec ( root . left key ); else if ( key > root . key ) root . right = insertRec ( root . right key ); /* return the root */ return root ; } // A function to do // inorder traversal of BST void inorderRec ( Node root ) { if ( root != null ) { inorderRec ( root . left ); Console . Write ( root . key + ' ' ); inorderRec ( root . right ); } } void treeins ( int [] arr ) { for ( int i = 0 ; i < arr . Length ; i ++ ) { insert ( arr [ i ]); } } // Driver Code public static void Main ( String [] args ) { GFG tree = new GFG (); int [] arr = { 5 4 7 2 11 }; tree . treeins ( arr ); tree . inorderRec ( tree . root ); } } // This code is contributed by Rajput-Ji
Producción2 4 5 7 11Análisis de complejidad:
Complejidad del tiempo promedio del caso: O(n log n) Agregar un elemento a un árbol de búsqueda binaria requiere en promedio tiempo O(log n). Por lo tanto, agregar n elementos tomará O (n log n) tiempo
Peor caso de complejidad temporal: En 2 ). La complejidad temporal del peor de los casos de Tree Sort se puede mejorar utilizando un árbol de búsqueda binario autoequilibrado como Red Black Tree AVL Tree. El uso de un árbol binario autoequilibrado Tree Sort tomará O(n log n) tiempo para ordenar la matriz en el peor de los casos.
Espacio Auxiliar: En)
Crear cuestionario
Te Puede Gustar
Artículos Más Populares
Categoría
Artículos De Interés
