logo

Structures de données en Java

Les nombreuses façons dont les données peuvent être organisées, enregistrées et traitées dans un programme informatique sont appelées structures de données en Java. Ces structures offrent une méthode méthodique pour manipuler et gérer efficacement les données, permettant des opérations utiles telles que l'insertion, la suppression, la récupération et le parcours.

L'article explorera tout ce qui concerne les structures de données en Java et aidera les débutants à comprendre facilement et efficacement.

  • Qu'est-ce que 'java?
  • Que sont les structures de données en Java ?
  • Types de structures de données en Java
  • Avantages des structures de données en Java
  • Classification des structures de données
  • FAQ sur les structures de données dans Java

Qu'est-ce que 'java?

Java est un langage de programmation orienté objet populaire, réputé pour sa vaste bibliothèque standard et la liberté de sa plateforme. Il offre une architecture solide pour créer des programmes exécutés sans recompilation sur diverses plates-formes. La célèbre bibliothèque pour Java propose un choix de systèmes d'enregistrement qui permettent de traiter efficacement de nombreux types de données.

Que sont les structures de données en Java ?

La manière dont les données sont organisées et stockées dans la mémoire d'un programme informatique repose étroitement sur les structures d'enregistrement Java. La célèbre bibliothèque Java comprend un type important de structures statistiques intégrées. Quelques-uns des systèmes d'enregistrement qui permettent aux programmeurs de sauvegarder et d'organiser les données de manière courte et simple incluent des listes connectées, des piles, des files d'attente et des tableaux. Les développeurs peuvent effectuer rapidement des opérations telles que l'insertion, la suppression, la recherche et le tri, car ils fournissent une gamme de mécanismes pour accéder, modifier et gérer les données. Les programmeurs Java peuvent réduire l'utilisation de la mémoire et augmenter considérablement l'efficacité globale de leurs programmes en utilisant ces structures de données.

Types de structures de données en Java

La liste des structures de données en Java répertoriées ci-dessous

  1. Tableaux
  2. Liste des tableaux
  3. Liste liée
  4. Empiler
  5. File d'attente
  6. Carte de hachage
  7. Jeu de hachage
  8. Ensemble d'arbres
  9. ArbreCarte
  10. Graphique
  11. Arbre

Le diagramme ci-dessous explique clairement les types de structures de données en Java.

Structures de données en Java

Classification supplémentaire des types de structures de données :

Il existe deux types de structures de données : -

  1. Structures de données primitives
  2. Structures de données non primitives

1) Structures de données primitives : Également appelés types de données primitifs, il s’agit de types de données de base intégrés à Java. Ils comprennent:

    Octet:Stocke les nombres entiers de -128 à 127.court:Stocke les nombres entiers de -32 768 à 32 767.entier :Stocke les nombres entiers de -2 147 483 648 à 2 147 483 647.flotter:Stocke les nombres à virgule flottante avec une simple précision.carboniser:Stocke des caractères individuels.booléen :Stocke les valeurs vraies ou fausses.long:Stocke de grands nombres entiers.Double:Stocke les nombres à facteur flottant avec une double précision.

2) Structures de données non primitives : Les structures d'enregistrements non primitifs sont plus complexes et sont composées de types d'informations primitives. Ils peuvent en outre être classés en deux sortes :

    Structures de données linéaires :Dans les structures de données linéaires, les éléments sont disposés linéairement ou séquentiellement. Les exemples comprennent:
      Tableaux :Groupe d'éléments de type identique placés dans un tableau selon un arrangement prédéterminé.Piles :Une structure Last In, First Out (LIFO) dans laquelle seuls les éléments les plus hauts peuvent être ajoutés ou supprimés.Queues:Les structures premier entré, premier sorti (FIFO) sont utilisées dans les files d'attente, où les articles sont insérés au retour et retirés au recto.Liste liée :Une liste associée comprend un ensemble de gadgets appelés nœuds, chacun d'entre eux comportant une référence au nœud qui le suit et des statistiques à l'intérieur.
    Structures de données non linéaires :Dans les structures de données non linéaires, les éléments sont disposés de manière non séquentielle. Les exemples comprennent:
      Des arbres:Les arbres sont un type de structure hiérarchique basée sur des nœuds, avec un nœud racine au sommet et des nœuds enfants qui en partent. Les exemples incluent les arbres rouge-noir, les arbres AVL, les arbres de recherche binaires et les arbres binaires.Graphiques :Un ensemble de nœuds liés à l'aide d'arêtes, dans lequel les nœuds peuvent avoir n'importe quelle quantité de connexions. Les graphiques sont utilisés pour symboliser des relations complexes entre des éléments.Tas:Une structure arborescente spécialisée dans laquelle chaque nœud déterminé a une valeur supérieure ou inférieure à celle de ses enfants, selon qu'il s'agit ou non d'un tas maximum ou d'un tas minimum.Hacher:Structures de données qui utilisent une fonction de hachage pour mapper les clés aux valeurs. Les exemples consistent en des jeux de hachage et des cartes de hachage, qui permettent une récupération et un stockage verts de statistiques basées sur des clés précises.
Structures de données en Java

Avantages des structures de données en Java

    Organisation efficace des données :Les structures de données fournissent des moyens organisés de stocker et de gérer les données, permettant des opérations d'accès, de manipulation et de récupération efficaces. Ils optimisent l'utilisation de la mémoire et facilitent une exécution plus rapide des algorithmes.Meilleure performance:Les développeurs peuvent améliorer les performances en termes de vitesse et d'utilisation de la mémoire en sélectionnant la structure de données appropriée pour une activité particulière. Les performances sont optimisées car des structures de données spécifiques sont conçues pour exceller dans des actions particulières telles que la recherche, le tri ou l'insertion d'informations.Réutilisabilité du code :Java offre une large gamme de structures de données intégrées simples à utiliser pour les programmeurs. Ces structures de données réutilisables permettent d'économiser du temps et des efforts en éliminant le besoin de créer des algorithmes sophistiqués à partir de zéro.Simplicité du code :Les structures de données simplifient la mise en œuvre de processus complexes à coder. Ils offrent des abstractions de haut niveau et encapsulent les spécificités de la gestion des données, ce qui améliore la lisibilité, la maintenabilité et la clarté du code.Flexibilité et adaptabilité :Les structures de données offrent une flexibilité dans la gestion de différents types et tailles de données. Ils peuvent s'adapter de manière dynamique pour s'adapter aux exigences changeantes en matière de données et fournir des mécanismes pour une manipulation efficace des données.Standardisé et bien testé :La bibliothèque standard pour Java contient des structures de données intégrées qui ont fait l'objet d'importants tests et optimisations, garantissant leur fiabilité et leurs performances. L'utilisation de ces structures de données communes réduit le risque d'erreurs et donne au développement d'applications une base solide.Évolutivité :Les structures de données offrent des options d'évolutivité, permettant aux applications de gérer efficacement de gros volumes de données. Ils peuvent croître ou diminuer de manière dynamique en fonction de la taille des données, garantissant ainsi des performances optimales même avec des demandes croissantes de données.Conception d'algorithmes :Les structures de données sont cruciales dans la conception et l’analyse des algorithmes. Ils fournissent la structure sous-jacente et les opérations nécessaires à la mise en œuvre de divers algorithmes et à la résolution de problèmes complexes.

1) Tableaux :

Un tableau est une structure de données de base souvent utilisée dans le contexte des structures de données Java. Il offre une méthode de stockage d'une collection de taille fixe de composants de type identique. Parce qu'ils offrent un accès rapide et facile aux éléments en fonction de leur index, les tableaux sont un outil crucial pour gérer et organiser les données.

Avantages :

    Organisation des données :Les tableaux offrent un moyen structuré de stocker et d'organiser les éléments, améliorant ainsi la gestion des données.Accès aléatoire:Les éléments sont accessibles directement à l'aide de leur index, permettant une récupération et une modification efficaces.Taille fixe:Les tableaux ont une taille prédéterminée, permettant une allocation de mémoire efficace.Éléments homogènes :Les tableaux stockent des éléments du même type, garantissant la cohérence des données et simplifiant les opérations.Itération:Les tableaux prennent en charge une itération facile à travers les éléments, facilitant ainsi le parcours et le traitement.Tri et recherche :Les tableaux fonctionnent bien avec les algorithmes de tri et de recherche, offrant des opérations efficaces.Efficacité de la mémoire :Les tableaux optimisent l'utilisation de la mémoire en stockant les éléments dans des régions contiguës.Compatibilité:Les tableaux sont largement pris en charge en Java, ce qui les rend compatibles avec divers frameworks et outils.

Désavantages:

    Taille fixe:Les tableaux ne peuvent pas être redimensionnés dynamiquement, ce qui nécessite une recréation pour les changements de taille.Gaspillage de mémoire :Les éléments inutilisés dans des tableaux plus grands peuvent entraîner un gaspillage de mémoire.Frais généraux d’insertion et de suppression :L'insertion ou la suppression d'éléments au milieu d'un tableau nécessite le déplacement des éléments suivants, ce qui entraîne une inefficacité.Manque de flexibilité :Les tableaux ont des types de données rigides et ne peuvent pas prendre en charge différents types de données sans tableaux ou structures de données supplémentaires.

Les fonctions:

    Création d'un tableau :Déclarez et initialisez un tableau avec une taille spécifique en utilisant le type de tableau et le mot-clé new.Accéder aux éléments :Utilisez l'index pour accéder aux éléments individuels du tableau.Modification d'éléments :Mettez à jour la valeur d'un élément en attribuant une nouvelle valeur à un index spécifique du tableau.Longueur de recherche :Utilisez l'attribut length pour déterminer la longueur du tableau.Itérer dans le tableau :Utilisez des boucles pour parcourir chaque élément du tableau et exécuter

Mise en œuvre:

Nom de fichier: ArrayExample.java

 import java.util.*; public class ArrayExample { public static void main(String[] args) { int[] numbers={10,20,30,40,50}; // Initialize an array of integers System.out.println(&apos;Element at index 0:&apos;+numbers[0]); System.out.println(&apos;Element at index 2:&apos;+numbers[2]); System.out.println(&apos;Element at index 4:&apos;+numbers[4]); int sum=0; for (int i=0;i<numbers.length;i++) { sum+="numbers[i];" } system.out.println('sum of array elements:'+sum); numbers[2]="35;" update an element in the system.out.println('updated at index 2:'+numbers[2]); system.out.println('elements array:'); for (int number:numbers) system.out.println(number); < pre> <p> <strong>Output:</strong> </p> <pre> Element at index 0:10 Element at index 2:30 Element at index 4:50 Sum of array elements:150 Updated element at index 2:35 Elements in the array: 10 20 35 40 50 </pre> <h3>2) ArrayList:</h3> <p>ArrayList in Java is a dynamic data structure that allows for the storage and manipulation of elements. It is part of the Java Collections Framework and is implemented using an array internally.</p> <p> <strong>Advantages:</strong> </p> <ol class="points"> <tr><td>Dynamic Size:</td> Unlike arrays, ArrayLists can dynamically grow or shrink in size as elements are added or removed. It eliminates the need for manual resizing and allows for handling varying amounts of data conveniently. </tr><tr><td>Easy Element Manipulation:</td> ArrayLists offer methods to add, remove, and modify elements at any position within the list. Its flexibility simplifies common operations such as insertion, deletion, and updating, making element manipulation more efficient. </tr><tr><td>Random Access:</td> ArrayLists support random Access to elements using their index, enabling quick retrieval and modification of elements at specific positions within the list. It facilitates efficient element access and enhances overall performance. </tr><tr><td>Compatibility with Java Collection Framework:</td> ArrayLists implement the List interface, making them compatible with other Collection classes in the Java Collections Framework. Its compatibility allows for seamless integration with various algorithms and operations provided by the framework. </tr></ol> <p> <strong>Disadvantages:</strong> </p> <ol class="points"> <tr><td>Higher Memory Overhead:</td> ArrayLists require additional memory to maintain their internal structure, resulting in higher memory overhead compared to arrays. It can be a concern when dealing with large collections of elements. </tr><tr><td>Slower Insertion and Deletion:</td> Inserting or deleting elements in the middle of an ArrayList requires shifting elements, which can be time-consuming for large lists. In scenarios where frequent insertion or deletion operations are expected, other data structures like LinkedList may offer better performance. </tr><tr><td>Limited Performance for Search:</td> Searching for an element in an unsorted ArrayList requires iterating over the elements until a match is found. It is a linear search approach that results in slower search performance compared to data structures optimized for searching, such as HashSet or TreeMap. </tr><tr><td>No Primitive Type Support:</td> ArrayLists can only store objects and do not directly support primitive data types like int or char. To store primitive types, wrapper classes like Integer or Character need to be used, leading to potential autoboxing and unboxing overhead. </tr></ol> <p> <strong>Functions:</strong> </p> <ol class="points"> <tr><td>Creating an ArrayList:</td> Declare and initialize an ArrayList using the ArrayList class and specify the element type within the angle brackets. </tr><tr><td>Adding Elements:</td> Use the add method to append elements at the end of the ArrayList. </tr><tr><td>Accessing Elements:</td> Use the get technique to retrieve the price of detail at a selected index. </tr><tr><td>Modifying Elements:</td> Update the cost of detail at a specific index for the usage of the set approach. </tr><tr><td>Finding Size:</td> Use the dimensions method to get the cutting-edge quantity of factors in the ArrayList. </tr><tr><td>Removing Elements:</td> Use the remove approach to delete a detail at a specific index or via providing the object reference. </tr><tr><td>Iterating through the ArrayList:</td> Use loops to iterate over each element in the ArrayList and perform operations on them. </tr></ol> <p> <strong>Implementation:</strong> </p> <p> <strong>FileName:</strong> ArrayListExample.java</p> <pre> import java.util.*; public class ArrayListExample { public static void main(String[] args) { // Create an ArrayList to store integers ArrayList numbers=new ArrayList(List.of(10,20,30,40,50)); //Access and print elements from the ArrayList System.out.println(&apos;Element at index 0:&apos;+numbers.get(0)); System.out.println(&apos;Element at index 2:&apos;+numbers.get(2)); System.out.println(&apos;Element at index 4:&apos;+numbers.get(4)); // Calculate and print the sum of all elements in the ArrayList int sum=numbers.stream().mapToInt(Integer::intValue).sum(); System.out.println(&apos;Sum of ArrayList elements:&apos;+sum); // Update an element in the ArrayList numbers.set(2,35); System.out.println(&apos;Updated element at index 2:&apos;+numbers.get(2)); // Iterate through the ArrayList using a for-each loop and print the elements System.out.println(&apos;Elements in the ArrayList:&apos;); for (int number:numbers) { System.out.println(number); } } } </pre> <p> <strong>Output:</strong> </p> <pre> Element at index 0:10 Element at index 2:30 Element at index 4:50 Sum of ArrayList elements:150 Updated element at index 2:35 Elements in the ArrayList: 10 20 35 40 50 </pre> <h3>3) Linked List:</h3> <p>A linked list is a linear data structure in which elements are stored in separate objects called nodes. A reference link to the following node in the sequence is included in each node&apos;s data element. The list&apos;s final node links to null, indicating that the list has ended.</p> <p>Unlike arrays, linked lists do not require contiguous memory allocation. Each node in a linked list can be allocated independently, allowing for dynamic memory allocation and efficient insertion and deletion operations.</p> <p> <strong>Advantages:</strong> </p> <ol class="points"> <tr><td>Dynamic Size:</td> LinkedList can grow or shrink dynamically, making it suitable for varying or unknown data sizes. </tr><tr><td>Efficient Insertion and Deletion:</td> Inserting or deleting elements within a LinkedList is efficient, as it does not require shifting elements. </tr><tr><td>No Contiguous Memory Requirement:</td> LinkedList does not need contiguous memory allocation, making it flexible and suitable for unpredictable memory situations. </tr><tr><td>Easy Modification:</td> LinkedList allows easy modification of elements by changing reference pointers, enabling efficient manipulation. </tr></ol> <p> <strong>Disadvantages:</strong> </p> <ol class="points"> <tr><td>Slower Random Access:</td> LinkedList has slower random Access as it requires traversing the list to access elements by index. </tr><tr><td>Increased Memory Overhead:</td> LinkedList requires additional memory for references and nodes, increasing memory overhead compared to arrays. </tr><tr><td>Inefficient Search:</td> LinkedList has slower search operations, requiring sequential iteration to find specific elements. </tr></ol> <p> <strong>Functions:</strong> </p> <ol class="points"> <tr><td>Creating a LinkedList:</td> Declare and initialize a LinkedList using the LinkedList class. </tr><tr><td>Adding Elements:</td> Use the add method to append elements at the end of the LinkedList. </tr><tr><td>Accessing Elements:</td> Use the get method to retrieve the value of an element at a specific index. </tr><tr><td>Modifying Elements:</td> Update the value of an element at a particular index using the set method. </tr><tr><td>Removing Elements:</td> Use the remove method to delete an element at a specific index or by providing the object reference. </tr></ol> <p> <strong>Implementation:</strong> </p> <p> <strong>FileName:</strong> LinkedList1.java</p> <pre> import java.util.*; public class LinkedList1 { public static void main(String[] args) { // Create a LinkedList to store integers LinkedList linkedList1 = new LinkedList(); // Add elements to the LinkedList linkedList1.add(10); linkedList1.add(20); linkedList1.add(30); linkedList1.add(40); linkedList1.add(50); // Print the LinkedList System.out.println(&apos;LinkedList:&apos;+linkedList1); // Remove an element from the LinkedList linkedList1.removeFirst(); System.out.println(&apos;LinkedList after removing first element:&apos;+linkedList1); // Check if an element exists in the LinkedList boolean containsElement=linkedList1.contains(30); System.out.println(&apos;LinkedList contains element 30?&apos;+containsElement); // Get the first and last elements of the LinkedList int firstElement=linkedList1.getFirst(); int lastElement=linkedList1.getLast(); System.out.println(&apos;First element:&apos;+firstElement); System.out.println(&apos;Last element:&apos;+lastElement); // Clear the LinkedList linkedList1.clear(); System.out.println(&apos;LinkedList after clearing:&apos;+linkedList1); } } </pre> <p> <strong>Output:</strong> </p> <pre> LinkedList:[10, 20, 30, 40, 50] LinkedList after removing first element:[20, 30, 40, 50] LinkedList contains element 30?true First element:20 Last element:50 LinkedList after clearing:[] </pre> <h3>4) Stack:</h3> <p>The Last-In-First-Out (LIFO) principle dictates that the element that was most recently inserted is also the element that is removed first. A stack is a linear data structure that follows this rule. It employs the commands &apos;push&apos; and &apos;pop&apos; to add elements to the stack and, accordingly, remove the top element from the stack. The &apos;peek&apos; technique additionally enables Access to the top element without removing it.</p> <p> <strong>Features of a stack:</strong> </p> <ol class="points"> <tr><td>LIFO behavior:</td> The last element pushed onto the stack is the first one to be popped out, making it suitable for applications where the order of insertion and removal is important. </tr><tr><td>Limited Access:</td> Stacks typically provide restricted Access to elements. You can only access the topmost element, and to reach other elements, you need to pop the elements above them. </tr><tr><td>Dynamic size:</td> Stacks can be implemented using arrays or linked lists, allowing for a dynamic size. They can grow or shrink as needed during runtime. </tr></ol> <p> <strong>Advantages:</strong> </p> <ol class="points"> <tr><td>Simplicity:</td> Stacks are easy to understand and implement. </tr><tr><td>Efficiency:</td> Insertion and deletion operations have a time complexity of O(1). </tr><tr><td>Function call management:</td> Stacks efficiently manage function calls and variable storage. </tr><tr><td>Undo/Redo functionality:</td> Stacks enable undo and redo operations in applications. </tr></ol> <p> <strong>Disadvantages:</strong> </p> <ol class="points"> <tr><td>Limited Access:</td> Access to elements is restricted to the top of the stack. </tr><tr><td>Size restrictions:</td> Stacks may have size limitations depending on the implementation. </tr><tr><td>Not suitable for all scenarios:</td> Stacks are specific to LIFO behavior and may not be appropriate in other cases. </tr></ol> <p> <strong>Implementation:</strong> </p> <p> <strong>FileName:</strong> StackExample.java</p> <pre> import java.util.Stack; public class StackExample { public static void main(String[] args) { // Create a stack Stack stack=new Stack(); // Push elements onto the stack stack.push(10); stack.push(20); stack.push(30); // Print the top element of the stack System.out.println(&apos;Top element:&apos;+stack.peek()); // Pop elements from the stack int poppedElement=stack.pop(); System.out.println(&apos;Popped element:&apos;+poppedElement); // Check if the stack is empty System.out.println(&apos;Is stack empty?&apos;+stack.isEmpty()); // Get the size of the stack System.out.println(&apos;Stack size:&apos;+stack.size()); // Iterate over the stack System.out.println(&apos;Stack elements:&apos;); for (Integer element:stack) { System.out.println(element); } } } </pre> <p> <strong>Output:</strong> </p> <pre> Top element:30 Popped element:30 Is stack empty?false Stack size:2 Stack elements: 10 20 </pre> <h3>5) Queue:</h3> <p>A queue is a linear data structure in Java that follows the First-In-First-Out (FIFO) principle. It represents a collection of elements where elements are inserted at the rear and removed from the front.</p> <p> <strong>Features:</strong> </p> <ol class="points"> <tr><td>Enqueue:</td> Adding an element to the rear of the queue. </tr><tr><td>Dequeue:</td> Removing an element from the front of the queue. </tr><tr><td>Peek:</td> Retrieve the element at the front of the queue without removing it. </tr><tr><td>Size:</td> Determining the number of elements in the queue. </tr><tr><td>Empty Check:</td> Checking if the queue is empty. </tr></ol> <p> <strong>Advantages:</strong> </p> <ol class="points"> <tr><td>FIFO Behavior:</td> Elements are processed in the order of their insertion, ensuring the preservation of the original sequence. </tr><tr><td>Efficient Insertion and Removal:</td> Adding and removing elements from a queue is fast and has a constant time complexity of O(1). </tr><tr><td>Synchronization:</td> Java provides synchronized queue implementations, making them safe for concurrent programming. </tr><tr><td>Standardized Interface:</td> The Queue interface in Java offers a common set of methods, allowing easy interchangeability between different queue implementations. </tr></ol> <p> <strong>Disadvantages:</strong> </p> <ol class="points"> <tr><td>No Random Access:</td> Queues do not support direct Access to elements in the middle. Accessing specific positions requires dequeuing preceding elements. </tr><tr><td>Limited Size:</td> Some queue implementations have a fixed size or capacity, leading to overflow or exceptions when exceeding the maximum size. </tr><tr><td>Inefficient Search:</td> Searching for an element in a queue requires dequeuing until a match is found, resulting in a linear search with potentially high time complexity. </tr></ol> <p> <strong>Implementation:</strong> </p> <p> <strong>FileName:</strong> QueueExample.java</p> <pre> import java.util.Stack; import java.util.LinkedList; import java.util.Queue; public class QueueExample { public static void main(String[] args) { // Create a Queue to store integers Queue queue=new LinkedList(); // Enqueue elements to the Queue queue.offer(10); queue.offer(20); queue.offer(30); queue.offer(40); queue.offer(50); //Access and print the front element of the Queue System.out.println(&apos;Front element:&apos;+queue.peek()); // Dequeue elements from the Queue and print them while (!queue.isEmpty()) { int element=queue.poll(); System.out.println(&apos;Dequeued element:&apos;+element); } } } </pre> <p> <strong>Output:</strong> </p> <pre> Front element:10 Dequeued element:10 Dequeued element:20 Dequeued element:30 Dequeued element:40 Dequeued element:50 </pre> <h3>6) HashMap:</h3> <p>A HashMap is a data structure in Java that provides a way to store and retrieve key-value pairs. It is part of the Java Collections Framework and is implemented based on the hash table data structure.</p> <p> <strong>Functions:</strong> </p> <ul> <tr><td>put(key, value):</td> Inserts the specified key-value pair into the HashMap. </tr><tr><td>get(key):</td> Retrieves the value associated with the specified key. </tr><tr><td>containsKey(key):</td> Checks if the HashMap contains the specified key. </tr><tr><td>containsValue(value):</td> Checks if the HashMap contains the specified value. </tr><tr><td>remove(key):</td> Removes the key-value pair associated with the specified key from the HashMap. </tr><tr><td>size():</td> Returns the number of key-value pairs in the HashMap. </tr><tr><td>isEmpty():</td> Checks if the HashMap is empty. </tr><tr><td>keySet():</td> Returns a Set containing all the keys in the HashMap. </tr><tr><td>values():</td> Returns a Collection containing all the values in the HashMap. </tr><tr><td>clear():</td> Removes all the key-value pairs from the HashMap. </tr></ul> <p> <strong>Advantages:</strong> </p> <ol class="points"> <tr><td>Efficient Retrieval:</td> HashMap provides fast retrieval of values based on keys with constant-time complexity O(1). </tr><tr><td>Flexible Key-Value Pairing:</td> HashMap allows any non-null object as a key, enabling custom-defined keys for storing and retrieving data. </tr><tr><td>Dynamic Size:</td> HashMap can dynamically grow or shrink in size to handle varying amounts of data. </tr><tr><td>Compatibility with Java Collections Framework:</td> HashMap implements the Map interface, allowing seamless integration with other Collection classes. </tr></ol> <p> <strong>Disadvantages:</strong> </p> <ol class="points"> <tr><td>Lack of Ordering:</td> HashMap does not preserve the order of elements. Use LinkedHashMap or TreeMap for specific ordering requirements. </tr><tr><td>Increased Memory Overhead:</td> HashMap requires additional memory for hash codes and internal structure compared to simpler data structures. </tr><tr><td>Slower Iteration:</td> Iterating over a HashMap can be slower compared to arrays or lists due to traversing the underlying hash table. </tr></ol> <p> <strong>Implementation:</strong> </p> <p> <strong>FileName:</strong> HashMapExample.java</p> <pre> import java.util.HashMap; public class HashMapExample { public static void main(String[] args) { // Create a HashMap to store String keys and Integer values HashMap hashMap=new HashMap(); // Add key-value pairs to the HashMap hashMap.put(&apos;John&apos;,25); hashMap.put(&apos;Alice&apos;,30); hashMap.put(&apos;Bob&apos;,35); //Access and print values based on keys System.out.println(&apos;Age of John:&apos;+hashMap.get(&apos;John&apos;)); System.out.println(&apos;Age of Alice:&apos;+hashMap.get(&apos;Alice&apos;)); // Check if a key exists in the HashMap System.out.println(&apos;Is Bob present?&apos;+hashMap.containsKey(&apos;Bob&apos;)); // Update the value associated with a key hashMap.put(&apos;Alice&apos;,32); // Remove a key-value pair from the HashMap hashMap.remove(&apos;John&apos;); // Print all key-value pairs in the HashMap System.out.println(&apos;Key-Value pairs in the HashMap:&apos;); for (String key : hashMap.keySet()) { System.out.println(key+&apos;:&apos;+hashMap.get(key)); } // Check the size of the HashMap System.out.println(&apos;Size of the HashMap:&apos;+hashMap.size()); } } </pre> <p> <strong>Output:</strong> </p> <pre> Age of John:25 Age of Alice:30 Is Bob present?true Key-Value pairs in the HashMap: Bob:35 Alice:32 Size of the HashMap:2 </pre> <h3>7) HashSet:</h3> <p>HashSet is a data structure in Java that implements the Set interface and stores elements in a hash table.</p> <p> <strong>Features:</strong> </p> <ol class="points"> <tr><td>Stores unique elements:</td> HashSet does not allow duplicate elements. Each element in the HashSet is unique. </tr><tr><td>Uses hash-based lookup:</td> HashSet uses the hash value of each element to determine its storage location, providing efficient element retrieval. </tr><tr><td>Unordered collection:</td> The elements in a HashSet are not stored in a specific order. The order of elements may change over time. </tr></ol> <p> <strong>Advantages:</strong> </p> <ol class="points"> <tr><td>Fast element lookup:</td> HashSet provides fast lookup operations, making it efficient to check if an element exists in the set. </tr><tr><td>No duplicate elements:</td> HashSet automatically handles duplicate elements and ensures that each element is unique. </tr><tr><td>Integration with Java Collections Framework:</td> HashSet implements the Set interface, making it compatible with other collection classes in the Java Collections Framework. </tr></ol> <p> <strong>Disadvantages:</strong> </p> <ol class="points"> <tr><td>No guaranteed order:</td> HashSet does not maintain the order of elements. If the order of elements is important, HashSet is not suitable. </tr><tr><td>No indexing:</td> HashSet does not provide direct indexing or positional Access to elements. To access elements, you need to iterate over the set. </tr><tr><td>Higher memory overhead:</td> HashSet requires additional memory to store hash values and maintain the hash table structure, resulting in higher memory usage compared to some other data structures. </tr></ol> <p> <strong>Implementation:</strong> </p> <p> <strong>FileName:</strong> HashSetExample.java</p> <pre> import java.util.HashSet; public class HashSetExample { public static void main(String[] args) { // Create a HashSet HashSet set=new HashSet(); // Add elements to the HashSet set.add(&apos;Apple&apos;); set.add(&apos;Banana&apos;); set.add(&apos;Orange&apos;); set.add(&apos;Grapes&apos;); set.add(&apos;Mango&apos;); // Print the HashSet System.out.println(&apos;HashSet:&apos;+set); // Check if an element exists System.out.println(&apos;Contains &apos;Apple&apos;:&apos;+set.contains(&apos;Apple&apos;)); // Remove an element set.remove(&apos;Banana&apos;); // Print the updated HashSet System.out.println(&apos;Updated HashSet:&apos;+set); // Get the size of the HashSet System.out.println(&apos;Size of HashSet:&apos;+set.size()); // Clear the HashSet set.clear(); // Check if the HashSet is empty System.out.println(&apos;Is HashSet empty?&apos;+set.isEmpty()); } } </pre> <p> <strong>Output:</strong> </p> <pre> HashSet:[Apple, Grapes, Mango, Orange, Banana] Contains &apos;Apple&apos;:true Updated HashSet:[Apple, Grapes, Mango, Orange] Size of HashSet:4 Is HashSet empty?true </pre> <h3>8) TreeSet:</h3> <p>TreeSet is an implementation of the SortedSet interface in Java that uses a self-balancing binary search tree called a red-black tree to store elements in sorted order.</p> <p> <strong>Advantages:</strong> </p> <ol class="points"> <tr><td>Sorted Order:</td> TreeSet automatically maintains the elements in a sorted order based on their natural ordering or a custom comparator. It allows for efficient searching and retrieval of elements in ascending or descending order. </tr><tr><td>No Duplicate Elements:</td> TreeSet does not allow duplicate elements. It ensures that each element in the set is unique, which can be useful in scenarios where duplicate values should be avoided. </tr><tr><td>Efficient Operations:</td> TreeSet provides efficient operations like insertion, deletion, and searching. These operations have a time complexity of O(log n), where n is the number of elements in the set. </tr><tr><td>Navigable Set Operations:</td> TreeSet provides additional navigational methods, such as higher(), lower(), ceiling(), and floor(), which allow you to find elements that are greater than, less than, or equal to a given value. </tr></ol> <p> <strong>Disadvantages:</strong> </p> <ol class="points"> <tr><td>Overhead:</td> TreeSet requires additional memory to store the internal data structure, which can lead to higher memory overhead compared to other set implementations. </tr><tr><td>Slower Insertion and Removal:</td> Insertion and removal operations in TreeSet involve maintaining the sorted order of elements, which may require tree restructuring. It can make these operations slightly slower compared to HashSet or LinkedHashSet. </tr><tr><td>Limited Customization:</td> TreeSet is primarily designed for natural ordering or a single custom comparator. It may need more flexibility for multiple sorting criteria or complex sorting logic. </tr></ol> <p> <strong>Functions:</strong> </p> <ul> <tr><td>add(element):</td> Adds an element to the TreeSet while maintaining the sorted order. </tr><tr><td>remove(element):</td> Removes the specified element from the TreeSet. </tr><tr><td>contains(element):</td> Checks if the TreeSet contains the specified element. </tr><tr><td>size():</td> Returns the number of elements in the TreeSet. </tr><tr><td>first():</td> Returns the first (lowest) element in the TreeSet. </tr><tr><td>last():</td> Returns the last (highest) element in the TreeSet. </tr><tr><td>higher(element):</td> Returns the least element in the TreeSet that is strictly greater than the given element. </tr><tr><td>lower(element):</td> Returns the greatest element in the TreeSet that is strictly less than the given element. </tr></ul> <p> <strong>Implementation:</strong> </p> <p> <strong>FileName:</strong> TreeSetExample.java</p> <pre> import java.util.TreeSet; public class TreeSetExample { public static void main(String[] args) { // Create a TreeSet TreeSet numbers=new TreeSet(); // Add elements to the TreeSet numbers.add(5); numbers.add(2); numbers.add(8); numbers.add(1); numbers.add(4); // Print the TreeSet System.out.println(&apos;Elements in the TreeSet:&apos;+numbers); // Check if an element exists System.out.println(&apos;Does TreeSet contain 4?&apos;+numbers.contains(4)); // Remove an element numbers.remove(2); // Print the TreeSet after removal System.out.println(&apos;Elements in the TreeSet after removal:&apos;+numbers); // Get the size of the TreeSet System.out.println(&apos;Size of the TreeSet:&apos;+numbers.size()); // Get the first and last element System.out.println(&apos;First element:&apos;+numbers.first()); System.out.println(&apos;Last element:&apos;+numbers.last()); // Iterate over the TreeSet System.out.println(&apos;Iterating over the TreeSet:&apos;); for (int number:numbers) { System.out.println(number); } } } </pre> <p> <strong>Output:</strong> </p> <pre> Elements in the TreeSet:[1, 2, 4, 5, 8] Does TreeSet contain 4? true Elements in the TreeSet after removal:[1, 4, 5, 8] Size of the TreeSet:4First element:1 Last element:8 Iterating over the TreeSet: 1 4 5 8 </pre> <h3>9) TreeMap:</h3> <p>TreeMap is a class in Java that implements the Map interface and provides a sorted key-value mapping based on the natural order of the keys or a custom comparator.</p> <p> <strong>Advantages:</strong> </p> <ol class="points"> <tr><td>Sorted Ordering:</td> TreeMap maintains the keys in sorted order, which allows for efficient searching, retrieval, and range-based operations. </tr><tr><td>Key-Value Mapping:</td> TreeMap stores key-value pairs, enabling efficient lookup and retrieval of values based on the associated keys. </tr><tr><td>Red-Black Tree Implementation:</td> TreeMap uses a balanced binary search tree (Red-Black Tree) internally, ensuring efficient performance even for large datasets. </tr><tr><td>Support for Custom Comparators:</td> TreeMap allows the use of custom comparators to define the sorting order of the keys, providing flexibility in sorting criteria. </tr></ol> <p> <strong>Disadvantages:</strong> </p> <ol class="points"> <tr><td>Memory Overhead:</td> TreeMap requires additional memory to store the internal tree structure and associated objects, resulting in higher memory usage compared to simpler data structures like HashMap. </tr><tr><td>Slower Insertion and Deletion:</td> Insertion and deletion operations in TreeMap have a time complexity of O(log n) due to the need for tree restructuring, making them slower compared to HashMap or LinkedHashMap. </tr><tr><td>Limited Performance for Unsorted Data:</td> TreeMap performs efficiently for sorted data, but its performance can degrade when dealing with unsorted data or frequent modifications, as it requires maintaining the sorted order. </tr></ol> <p> <strong>Functions:</strong> </p> <ul> <tr><td>put(key, value):</td> Inserts a key-value pair into the TreeMap. </tr><tr><td>get(key):</td> Retrieves the value associated with the specified key. </tr><tr><td>containsKey(key):</td> Checks if the TreeMap contains a specific key. </tr><tr><td>remove(key):</td> Removes the key-value pair associated with the specified key. </tr><tr><td>size():</td> Returns the number of key-value pairs in the TreeMap. </tr><tr><td>keySet():</td> Returns a set of all keys in the TreeMap. </tr><tr><td>values():</td> Returns a collection of all values in the TreeMap. </tr><tr><td>entrySet():</td> Returns a set of key-value pairs in the TreeMap. </tr></ul> <p> <strong>Implementation:</strong> </p> <p> <strong>FileName:</strong> TreeMapExample.java</p> <pre> import java.util.TreeMap; public class TreeMapExample { public static void main(String[] args) { // Create a TreeMap TreeMap scores=new TreeMap(); // Insert key-value pairs into the TreeMap scores.put(&apos;Alice&apos;,90); scores.put(&apos;Bob&apos;,80); scores.put(&apos;Charlie&apos;,95); scores.put(&apos;David&apos;,87); scores.put(&apos;Eve&apos;,92); //Access and print values from the TreeMap System.out.println(&apos;Score of Alice:&apos;+scores.get(&apos;Alice&apos;)); System.out.println(&apos;Score of Charlie:&apos;+scores.get(&apos;Charlie&apos;)); System.out.println(&apos;Score of David:&apos;+scores.get(&apos;David&apos;)); // Update a value in the TreeMap scores.put(&apos;Bob&apos;,85); // Remove a key-value pair from the TreeMap scores.remove(&apos;Eve&apos;); // Iterate through the TreeMap using a for-each loop System.out.println(&apos;Scores in the TreeMap:&apos;); for (String name:scores.keySet()) { int score=scores.get(name); System.out.println(name+&apos;:&apos;+score); } } } </pre> <p> <strong>Output:</strong> </p> <pre> Score of Alice:90 Score of Charlie:95 Score of David:87 Scores in the TreeMap: Alice:90 Bob:85 Charlie:95 David:87 </pre> <h3>10) Graph:</h3> <p>Graphs are data structure that represents a collection of interconnected nodes or vertices. They are composed of vertices and edges, where vertices represent entities and edges represent the relationships between those entities.</p> <p> <strong>Advantages:</strong> </p> <ol class="points"> <tr><td>Versatility:</td> Graphs can represent a wide range of real-world scenarios, making them suitable for various applications such as social networks, transportation systems, and computer networks. </tr><tr><td>Relationship Representation:</td> Graphs provide a natural way to represent relationships and connections between entities, allowing for efficient analysis and traversal of these relationships. </tr><tr><td>Efficient Search and Traversal:</td> Graph algorithms like breadth-first search (BFS) and depth-first search (DFS) enable efficient traversal and searching of the graph&apos;s vertices and edges. </tr><tr><td>Modeling Complex Relationships:</td> Graphs can model complex relationships, including hierarchical structures, cyclic dependencies, and multiple connections between entities. </tr></ol> <p> <strong>Disadvantages:</strong> </p> <ol class="points"> <tr><td>Space Complexity:</td> Graphs can consume a significant amount of memory, especially large-scale graphs with many vertices and edges. </tr><tr><td>The complexity of Operations:</td> Certain graph operations, such as finding the shortest path or detecting cycles, can have high time complexity, particularly in dense graphs. </tr><tr><td>Difficulty in Maintenance:</td> Modifying or updating a graph can be complex, as changes in the graph&apos;s structure may impact its connectivity and existing algorithms. </tr></ol> <p> <strong>Implementation:</strong> </p> <p> <strong>FileName:</strong> GraphExample.java</p> <pre> import java.util.*; public class GraphExample { private int V; // Number of vertices private List<list> adjacencyList; // Adjacency list representation public GraphExample(int V) { this.V=V; adjacencyList=new ArrayList(V); // Initialize the adjacency list for (int i=0;i<v;i++) { adjacencylist.add(new arraylist()); } function to add an edge between two vertices public void addedge(int source,int destination) adjacencylist.get(source).add(destination); adjacencylist.get(destination).add(source); perform breadth-first search traversal of the graph bfs(int startvertex) boolean[] visited="new" boolean[v]; queue linkedlist(); visited[startvertex]="true;" queue.add(startvertex); while (!queue.isempty()) int currentvertex="queue.poll();" system.out.print(currentvertex+' '); list neighbors="adjacencyList.get(currentVertex);" for (int neighbor:neighbors) if (!visited[neighbor]) visited[neighbor]="true;" queue.add(neighbor); system.out.println(); depth-first dfs(int dfsutil(startvertex,visited); private dfsutil(int vertex,boolean[] visited) visited[vertex]="true;" system.out.print(vertex+' dfsutil(neighbor,visited); static main(string[] args) v="5;" number graphexample graphexample(v); edges graph.addedge(0,1); graph.addedge(0,2); graph.addedge(1,3); graph.addedge(2,3); graph.addedge(2,4); system.out.print('bfs traversal: graph.bfs(0); system.out.print('dfs graph.dfs(0); < pre> <p> <strong>Output:</strong> </p> <pre> BFS traversal: 0 1 2 3 4 DFS traversal: 0 1 3 2 4 </pre> <h3>11) Tree:</h3> <p>A tree is a widely used data structure in computer science that represents a hierarchical structure. It consists of nodes connected by edges, where each node can have zero or more child nodes.</p> <p> <strong>Advantages:</strong> </p> <ol class="points"> <tr><td>Hierarchical Structure:</td> Trees provide a natural way to represent hierarchical relationships, such as file systems, organization charts, or HTML/XML documents. </tr><tr><td>Efficient Search:</td> Binary search trees enable efficient searching with a time complexity of O(log n), making them suitable for storing and retrieving sorted data. </tr><tr><td>Fast Insertion and Deletion:</td> Tree data structures offer efficient insertion and deletion operations, especially when balanced, such as AVL trees or Red-Black trees. </tr><tr><td>Ordered Iteration:</td> In-order traversal of a binary search tree gives elements in a sorted order, which is helpful for tasks like printing elements in sorted order or finding the next/previous element. </tr></ol> <p> <strong>Disadvantages:</strong> </p> <ol class="points"> <tr><td>High Memory Overhead:</td> Trees require additional memory to store node references or pointers, which can result in higher memory usage compared to linear data structures like arrays or lists. </tr><tr><td>Complex Implementation:</td> Implementing and maintaining a tree data structure can be more complex compared to other data structures like arrays or lists, especially for balanced tree variants. </tr><tr><td>Limited Operations:</td> Some tree variants, like binary search trees, do not support efficient operations like finding the kth smallest element or finding the rank of an element. </tr></ol> <p> <strong>Functions:</strong> </p> <ol class="points"> <tr><td>Insertion:</td> Add a new node to the tree. </tr><tr><td>Deletion:</td> Remove a node from the tree. </tr><tr><td>Search:</td> Find a specific node or element in the tree. </tr><tr><td>Traversal:</td> Traverse the tree in different orders, such as in-order, pre-order, or post-order. </tr><tr><td>Height/Depth:</td> Calculate the height or depth of the tree. </tr><tr><td>Balance:</td> Ensure the tree remains balanced to maintain efficient operations. </tr></ol> <p> <strong>Implementation:</strong> </p> <p> <strong>FileName:</strong> TreeExample.java</p> <pre> import java.util.*; class TreeNode { int value; TreeNode left; TreeNode right; public TreeNode(int value) { this.value = value; left = null; right = null; } } public class TreeExample { public static void main(String[] args) { // Create a binary search tree TreeNode root = new TreeNode(50); root.left = new TreeNode(30); root.right = new TreeNode(70); root.left.left = new TreeNode(20); root.left.right = new TreeNode(40); root.right.left = new TreeNode(60); root.right.right = new TreeNode(80); // Perform common operations System.out.println(&apos;In-order Traversal:&apos;); inOrderTraversal(root); System.out.println(&apos;
Search for value 40: &apos;+search(root, 40)); System.out.println(&apos;Search for value 90: &apos;+search(root, 90)); int minValue = findMinValue(root); System.out.println(&apos;Minimum value in the tree: &apos;+minValue); int maxValue = findMaxValue(root); System.out.println(&apos;Maximum value in the tree: &apos;+maxValue); } // In-order traversal: left subtree, root, right subtree public static void inOrderTraversal(TreeNode node) { if (node != null) { inOrderTraversal(node.left); System.out.print(node.value + &apos; &apos;); inOrderTraversal(node.right); } } // Search for a value in the tree public static boolean search(TreeNode node, int value) { if (node == null) return false; if (node.value == value) return true; if (value <node.value) return search(node.left, value); else search(node.right, } find the minimum value in tree public static int findminvalue(treenode node) { if (node.left="=" null) node.value; findminvalue(node.left); maximum findmaxvalue(treenode (node.right="=" findmaxvalue(node.right); < pre> <p> <strong>Output:</strong> </p> <pre> In-order Traversal:20 30 40 50 60 70 80 Search for value 40: true Search for value 90: false Minimum value in the tree: 20 Maximum value in the tree: 80 </pre> <hr></node.value)></pre></v;i++)></list></pre></numbers.length;i++)>

2) Liste de tableaux :

ArrayList en Java est une structure de données dynamique qui permet le stockage et la manipulation d'éléments. Il fait partie du Java Collections Framework et est implémenté à l’aide d’un tableau en interne.

Avantages :

    Taille dynamique :Contrairement aux tableaux, les ArrayLists peuvent augmenter ou diminuer dynamiquement en taille à mesure que des éléments sont ajoutés ou supprimés. Il élimine le besoin de redimensionnement manuel et permet de gérer facilement différentes quantités de données.Manipulation facile des éléments :Les ArrayLists proposent des méthodes pour ajouter, supprimer et modifier des éléments à n’importe quelle position dans la liste. Sa flexibilité simplifie les opérations courantes telles que l'insertion, la suppression et la mise à jour, rendant la manipulation des éléments plus efficace.Accès aléatoire:Les ArrayLists prennent en charge l'accès aléatoire aux éléments à l'aide de leur index, permettant une récupération et une modification rapides des éléments à des positions spécifiques dans la liste. Il facilite un accès efficace aux éléments et améliore les performances globales.Compatibilité avec Java Collection Framework :ArrayLists implémente l'interface List, ce qui les rend compatibles avec d'autres classes Collection dans Java Collections Framework. Sa compatibilité permet une intégration transparente avec divers algorithmes et opérations fournis par le framework.

Désavantages:

    Surcharge de mémoire plus élevée :Les ArrayLists nécessitent de la mémoire supplémentaire pour conserver leur structure interne, ce qui entraîne une surcharge de mémoire plus élevée que les tableaux. Cela peut être un problème lorsqu’il s’agit de grandes collections d’éléments.Insertion et suppression plus lentes :L'insertion ou la suppression d'éléments au milieu d'une ArrayList nécessite le déplacement d'éléments, ce qui peut prendre du temps pour les grandes listes. Dans les scénarios où des opérations d'insertion ou de suppression fréquentes sont attendues, d'autres structures de données comme LinkedList peuvent offrir de meilleures performances.Performances limitées pour la recherche :La recherche d'un élément dans une ArrayList non triée nécessite une itération sur les éléments jusqu'à ce qu'une correspondance soit trouvée. Il s'agit d'une approche de recherche linéaire qui entraîne des performances de recherche plus lentes par rapport aux structures de données optimisées pour la recherche, telles que HashSet ou TreeMap.Pas de prise en charge des types primitifs :Les ArrayLists ne peuvent stocker que des objets et ne prennent pas directement en charge les types de données primitifs comme int ou char. Pour stocker les types primitifs, des classes wrapper telles que Integer ou Character doivent être utilisées, ce qui entraîne une surcharge potentielle de mise en boîte automatique et de déballage.

Les fonctions:

changer le nom du répertoire Linux
    Création d'une ArrayList :Déclarez et initialisez un ArrayList à l’aide de la classe ArrayList et spécifiez le type d’élément entre crochets angulaires.Ajout d'éléments :Utilisez la méthode add pour ajouter des éléments à la fin de ArrayList.Accéder aux éléments :Utilisez la technique get pour récupérer le prix du détail à un index sélectionné.Modification d'éléments :Mettez à jour le coût du détail à un index spécifique pour l’utilisation de l’approche définie.Taille de recherche :Utilisez la méthode des dimensions pour obtenir la quantité la plus récente de facteurs dans ArrayList.Suppression d'éléments :Utilisez l'approche Remove pour supprimer un détail à un index spécifique ou en fournissant la référence de l'objet.Itération dans ArrayList :Utilisez des boucles pour parcourir chaque élément de ArrayList et effectuer des opérations sur eux.

Mise en œuvre:

Nom de fichier: ArrayListExample.java

 import java.util.*; public class ArrayListExample { public static void main(String[] args) { // Create an ArrayList to store integers ArrayList numbers=new ArrayList(List.of(10,20,30,40,50)); //Access and print elements from the ArrayList System.out.println(&apos;Element at index 0:&apos;+numbers.get(0)); System.out.println(&apos;Element at index 2:&apos;+numbers.get(2)); System.out.println(&apos;Element at index 4:&apos;+numbers.get(4)); // Calculate and print the sum of all elements in the ArrayList int sum=numbers.stream().mapToInt(Integer::intValue).sum(); System.out.println(&apos;Sum of ArrayList elements:&apos;+sum); // Update an element in the ArrayList numbers.set(2,35); System.out.println(&apos;Updated element at index 2:&apos;+numbers.get(2)); // Iterate through the ArrayList using a for-each loop and print the elements System.out.println(&apos;Elements in the ArrayList:&apos;); for (int number:numbers) { System.out.println(number); } } } 

Sortir:

 Element at index 0:10 Element at index 2:30 Element at index 4:50 Sum of ArrayList elements:150 Updated element at index 2:35 Elements in the ArrayList: 10 20 35 40 50 

3) Liste chaînée :

Une liste chaînée est une structure de données linéaire dans laquelle les éléments sont stockés dans des objets distincts appelés nœuds. Un lien de référence vers le nœud suivant dans la séquence est inclus dans l'élément de données de chaque nœud. Le nœud final de la liste est lié à null, indiquant que la liste est terminée.

Contrairement aux tableaux, les listes chaînées ne nécessitent pas d’allocation de mémoire contiguë. Chaque nœud d'une liste chaînée peut être alloué indépendamment, permettant une allocation dynamique de la mémoire et des opérations d'insertion et de suppression efficaces.

Avantages :

    Taille dynamique :LinkedList peut croître ou diminuer de manière dynamique, ce qui la rend adaptée à des tailles de données variables ou inconnues.Insertion et suppression efficaces :L'insertion ou la suppression d'éléments dans une LinkedList est efficace, car elle ne nécessite pas de déplacement d'éléments.Aucune exigence de mémoire contiguë :LinkedList n'a pas besoin d'allocation de mémoire contiguë, ce qui la rend flexible et adaptée aux situations de mémoire imprévisibles.Modification facile :LinkedList permet une modification facile des éléments en changeant les pointeurs de référence, permettant une manipulation efficace.

Désavantages:

    Accès aléatoire plus lent :LinkedList a un accès aléatoire plus lent car il nécessite de parcourir la liste pour accéder aux éléments par index.Augmentation de la surcharge de mémoire :LinkedList nécessite de la mémoire supplémentaire pour les références et les nœuds, ce qui augmente la surcharge de mémoire par rapport aux tableaux.Recherche inefficace :LinkedList a des opérations de recherche plus lentes, nécessitant une itération séquentielle pour trouver des éléments spécifiques.

Les fonctions:

    Création d'une LinkedList :Déclarez et initialisez une LinkedList à l'aide de la classe LinkedList.Ajout d'éléments :Utilisez la méthode add pour ajouter des éléments à la fin de LinkedList.Accéder aux éléments :Utilisez la méthode get pour récupérer la valeur d'un élément à un index spécifique.Modification d'éléments :Mettez à jour la valeur d'un élément à un index particulier à l'aide de la méthode set.Suppression d'éléments :Utilisez la méthode Remove pour supprimer un élément à un index spécifique ou en fournissant la référence de l'objet.

Mise en œuvre:

Nom de fichier: LinkedList1.java

 import java.util.*; public class LinkedList1 { public static void main(String[] args) { // Create a LinkedList to store integers LinkedList linkedList1 = new LinkedList(); // Add elements to the LinkedList linkedList1.add(10); linkedList1.add(20); linkedList1.add(30); linkedList1.add(40); linkedList1.add(50); // Print the LinkedList System.out.println(&apos;LinkedList:&apos;+linkedList1); // Remove an element from the LinkedList linkedList1.removeFirst(); System.out.println(&apos;LinkedList after removing first element:&apos;+linkedList1); // Check if an element exists in the LinkedList boolean containsElement=linkedList1.contains(30); System.out.println(&apos;LinkedList contains element 30?&apos;+containsElement); // Get the first and last elements of the LinkedList int firstElement=linkedList1.getFirst(); int lastElement=linkedList1.getLast(); System.out.println(&apos;First element:&apos;+firstElement); System.out.println(&apos;Last element:&apos;+lastElement); // Clear the LinkedList linkedList1.clear(); System.out.println(&apos;LinkedList after clearing:&apos;+linkedList1); } } 

Sortir:

 LinkedList:[10, 20, 30, 40, 50] LinkedList after removing first element:[20, 30, 40, 50] LinkedList contains element 30?true First element:20 Last element:50 LinkedList after clearing:[] 

4) Pile :

Le principe Last-In-First-Out (LIFO) veut que l’élément qui a été inséré le plus récemment soit également celui qui est supprimé en premier. Une pile est une structure de données linéaire qui suit cette règle. Il utilise les commandes « push » et « pop » pour ajouter des éléments à la pile et, par conséquent, supprimer l'élément supérieur de la pile. La technique du « peek » permet en outre d'accéder à l'élément supérieur sans le retirer.

Caractéristiques d'une pile :

    Comportement LIFO :Le dernier élément poussé sur la pile est le premier à être retiré, ce qui le rend adapté aux applications où l'ordre d'insertion et de retrait est important.Accès limité:Les piles fournissent généralement un accès restreint aux éléments. Vous ne pouvez accéder qu'à l'élément le plus haut et pour atteindre d'autres éléments, vous devez faire apparaître les éléments situés au-dessus d'eux.Taille dynamique :Les piles peuvent être implémentées à l'aide de tableaux ou de listes chaînées, permettant une taille dynamique. Ils peuvent s'agrandir ou se réduire selon les besoins pendant l'exécution.

Avantages :

    Simplicité:Les piles sont faciles à comprendre et à mettre en œuvre.Efficacité:Les opérations d'insertion et de suppression ont une complexité temporelle de O(1).Gestion des appels de fonctions :Les piles gèrent efficacement les appels de fonctions et le stockage des variables.Fonctionnalité Annuler/Rétablir :Les piles permettent d'annuler et de rétablir les opérations dans les applications.

Désavantages:

    Accès limité:L'accès aux éléments est limité au sommet de la pile.Restrictions de taille :Les piles peuvent avoir des limites de taille en fonction de l'implémentation.Ne convient pas à tous les scénarios :Les piles sont spécifiques au comportement LIFO et peuvent ne pas être appropriées dans d'autres cas.

Mise en œuvre:

Nom de fichier: StackExample.java

 import java.util.Stack; public class StackExample { public static void main(String[] args) { // Create a stack Stack stack=new Stack(); // Push elements onto the stack stack.push(10); stack.push(20); stack.push(30); // Print the top element of the stack System.out.println(&apos;Top element:&apos;+stack.peek()); // Pop elements from the stack int poppedElement=stack.pop(); System.out.println(&apos;Popped element:&apos;+poppedElement); // Check if the stack is empty System.out.println(&apos;Is stack empty?&apos;+stack.isEmpty()); // Get the size of the stack System.out.println(&apos;Stack size:&apos;+stack.size()); // Iterate over the stack System.out.println(&apos;Stack elements:&apos;); for (Integer element:stack) { System.out.println(element); } } } 

Sortir:

 Top element:30 Popped element:30 Is stack empty?false Stack size:2 Stack elements: 10 20 

5) File d'attente :

Une file d'attente est une structure de données linéaire en Java qui suit le principe First-In-First-Out (FIFO). Il représente un ensemble d'éléments où des éléments sont insérés à l'arrière et retirés de l'avant.

base de données

Caractéristiques:

    Mettre en file d'attente :Ajout d'un élément à l'arrière de la file d'attente.Dequeue:Suppression d'un élément du début de la file d'attente.Coup d'oeil :Récupérez l’élément en début de file d’attente sans le supprimer.Taille:Détermination du nombre d'éléments dans la file d'attente.Chèque vide :Vérifier si la file d'attente est vide.

Avantages :

    Comportement FIFO :Les éléments sont traités dans l'ordre de leur insertion, garantissant la préservation de la séquence originale.Insertion et retrait efficaces :L'ajout et la suppression d'éléments d'une file d'attente sont rapides et ont une complexité temporelle constante de O(1).Synchronisation:Java fournit des implémentations de files d'attente synchronisées, ce qui les rend sûres pour la programmation simultanée.Interface standardisée :L'interface Queue en Java offre un ensemble commun de méthodes, permettant une interchangeabilité facile entre les différentes implémentations de files d'attente.

Désavantages:

    Pas d'accès aléatoire :Les files d'attente ne prennent pas en charge l'accès direct aux éléments du milieu. L’accès à des positions spécifiques nécessite de retirer les éléments précédents de la file d’attente.Taille limitée :Certaines implémentations de files d'attente ont une taille ou une capacité fixe, ce qui entraîne un débordement ou des exceptions en cas de dépassement de la taille maximale.Recherche inefficace :La recherche d'un élément dans une file d'attente nécessite de le retirer de la file d'attente jusqu'à ce qu'une correspondance soit trouvée, ce qui entraîne une recherche linéaire avec une complexité temporelle potentiellement élevée.

Mise en œuvre:

Nom de fichier: QueueExample.java

 import java.util.Stack; import java.util.LinkedList; import java.util.Queue; public class QueueExample { public static void main(String[] args) { // Create a Queue to store integers Queue queue=new LinkedList(); // Enqueue elements to the Queue queue.offer(10); queue.offer(20); queue.offer(30); queue.offer(40); queue.offer(50); //Access and print the front element of the Queue System.out.println(&apos;Front element:&apos;+queue.peek()); // Dequeue elements from the Queue and print them while (!queue.isEmpty()) { int element=queue.poll(); System.out.println(&apos;Dequeued element:&apos;+element); } } } 

Sortir:

 Front element:10 Dequeued element:10 Dequeued element:20 Dequeued element:30 Dequeued element:40 Dequeued element:50 

6) Carte de hachage :

Un HashMap est une structure de données en Java qui permet de stocker et de récupérer des paires clé-valeur. Il fait partie du Java Collections Framework et est implémenté sur la base de la structure de données de la table de hachage.

Les fonctions:

    put(clé, valeur):Insère la paire clé-valeur spécifiée dans le HashMap.Obtenir la clé):Récupère la valeur associée à la clé spécifiée.contientClé(clé):Vérifie si le HashMap contient la clé spécifiée.contientValeur(valeur) :Vérifie si le HashMap contient la valeur spécifiée.supprimer (clé):Supprime la paire clé-valeur associée à la clé spécifiée du HashMap.taille():Renvoie le nombre de paires clé-valeur dans le HashMap.est vide():Vérifie si le HashMap est vide.jeu de clés() :Renvoie un Set contenant toutes les clés du HashMap.valeurs():Renvoie une collection contenant toutes les valeurs du HashMap.clair():Supprime toutes les paires clé-valeur du HashMap.

Avantages :

    Récupération efficace :HashMap permet une récupération rapide des valeurs basées sur des clés de complexité en temps constant O(1).Appariement clé-valeur flexible :HashMap autorise n'importe quel objet non nul comme clé, permettant ainsi des clés personnalisées pour stocker et récupérer des données.Taille dynamique :HashMap peut augmenter ou diminuer dynamiquement sa taille pour gérer différentes quantités de données.Compatibilité avec Java Collections Framework :HashMap implémente l'interface Map, permettant une intégration transparente avec d'autres classes Collection.

Désavantages:

    Manque de commande :HashMap ne préserve pas l'ordre des éléments. Utilisez LinkedHashMap ou TreeMap pour des exigences de commande spécifiques.Augmentation de la surcharge de mémoire :HashMap nécessite de la mémoire supplémentaire pour les codes de hachage et la structure interne par rapport aux structures de données plus simples.Itération plus lente :L'itération sur un HashMap peut être plus lente que celle des tableaux ou des listes en raison du parcours de la table de hachage sous-jacente.

Mise en œuvre:

Nom de fichier: HashMapExample.java

 import java.util.HashMap; public class HashMapExample { public static void main(String[] args) { // Create a HashMap to store String keys and Integer values HashMap hashMap=new HashMap(); // Add key-value pairs to the HashMap hashMap.put(&apos;John&apos;,25); hashMap.put(&apos;Alice&apos;,30); hashMap.put(&apos;Bob&apos;,35); //Access and print values based on keys System.out.println(&apos;Age of John:&apos;+hashMap.get(&apos;John&apos;)); System.out.println(&apos;Age of Alice:&apos;+hashMap.get(&apos;Alice&apos;)); // Check if a key exists in the HashMap System.out.println(&apos;Is Bob present?&apos;+hashMap.containsKey(&apos;Bob&apos;)); // Update the value associated with a key hashMap.put(&apos;Alice&apos;,32); // Remove a key-value pair from the HashMap hashMap.remove(&apos;John&apos;); // Print all key-value pairs in the HashMap System.out.println(&apos;Key-Value pairs in the HashMap:&apos;); for (String key : hashMap.keySet()) { System.out.println(key+&apos;:&apos;+hashMap.get(key)); } // Check the size of the HashMap System.out.println(&apos;Size of the HashMap:&apos;+hashMap.size()); } } 

Sortir:

 Age of John:25 Age of Alice:30 Is Bob present?true Key-Value pairs in the HashMap: Bob:35 Alice:32 Size of the HashMap:2 

7) Jeu de hachage :

HashSet est une structure de données en Java qui implémente l'interface Set et stocke les éléments dans une table de hachage.

Caractéristiques:

    Stocke des éléments uniques :HashSet n'autorise pas les éléments en double. Chaque élément du HashSet est unique.Utilise la recherche basée sur le hachage :HashSet utilise la valeur de hachage de chaque élément pour déterminer son emplacement de stockage, offrant ainsi une récupération efficace des éléments.Collecte non ordonnée :Les éléments d'un HashSet ne sont pas stockés dans un ordre spécifique. L'ordre des éléments peut changer avec le temps.

Avantages :

    Recherche rapide d'éléments :HashSet fournit des opérations de recherche rapides, ce qui permet de vérifier efficacement si un élément existe dans l'ensemble.Aucun élément en double :HashSet gère automatiquement les éléments en double et garantit que chaque élément est unique.Intégration avec Java Collections Framework :HashSet implémente l'interface Set, la rendant compatible avec d'autres classes de collection dans Java Collections Framework.

Désavantages:

nat contre lit
    Aucune commande garantie :HashSet ne conserve pas l'ordre des éléments. Si l’ordre des éléments est important, HashSet ne convient pas.Pas d'indexation :HashSet ne fournit pas d'indexation directe ni d'accès positionnel aux éléments. Pour accéder aux éléments, vous devez parcourir l’ensemble.Surcharge de mémoire plus élevée :HashSet nécessite de la mémoire supplémentaire pour stocker les valeurs de hachage et maintenir la structure de la table de hachage, ce qui entraîne une utilisation de la mémoire plus élevée par rapport à certaines autres structures de données.

Mise en œuvre:

Nom de fichier: HashSetExample.java

 import java.util.HashSet; public class HashSetExample { public static void main(String[] args) { // Create a HashSet HashSet set=new HashSet(); // Add elements to the HashSet set.add(&apos;Apple&apos;); set.add(&apos;Banana&apos;); set.add(&apos;Orange&apos;); set.add(&apos;Grapes&apos;); set.add(&apos;Mango&apos;); // Print the HashSet System.out.println(&apos;HashSet:&apos;+set); // Check if an element exists System.out.println(&apos;Contains &apos;Apple&apos;:&apos;+set.contains(&apos;Apple&apos;)); // Remove an element set.remove(&apos;Banana&apos;); // Print the updated HashSet System.out.println(&apos;Updated HashSet:&apos;+set); // Get the size of the HashSet System.out.println(&apos;Size of HashSet:&apos;+set.size()); // Clear the HashSet set.clear(); // Check if the HashSet is empty System.out.println(&apos;Is HashSet empty?&apos;+set.isEmpty()); } } 

Sortir:

 HashSet:[Apple, Grapes, Mango, Orange, Banana] Contains &apos;Apple&apos;:true Updated HashSet:[Apple, Grapes, Mango, Orange] Size of HashSet:4 Is HashSet empty?true 

8) Ensemble d'arbres :

TreeSet est une implémentation de l'interface SortedSet en Java qui utilise un arbre de recherche binaire auto-équilibré appelé arbre rouge-noir pour stocker les éléments dans un ordre trié.

Avantages :

    Ordre trié :TreeSet maintient automatiquement les éléments dans un ordre trié en fonction de leur ordre naturel ou d'un comparateur personnalisé. Il permet une recherche et une récupération efficaces des éléments par ordre croissant ou décroissant.Aucun élément en double :TreeSet n'autorise pas les éléments en double. Cela garantit que chaque élément de l'ensemble est unique, ce qui peut être utile dans les scénarios où les valeurs en double doivent être évitées.Opérations efficaces :TreeSet fournit des opérations efficaces telles que l'insertion, la suppression et la recherche. Ces opérations ont une complexité temporelle de O(log n), où n est le nombre d'éléments dans l'ensemble.Opérations sur les ensembles navigables :TreeSet fournit des méthodes de navigation supplémentaires, telles que upper(), lower(), plafond() et floor(), qui vous permettent de rechercher des éléments supérieurs, inférieurs ou égaux à une valeur donnée.

Désavantages:

    Aérien:TreeSet nécessite de la mémoire supplémentaire pour stocker la structure de données interne, ce qui peut entraîner une surcharge de mémoire plus élevée par rapport à d'autres implémentations d'ensembles.Insertion et retrait plus lents :Les opérations d'insertion et de suppression dans TreeSet impliquent le maintien de l'ordre de tri des éléments, ce qui peut nécessiter une restructuration de l'arborescence. Cela peut rendre ces opérations légèrement plus lentes par rapport à HashSet ou LinkedHashSet.Personnalisation limitée :TreeSet est principalement conçu pour un classement naturel ou un seul comparateur personnalisé. Il peut nécessiter plus de flexibilité pour plusieurs critères de tri ou une logique de tri complexe.

Les fonctions:

    ajouter(élément):Ajoute un élément au TreeSet tout en conservant l'ordre de tri.supprimer (élément):Supprime l'élément spécifié du TreeSet.contient (élément):Vérifie si le TreeSet contient l'élément spécifié.taille():Renvoie le nombre d'éléments dans le TreeSet.d'abord():Renvoie le premier élément (le plus bas) du TreeSet.dernier():Renvoie le dernier élément (le plus élevé) du TreeSet.supérieur(élément):Renvoie le plus petit élément du TreeSet qui est strictement supérieur à l'élément donné.inférieur (élément):Renvoie le plus grand élément du TreeSet qui est strictement inférieur à l'élément donné.

Mise en œuvre:

Nom de fichier: TreeSetExample.java

 import java.util.TreeSet; public class TreeSetExample { public static void main(String[] args) { // Create a TreeSet TreeSet numbers=new TreeSet(); // Add elements to the TreeSet numbers.add(5); numbers.add(2); numbers.add(8); numbers.add(1); numbers.add(4); // Print the TreeSet System.out.println(&apos;Elements in the TreeSet:&apos;+numbers); // Check if an element exists System.out.println(&apos;Does TreeSet contain 4?&apos;+numbers.contains(4)); // Remove an element numbers.remove(2); // Print the TreeSet after removal System.out.println(&apos;Elements in the TreeSet after removal:&apos;+numbers); // Get the size of the TreeSet System.out.println(&apos;Size of the TreeSet:&apos;+numbers.size()); // Get the first and last element System.out.println(&apos;First element:&apos;+numbers.first()); System.out.println(&apos;Last element:&apos;+numbers.last()); // Iterate over the TreeSet System.out.println(&apos;Iterating over the TreeSet:&apos;); for (int number:numbers) { System.out.println(number); } } } 

Sortir:

questions d'entretien de base sur Java
 Elements in the TreeSet:[1, 2, 4, 5, 8] Does TreeSet contain 4? true Elements in the TreeSet after removal:[1, 4, 5, 8] Size of the TreeSet:4First element:1 Last element:8 Iterating over the TreeSet: 1 4 5 8 

9) ArbreMap :

TreeMap est une classe en Java qui implémente l'interface Map et fournit un mappage clé-valeur trié basé sur l'ordre naturel des clés ou un comparateur personnalisé.

Avantages :

    Ordre trié :TreeMap conserve les clés dans un ordre trié, ce qui permet des opérations efficaces de recherche, de récupération et basées sur des plages.Cartographie clé-valeur :TreeMap stocke les paires clé-valeur, permettant une recherche et une récupération efficaces des valeurs en fonction des clés associées.Implémentation de l'arbre rouge-noir :TreeMap utilise un arbre de recherche binaire équilibré (arbre rouge-noir) en interne, garantissant des performances efficaces même pour les grands ensembles de données.Prise en charge des comparateurs personnalisés :TreeMap permet l'utilisation de comparateurs personnalisés pour définir l'ordre de tri des clés, offrant ainsi une flexibilité dans les critères de tri.

Désavantages:

    Surcharge de mémoire :TreeMap nécessite de la mémoire supplémentaire pour stocker la structure arborescente interne et les objets associés, ce qui entraîne une utilisation de la mémoire plus élevée par rapport aux structures de données plus simples comme HashMap.Insertion et suppression plus lentes :Les opérations d'insertion et de suppression dans TreeMap ont une complexité temporelle de O(log n) en raison de la nécessité de restructurer l'arborescence, ce qui les rend plus lentes par rapport à HashMap ou LinkedHashMap.Performances limitées pour les données non triées :TreeMap fonctionne efficacement pour les données triées, mais ses performances peuvent se dégrader lorsqu'il s'agit de données non triées ou de modifications fréquentes, car cela nécessite de maintenir l'ordre de tri.

Les fonctions:

    put(clé, valeur):Insère une paire clé-valeur dans le TreeMap.Obtenir la clé):Récupère la valeur associée à la clé spécifiée.contientClé(clé):Vérifie si le TreeMap contient une clé spécifique.supprimer (clé):Supprime la paire clé-valeur associée à la clé spécifiée.taille():Renvoie le nombre de paires clé-valeur dans le TreeMap.jeu de clés() :Renvoie un ensemble de toutes les clés du TreeMap.valeurs():Renvoie une collection de toutes les valeurs du TreeMap.jeu d'entrées() :Renvoie un ensemble de paires clé-valeur dans TreeMap.

Mise en œuvre:

Nom de fichier: TreeMapExample.java

 import java.util.TreeMap; public class TreeMapExample { public static void main(String[] args) { // Create a TreeMap TreeMap scores=new TreeMap(); // Insert key-value pairs into the TreeMap scores.put(&apos;Alice&apos;,90); scores.put(&apos;Bob&apos;,80); scores.put(&apos;Charlie&apos;,95); scores.put(&apos;David&apos;,87); scores.put(&apos;Eve&apos;,92); //Access and print values from the TreeMap System.out.println(&apos;Score of Alice:&apos;+scores.get(&apos;Alice&apos;)); System.out.println(&apos;Score of Charlie:&apos;+scores.get(&apos;Charlie&apos;)); System.out.println(&apos;Score of David:&apos;+scores.get(&apos;David&apos;)); // Update a value in the TreeMap scores.put(&apos;Bob&apos;,85); // Remove a key-value pair from the TreeMap scores.remove(&apos;Eve&apos;); // Iterate through the TreeMap using a for-each loop System.out.println(&apos;Scores in the TreeMap:&apos;); for (String name:scores.keySet()) { int score=scores.get(name); System.out.println(name+&apos;:&apos;+score); } } } 

Sortir:

 Score of Alice:90 Score of Charlie:95 Score of David:87 Scores in the TreeMap: Alice:90 Bob:85 Charlie:95 David:87 

10) Graphique :

Les graphiques sont une structure de données qui représente une collection de nœuds ou de sommets interconnectés. Ils sont composés de sommets et d'arêtes, où les sommets représentent des entités et les arêtes représentent les relations entre ces entités.

Avantages :

    Polyvalence:Les graphiques peuvent représenter un large éventail de scénarios du monde réel, ce qui les rend adaptés à diverses applications telles que les réseaux sociaux, les systèmes de transport et les réseaux informatiques.Représentation relationnelle :Les graphiques constituent un moyen naturel de représenter les relations et les connexions entre les entités, permettant une analyse et un parcours efficaces de ces relations.Recherche et traversée efficaces :Les algorithmes graphiques tels que la recherche en largeur d'abord (BFS) et la recherche en profondeur d'abord (DFS) permettent une traversée et une recherche efficaces des sommets et des arêtes du graphique.Modélisation de relations complexes :Les graphiques peuvent modéliser des relations complexes, notamment des structures hiérarchiques, des dépendances cycliques et de multiples connexions entre entités.

Désavantages:

    Complexité spatiale :Les graphiques peuvent consommer une quantité importante de mémoire, en particulier les graphiques à grande échelle comportant de nombreux sommets et arêtes.La complexité des opérations :Certaines opérations sur les graphes, telles que la recherche du chemin le plus court ou la détection de cycles, peuvent avoir une complexité temporelle élevée, en particulier dans les graphes denses.Difficulté d'entretien :La modification ou la mise à jour d'un graphique peut être complexe, car les changements dans la structure du graphique peuvent avoir un impact sur sa connectivité et les algorithmes existants.

Mise en œuvre:

Nom de fichier: GraphExample.java

 import java.util.*; public class GraphExample { private int V; // Number of vertices private List<list> adjacencyList; // Adjacency list representation public GraphExample(int V) { this.V=V; adjacencyList=new ArrayList(V); // Initialize the adjacency list for (int i=0;i<v;i++) { adjacencylist.add(new arraylist()); } function to add an edge between two vertices public void addedge(int source,int destination) adjacencylist.get(source).add(destination); adjacencylist.get(destination).add(source); perform breadth-first search traversal of the graph bfs(int startvertex) boolean[] visited="new" boolean[v]; queue linkedlist(); visited[startvertex]="true;" queue.add(startvertex); while (!queue.isempty()) int currentvertex="queue.poll();" system.out.print(currentvertex+\' \'); list neighbors="adjacencyList.get(currentVertex);" for (int neighbor:neighbors) if (!visited[neighbor]) visited[neighbor]="true;" queue.add(neighbor); system.out.println(); depth-first dfs(int dfsutil(startvertex,visited); private dfsutil(int vertex,boolean[] visited) visited[vertex]="true;" system.out.print(vertex+\' dfsutil(neighbor,visited); static main(string[] args) v="5;" number graphexample graphexample(v); edges graph.addedge(0,1); graph.addedge(0,2); graph.addedge(1,3); graph.addedge(2,3); graph.addedge(2,4); system.out.print(\'bfs traversal: graph.bfs(0); system.out.print(\'dfs graph.dfs(0); < pre> <p> <strong>Output:</strong> </p> <pre> BFS traversal: 0 1 2 3 4 DFS traversal: 0 1 3 2 4 </pre> <h3>11) Tree:</h3> <p>A tree is a widely used data structure in computer science that represents a hierarchical structure. It consists of nodes connected by edges, where each node can have zero or more child nodes.</p> <p> <strong>Advantages:</strong> </p> <ol class="points"> <tr><td>Hierarchical Structure:</td> Trees provide a natural way to represent hierarchical relationships, such as file systems, organization charts, or HTML/XML documents. </tr><tr><td>Efficient Search:</td> Binary search trees enable efficient searching with a time complexity of O(log n), making them suitable for storing and retrieving sorted data. </tr><tr><td>Fast Insertion and Deletion:</td> Tree data structures offer efficient insertion and deletion operations, especially when balanced, such as AVL trees or Red-Black trees. </tr><tr><td>Ordered Iteration:</td> In-order traversal of a binary search tree gives elements in a sorted order, which is helpful for tasks like printing elements in sorted order or finding the next/previous element. </tr></ol> <p> <strong>Disadvantages:</strong> </p> <ol class="points"> <tr><td>High Memory Overhead:</td> Trees require additional memory to store node references or pointers, which can result in higher memory usage compared to linear data structures like arrays or lists. </tr><tr><td>Complex Implementation:</td> Implementing and maintaining a tree data structure can be more complex compared to other data structures like arrays or lists, especially for balanced tree variants. </tr><tr><td>Limited Operations:</td> Some tree variants, like binary search trees, do not support efficient operations like finding the kth smallest element or finding the rank of an element. </tr></ol> <p> <strong>Functions:</strong> </p> <ol class="points"> <tr><td>Insertion:</td> Add a new node to the tree. </tr><tr><td>Deletion:</td> Remove a node from the tree. </tr><tr><td>Search:</td> Find a specific node or element in the tree. </tr><tr><td>Traversal:</td> Traverse the tree in different orders, such as in-order, pre-order, or post-order. </tr><tr><td>Height/Depth:</td> Calculate the height or depth of the tree. </tr><tr><td>Balance:</td> Ensure the tree remains balanced to maintain efficient operations. </tr></ol> <p> <strong>Implementation:</strong> </p> <p> <strong>FileName:</strong> TreeExample.java</p> <pre> import java.util.*; class TreeNode { int value; TreeNode left; TreeNode right; public TreeNode(int value) { this.value = value; left = null; right = null; } } public class TreeExample { public static void main(String[] args) { // Create a binary search tree TreeNode root = new TreeNode(50); root.left = new TreeNode(30); root.right = new TreeNode(70); root.left.left = new TreeNode(20); root.left.right = new TreeNode(40); root.right.left = new TreeNode(60); root.right.right = new TreeNode(80); // Perform common operations System.out.println(&apos;In-order Traversal:&apos;); inOrderTraversal(root); System.out.println(&apos;
Search for value 40: &apos;+search(root, 40)); System.out.println(&apos;Search for value 90: &apos;+search(root, 90)); int minValue = findMinValue(root); System.out.println(&apos;Minimum value in the tree: &apos;+minValue); int maxValue = findMaxValue(root); System.out.println(&apos;Maximum value in the tree: &apos;+maxValue); } // In-order traversal: left subtree, root, right subtree public static void inOrderTraversal(TreeNode node) { if (node != null) { inOrderTraversal(node.left); System.out.print(node.value + &apos; &apos;); inOrderTraversal(node.right); } } // Search for a value in the tree public static boolean search(TreeNode node, int value) { if (node == null) return false; if (node.value == value) return true; if (value <node.value) return search(node.left, value); else search(node.right, } find the minimum value in tree public static int findminvalue(treenode node) { if (node.left="=" null) node.value; findminvalue(node.left); maximum findmaxvalue(treenode (node.right="=" findmaxvalue(node.right); < pre> <p> <strong>Output:</strong> </p> <pre> In-order Traversal:20 30 40 50 60 70 80 Search for value 40: true Search for value 90: false Minimum value in the tree: 20 Maximum value in the tree: 80 </pre> <hr></node.value)></pre></v;i++)></list>

11) Arbre :

Un arbre est une structure de données largement utilisée en informatique qui représente une structure hiérarchique. Il se compose de nœuds connectés par des arêtes, où chaque nœud peut avoir zéro ou plusieurs nœuds enfants.

Avantages :

    Structure hiérarchique:Les arborescences constituent un moyen naturel de représenter les relations hiérarchiques, telles que les systèmes de fichiers, les organigrammes ou les documents HTML/XML.Recherche efficace :Les arbres de recherche binaires permettent une recherche efficace avec une complexité temporelle de O (log n), ce qui les rend adaptés au stockage et à la récupération de données triées.Insertion et suppression rapides :Les structures de données arborescentes offrent des opérations d'insertion et de suppression efficaces, en particulier lorsqu'elles sont équilibrées, comme les arbres AVL ou les arbres Rouge-Noir.Itération ordonnée :Le parcours dans l'ordre d'un arbre de recherche binaire donne les éléments dans un ordre trié, ce qui est utile pour des tâches telles que l'impression des éléments dans l'ordre trié ou la recherche de l'élément suivant/précédent.

Désavantages:

    Surcharge de mémoire élevée :Les arbres nécessitent de la mémoire supplémentaire pour stocker les références de nœuds ou les pointeurs, ce qui peut entraîner une utilisation plus élevée de la mémoire par rapport aux structures de données linéaires telles que des tableaux ou des listes.Mise en œuvre complexe :La mise en œuvre et la maintenance d'une structure de données arborescente peuvent être plus complexes que d'autres structures de données telles que des tableaux ou des listes, en particulier pour les variantes d'arbre équilibré.Opérations limitées :Certaines variantes d'arbres, comme les arbres de recherche binaires, ne prennent pas en charge des opérations efficaces telles que la recherche du kième plus petit élément ou la recherche du rang d'un élément.

Les fonctions:

    Insertion:Ajoutez un nouveau nœud à l'arborescence.Effacement:Supprimez un nœud de l'arborescence.Recherche:Recherchez un nœud ou un élément spécifique dans l'arborescence.Traversée :Parcourez l'arborescence dans différents ordres, par exemple en commande, en précommande ou en post-commande.Hauteur/Profondeur :Calculez la hauteur ou la profondeur de l'arbre.Équilibre:Assurez-vous que l’arbre reste équilibré pour maintenir des opérations efficaces.

Mise en œuvre:

Nom de fichier: TreeExample.java

 import java.util.*; class TreeNode { int value; TreeNode left; TreeNode right; public TreeNode(int value) { this.value = value; left = null; right = null; } } public class TreeExample { public static void main(String[] args) { // Create a binary search tree TreeNode root = new TreeNode(50); root.left = new TreeNode(30); root.right = new TreeNode(70); root.left.left = new TreeNode(20); root.left.right = new TreeNode(40); root.right.left = new TreeNode(60); root.right.right = new TreeNode(80); // Perform common operations System.out.println(&apos;In-order Traversal:&apos;); inOrderTraversal(root); System.out.println(&apos;
Search for value 40: &apos;+search(root, 40)); System.out.println(&apos;Search for value 90: &apos;+search(root, 90)); int minValue = findMinValue(root); System.out.println(&apos;Minimum value in the tree: &apos;+minValue); int maxValue = findMaxValue(root); System.out.println(&apos;Maximum value in the tree: &apos;+maxValue); } // In-order traversal: left subtree, root, right subtree public static void inOrderTraversal(TreeNode node) { if (node != null) { inOrderTraversal(node.left); System.out.print(node.value + &apos; &apos;); inOrderTraversal(node.right); } } // Search for a value in the tree public static boolean search(TreeNode node, int value) { if (node == null) return false; if (node.value == value) return true; if (value <node.value) return search(node.left, value); else search(node.right, } find the minimum value in tree public static int findminvalue(treenode node) { if (node.left="=" null) node.value; findminvalue(node.left); maximum findmaxvalue(treenode (node.right="=" findmaxvalue(node.right); < pre> <p> <strong>Output:</strong> </p> <pre> In-order Traversal:20 30 40 50 60 70 80 Search for value 40: true Search for value 90: false Minimum value in the tree: 20 Maximum value in the tree: 80 </pre> <hr></node.value)>