logo

Datastrukturer i Java

De mange måder, hvorpå data kan arrangeres, gemmes og håndteres i et computerprogram, omtales som datastrukturer i Java. Disse strukturer tilbyder en metodisk metode til at håndtere og administrere data effektivt, hvilket muliggør nyttige operationer som indsættelse, sletning, hentning og gennemkøring.

Artiklen vil udforske alt relateret til datastrukturerne i Java, og den hjælper begyndere med at forstå nemt og effektivt.

  • Hvad er Java?
  • Hvad er datastrukturer i Java?
  • Typer af datastrukturer i Java
  • Fordele ved datastrukturer i Java
  • Klassificering af datastrukturer
  • Ofte stillede spørgsmål om datastrukturer i Java

Hvad er Java?

Java er et populært objektorienteret programmeringssprog, der er kendt for sit store standardbibliotek og platformsfrihed. Det tilbyder en solid arkitektur til at skabe programmer, der kører uden genkompilering på tværs af forskellige platforme. Det velkendte bibliotek for Java har et udvalg af registreringssystemer, der gør det muligt at håndtere adskillige datatyper effektivt.

Hvad er datastrukturer i Java?

Den måde, hvorpå data organiseres og lagres i et computerprograms hukommelse, afhænger i høj grad af Java-registreringsstrukturer. Det velkendte Java-bibliotek indeholder en betydelig type indbyggede statistikstrukturer. Nogle få af de registreringssystemer, der tillader programmører korte og enkle måder at gemme og arrangere data på, omfatter forbundne lister, stakke, køer og arrays. Udviklere kan hurtigt udføre operationer som indsættelse, sletning, søgning og sortering, fordi de giver en række mekanismer til at få adgang til, ændre og administrere data. Java-programmører kan reducere hukommelsesforbruget og øge den samlede effektivitet af deres programmer betydeligt ved at bruge disse datastrukturer.

Typer af datastrukturer i Java

Listen over datastrukturer i Java er anført nedenfor

  1. Arrays
  2. ArrayList
  3. LinkedList
  4. Stak
  5. HashMap
  6. HashSet
  7. Træsæt
  8. Trækort
  9. Kurve
  10. Træ

Nedenstående diagram forklarer tydeligt typerne af datastrukturer i Java meget klart.

Datastrukturer i Java

Yderligere klassificering af typer af datastrukturer:

Der er to typer datastrukturer: -

  1. Primitive datastrukturer
  2. Ikke-primitive datastrukturer

1) Primitive datastrukturer: Også kendt som primitive datatyper, disse er grundlæggende indbyggede datatyper i Java. De omfatter:

    Byte:Gemmer hele tal fra -128 til 127.kort:Gemmer hele tal fra -32.768 til 32.767.int:Gemmer hele tal fra -2.147.483.648 til 2.147.483.647.flyde:Gemmer flydende kommatal med enkelt præcision.char:Gemmer individuelle tegn.boolsk:Gemmer sande eller falske værdier.lang:Gemmer store hele tal.Dobbelt:Gemmer tal med flydende faktor med dobbelt præcision.

2) Ikke-primitive datastrukturer: Ikke-primitive optegnelsesstrukturer er mere komplekse og er sammensat af primitive informationstyper. De kan desuden kategoriseres i to typer:

    Lineære datastrukturer:I lineære datastrukturer er elementerne arrangeret lineært eller sekventielt. Eksempler omfatter:
      Arrays:En gruppe af identisk type elementer placeret i et array ifølge et forudbestemt arrangement.Stabler:En Last-In-First-Out (LIFO) struktur, hvor kun de øverste elementer kan tilføjes eller fjernes.Haler:First-In-First-Out (FIFO) strukturer bruges i køer, hvor varer indsættes på den returnerede og tages ud på forsiden.Linket liste:En relateret liste omfatter en samling af gadgets, der omtales som noder, som hver har en reference til noden efter sig og statistik inde i den.
    Ikke-lineære datastrukturer:I ikke-lineære datastrukturer er elementerne arrangeret på en ikke-sekventiel måde. Eksempler omfatter:
      Træer:Træer er en type knudebaseret hierarkisk struktur med en rodknude øverst og underordnede knudepunkter, der forgrener sig ud af den. Eksempler inkluderer rød-sorte træer, AVL-træer, binære søgetræer og binære træer.Grafer:Et sæt knudepunkter forbundet ved hjælp af kanter, hvor knudepunkter kan have en hvilken som helst mængde forbindelser. Grafer bruges til at symbolisere komplekse forhold mellem elementer.Hobe:En specialiseret træ-baseret struktur, hvor hver bestemt node har en værdi, der er større eller mindre end dens børn, afhængig af, om det er en max heap eller en min heap.Hash:Datastrukturer, der bruger en hash-funktion til at knytte nøgler til værdier. Eksempler består af hashsæt og hashmaps, som giver grøn genfinding og lagring af statistik baseret på præcise nøgler.
Datastrukturer i Java

Fordele ved datastrukturer i Java

    Effektiv dataorganisation:Datastrukturer giver organiserede måder at gemme og administrere data på, hvilket giver mulighed for effektiv adgang, manipulation og hentning. De optimerer hukommelsesforbruget og letter hurtigere udførelse af algoritmer.Bedre ydeevne:Udviklere kan forbedre ydeevnen med hensyn til hastighed og hukommelsesudnyttelse ved at vælge den passende datastruktur til en bestemt aktivitet. Ydeevnen er optimeret, fordi specifikke datastrukturer er lavet til at udmærke sig ved bestemte handlinger som søgning, sortering eller indsættelse af information.Kode genanvendelighed:Java tilbyder en bred vifte af indbyggede datastrukturer, der er enkle for programmører at bruge. Disse genanvendelige datastrukturer sparer tid og kræfter ved at fjerne behovet for at skabe sofistikerede algoritmer fra bunden.Kode enkelhed:Datastrukturer gør implementeringen af ​​komplicerede processer nemmere at kode. De tilbyder abstraktioner på højt niveau og indkapsler detaljerne i datahåndtering, hvilket forbedrer kodens læsbarhed, vedligeholdelsesvenlighed og klarhed.Fleksibilitet og tilpasningsevne:Datastrukturer giver fleksibilitet til at håndtere forskellige typer og størrelser af data. De kan justeres dynamisk for at imødekomme skiftende datakrav og give mekanismer til effektiv datamanipulation.Standardiseret og velafprøvet:Standardbiblioteket til Java indeholder indbyggede datastrukturer, der har gennemgået betydelige tests og optimering, hvilket garanterer deres pålidelighed og ydeevne. Brug af disse fælles datastrukturer mindsker risikoen for fejl og giver applikationsudvikling et solidt fundament.Skalerbarhed:Datastrukturer giver muligheder for skalerbarhed, hvilket gør det muligt for applikationer at håndtere store mængder data effektivt. De kan dynamisk vokse eller krympe baseret på datastørrelsen, hvilket sikrer optimal ydeevne selv med stigende datakrav.Algoritme design:Datastrukturer er afgørende i algoritmedesign og analyse. De giver den underliggende struktur og operationer, der er nødvendige for at implementere forskellige algoritmer og løse komplekse problemer.

1) Arrays:

Et array er en grundlæggende og ofte brugt datastruktur i sammenhæng med Javas datastrukturer. Det tilbyder en metode til at opbevare en samling af identiske komponenter i fast størrelse. Fordi de giver hurtig og nem adgang til elementer afhængigt af deres indeks, er arrays et afgørende værktøj til at administrere og organisere data.

Fordele:

    Dataorganisation:Arrays giver en struktureret måde at gemme og organisere elementer på, hvilket forbedrer datastyring.Tilfældig adgang:Elementer kan tilgås direkte ved hjælp af deres indeks, hvilket giver mulighed for effektiv hentning og modifikation.Fast størrelse:Arrays har en forudbestemt størrelse, hvilket muliggør effektiv hukommelsesallokering.Homogene elementer:Arrays gemmer elementer af samme type, hvilket sikrer datakonsistens og forenkler operationer.Gentagelse:Arrays understøtter nem iteration gennem elementer, hvilket letter gennemkøring og behandling.Sortering og søgning:Arrays fungerer godt sammen med sorterings- og søgealgoritmer og tilbyder effektiv drift.Hukommelseseffektivitet:Arrays optimerer hukommelsesbrug ved at gemme elementer i sammenhængende områder.Kompatibilitet:Arrays er bredt understøttet i Java, hvilket gør dem kompatible med forskellige rammer og værktøjer.

Ulemper:

    Fast størrelse:Arrays kan ikke ændres dynamisk, hvilket kræver genskabelse for størrelsesændringer.Hukommelsesspild:Ubrugte elementer i større arrays kan føre til hukommelsesspild.Overhead til indsættelse og sletning:Indsættelse eller sletning af elementer i midten af ​​et array kræver forskydning af efterfølgende elementer, hvilket resulterer i ineffektivitet.Mangel på fleksibilitet:Arrays har stive datatyper og kan ikke rumme forskellige datatyper uden yderligere arrays eller datastrukturer.

Funktioner:

    Oprettelse af et array:Deklarer og initialiser et array med en bestemt størrelse ved hjælp af array-typen og det nye nøgleord.Adgang til elementer:Brug indekset til at få adgang til individuelle elementer i arrayet.Ændring af elementer:Opdater værdien af ​​et element ved at tildele en ny værdi til et specifikt indeks i arrayet.Findelængde:Brug længdeattributten til at bestemme arrayets længde.Iteration gennem Array:Brug loops til at gå gennem hvert element i arrayet og udføre

Implementering:

Filnavn: 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) ArrayList:

ArrayList i Java er en dynamisk datastruktur, der giver mulighed for lagring og manipulation af elementer. Det er en del af Java Collections Framework og implementeres ved hjælp af et array internt.

Fordele:

    Dynamisk størrelse:I modsætning til arrays kan ArrayLists dynamisk vokse eller krympe i størrelse, efterhånden som elementer tilføjes eller fjernes. Det eliminerer behovet for manuel størrelsesændring og giver mulighed for bekvem håndtering af varierende mængder af data.Nem elementmanipulation:ArrayLists tilbyder metoder til at tilføje, fjerne og ændre elementer på enhver position på listen. Dens fleksibilitet forenkler almindelige operationer såsom indsættelse, sletning og opdatering, hvilket gør elementmanipulation mere effektiv.Tilfældig adgang:ArrayLists understøtter tilfældig adgang til elementer ved hjælp af deres indeks, hvilket muliggør hurtig hentning og ændring af elementer på bestemte positioner på listen. Det letter effektiv adgang til elementer og forbedrer den samlede ydeevne.Kompatibilitet med Java Collection Framework:ArrayLists implementerer List-grænsefladen, hvilket gør dem kompatible med andre samlingsklasser i Java Collections Framework. Dens kompatibilitet giver mulighed for problemfri integration med forskellige algoritmer og operationer leveret af rammen.

Ulemper:

    Højere hukommelsesomkostninger:ArrayLists kræver yderligere hukommelse for at bevare deres interne struktur, hvilket resulterer i højere hukommelsesomkostninger sammenlignet med arrays. Det kan være en bekymring, når man har at gøre med store samlinger af elementer.Langsommere indsættelse og sletning:Indsættelse eller sletning af elementer i midten af ​​en ArrayList kræver skiftende elementer, hvilket kan være tidskrævende for store lister. I scenarier, hvor hyppige indsættelses- eller sletningsoperationer forventes, kan andre datastrukturer som LinkedList give bedre ydeevne.Begrænset ydeevne til søgning:Søgning efter et element i en usorteret ArrayList kræver iteration over elementerne, indtil et match er fundet. Det er en lineær søgetilgang, der resulterer i langsommere søgeydeevne sammenlignet med datastrukturer, der er optimeret til søgning, såsom HashSet eller TreeMap.Ingen støtte for primitiv type:ArrayLists kan kun gemme objekter og understøtter ikke direkte primitive datatyper som int eller char. For at gemme primitive typer skal indpakningsklasser som Integer eller Character bruges, hvilket fører til potentiel autoboxing og unboxing overhead.

Funktioner:

hvordan man kaster streng til int i java
    Oprettelse af en ArrayList:Deklarer og initialiser en ArrayList ved hjælp af ArrayList-klassen og angiv elementtypen inden for vinkelparenteserne.Tilføjelse af elementer:Brug add-metoden til at tilføje elementer i slutningen af ​​ArrayList.Adgang til elementer:Brug get-teknikken til at hente prisen på detaljer ved et udvalgt indeks.Ændring af elementer:Opdater detaljeringsomkostningerne ved et specifikt indeks for brugen af ​​den indstillede tilgang.Find størrelse:Brug dimensionsmetoden til at få den banebrydende mængde af faktorer i ArrayList.Fjernelse af elementer:Brug fjernmetoden til at slette en detalje ved et specifikt indeks eller ved at angive objektreferencen.Iteration gennem ArrayList:Brug loops til at iterere over hvert element i ArrayList og udføre operationer på dem.

Implementering:

Filnavn: 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); } } } 

Produktion:

 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) Linket liste:

En sammenkædet liste er en lineær datastruktur, hvor elementer er gemt i separate objekter kaldet noder. Et referencelink til den følgende node i sekvensen er inkluderet i hver nodes dataelement. Listens sidste node linker til null, hvilket indikerer, at listen er afsluttet.

I modsætning til arrays kræver linkede lister ikke sammenhængende hukommelsesallokering. Hver node i en sammenkædet liste kan allokeres uafhængigt, hvilket giver mulighed for dynamisk hukommelsesallokering og effektive indsættelses- og sletningsoperationer.

Fordele:

    Dynamisk størrelse:LinkedList kan vokse eller krympe dynamisk, hvilket gør den velegnet til varierende eller ukendte datastørrelser.Effektiv indsættelse og sletning:Det er effektivt at indsætte eller slette elementer i en LinkedList, da det ikke kræver at skifte elementer.Ingen sammenhængende hukommelseskrav:LinkedList behøver ikke sammenhængende hukommelsesallokering, hvilket gør den fleksibel og velegnet til uforudsigelige hukommelsessituationer.Nem ændring:LinkedList tillader nem ændring af elementer ved at ændre referencepointere, hvilket muliggør effektiv manipulation.

Ulemper:

    Langsommere tilfældig adgang:LinkedList har langsommere tilfældig adgang, da det kræver at krydse listen for at få adgang til elementer efter indeks.Øget hukommelsesomkostninger:LinkedList kræver yderligere hukommelse til referencer og noder, hvilket øger hukommelsesomkostningerne sammenlignet med arrays.Ineffektiv søgning:LinkedList har langsommere søgeoperationer, der kræver sekventiel iteration for at finde specifikke elementer.

Funktioner:

    Oprettelse af en linket liste:Erklær og initialiser en LinkedList ved hjælp af LinkedList-klassen.Tilføjelse af elementer:Brug add-metoden til at tilføje elementer i slutningen af ​​LinkedList.Adgang til elementer:Brug get-metoden til at hente værdien af ​​et element ved et specifikt indeks.Ændring af elementer:Opdater værdien af ​​et element ved et bestemt indeks ved hjælp af sætmetoden.Fjernelse af elementer:Brug fjernmetoden til at slette et element i et bestemt indeks eller ved at angive objektreferencen.

Implementering:

Filnavn: 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); } } 

Produktion:

 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) Stak:

Last-In-First-Out (LIFO) princippet dikterer, at det element, der senest blev indsat, også er det element, der fjernes først. En stak er en lineær datastruktur, der følger denne regel. Den anvender kommandoerne 'push' og 'pop' til at tilføje elementer til stakken og følgelig fjerne det øverste element fra stakken. 'Kig'-teknikken giver desuden adgang til det øverste element uden at fjerne det.

Funktioner af en stak:

    LIFO adfærd:Det sidste element, der skubbes ind på stakken, er det første, der skal poppes ud, hvilket gør det velegnet til applikationer, hvor rækkefølgen af ​​indsættelse og fjernelse er vigtig.Begrænset adgang:Stabler giver typisk begrænset adgang til elementer. Du kan kun få adgang til det øverste element, og for at nå andre elementer skal du sætte elementerne over dem.Dynamisk størrelse:Stakke kan implementeres ved hjælp af arrays eller linkede lister, hvilket giver mulighed for en dynamisk størrelse. De kan vokse eller skrumpe efter behov under kørsel.

Fordele:

    Enkelhed:Stabler er nemme at forstå og implementere.Effektivitet:Indsættelses- og sletningsoperationer har en tidskompleksitet på O(1).Funktionsopkaldsstyring:Stabler administrerer effektivt funktionsopkald og variabel lagring.Fortryd/Gentag funktionalitet:Stabler muliggør fortryd- og fortryd-handlinger i applikationer.

Ulemper:

java null kontrol
    Begrænset adgang:Adgang til elementer er begrænset til toppen af ​​stakken.Størrelsesbegrænsninger:Stakke kan have størrelsesbegrænsninger afhængigt af implementeringen.Ikke egnet til alle scenarier:Stabler er specifikke for LIFO-adfærd og er muligvis ikke passende i andre tilfælde.

Implementering:

Filnavn: 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); } } } 

Produktion:

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

5) Kø:

En kø er en lineær datastruktur i Java, der følger First-In-First-Out (FIFO) princippet. Det repræsenterer en samling af elementer, hvor elementer er indsat bagpå og fjernet fra fronten.

Funktioner:

    Kø:Tilføjelse af et element bagerst i køen.Afkø:Fjernelse af et element fra forsiden af ​​køen.Kig:Hent elementet foran i køen uden at fjerne det.Størrelse:Bestemmelse af antallet af elementer i køen.Tom check:Tjek om køen er tom.

Fordele:

    FIFO-adfærd:Elementer behandles i rækkefølgen af ​​deres indsættelse, hvilket sikrer bevarelsen af ​​den originale sekvens.Effektiv isætning og fjernelse:Tilføjelse og fjernelse af elementer fra en kø er hurtig og har en konstant tidskompleksitet på O(1).Synkronisering:Java leverer synkroniserede køimplementeringer, hvilket gør dem sikre til samtidig programmering.Standardiseret grænseflade:Kø-grænsefladen i Java tilbyder et fælles sæt metoder, der muliggør nem udskiftning mellem forskellige køimplementeringer.

Ulemper:

    Ingen tilfældig adgang:Køer understøtter ikke direkte adgang til elementer i midten. Adgang til specifikke positioner kræver at de foregående elementer fjernes fra køen.Begrænset størrelse:Nogle køimplementeringer har en fast størrelse eller kapacitet, hvilket fører til overløb eller undtagelser, når den maksimale størrelse overskrides.Ineffektiv søgning:At søge efter et element i en kø kræver udskydelse af køen, indtil et match er fundet, hvilket resulterer i en lineær søgning med potentielt høj tidskompleksitet.

Implementering:

Filnavn: 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); } } } 

Produktion:

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

6) HashMap:

Et HashMap er en datastruktur i Java, der giver en måde at gemme og hente nøgleværdi-par. Det er en del af Java Collections Framework og er implementeret baseret på hash-tabellens datastruktur.

Funktioner:

    put(nøgle, værdi):Indsætter det angivne nøgle-værdi-par i HashMap.få (nøgle):Henter den værdi, der er knyttet til den angivne nøgle.indeholderNøgle(nøgle):Kontrollerer, om HashMap indeholder den angivne nøgle.indeholderVærdi(værdi):Kontrollerer, om HashMap indeholder den angivne værdi.fjern (nøgle):Fjerner det nøgleværdi-par, der er knyttet til den angivne nøgle, fra HashMap.størrelse():Returnerer antallet af nøgle-værdi-par i HashMap.er tom():Kontrollerer om HashMap er tomt.keySet():Returnerer et sæt, der indeholder alle nøglerne i HashMap.værdier():Returnerer en samling, der indeholder alle værdierne i HashMap.klar():Fjerner alle nøgleværdi-par fra HashMap.

Fordele:

    Effektiv hentning:HashMap giver hurtig hentning af værdier baseret på nøgler med konstant-tidskompleksitet O(1).Fleksibel nøgle-værdi-parring:HashMap tillader ethvert ikke-null objekt som en nøgle, hvilket muliggør brugerdefinerede nøgler til lagring og genfinding af data.Dynamisk størrelse:HashMap kan dynamisk vokse eller krympe i størrelse for at håndtere varierende mængder data.Kompatibilitet med Java Collections Framework:HashMap implementerer kortgrænsefladen, hvilket muliggør problemfri integration med andre samlingsklasser.

Ulemper:

    Manglende bestilling:HashMap bevarer ikke rækkefølgen af ​​elementer. Brug LinkedHashMap eller TreeMap til specifikke bestillingskrav.Øget hukommelsesomkostninger:HashMap kræver ekstra hukommelse til hashkoder og intern struktur sammenlignet med enklere datastrukturer.Langsommere iteration:Iteration over et HashMap kan være langsommere sammenlignet med arrays eller lister på grund af at krydse den underliggende hash-tabel.

Implementering:

Filnavn: 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()); } } 

Produktion:

 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) HashSet:

HashSet er en datastruktur i Java, der implementerer Set-grænsefladen og gemmer elementer i en hash-tabel.

Funktioner:

    Gemmer unikke elementer:HashSet tillader ikke duplikerede elementer. Hvert element i HashSet er unikt.Bruger hash-baseret opslag:HashSet bruger hash-værdien for hvert element til at bestemme dets lagerplacering, hvilket giver effektiv element-hentning.Uordnet samling:Elementerne i et HashSet er ikke gemt i en bestemt rækkefølge. Rækkefølgen af ​​elementer kan ændre sig over tid.

Fordele:

    Hurtigt elementopslag:HashSet giver hurtige opslagsoperationer, hvilket gør det effektivt at kontrollere, om der findes et element i sættet.Ingen duplikerede elementer:HashSet håndterer automatisk duplikerede elementer og sikrer, at hvert element er unikt.Integration med Java Collections Framework:HashSet implementerer Set-grænsefladen, hvilket gør den kompatibel med andre samlingsklasser i Java Collections Framework.

Ulemper:

diana mary blacker
    Ingen garanteret ordre:HashSet opretholder ikke rækkefølgen af ​​elementer. Hvis rækkefølgen af ​​elementer er vigtig, er HashSet ikke egnet.Ingen indeksering:HashSet giver ikke direkte indeksering eller positionel adgang til elementer. For at få adgang til elementer skal du iterere over sættet.Højere hukommelsesomkostninger:HashSet kræver yderligere hukommelse for at gemme hashværdier og opretholde hash-tabelstrukturen, hvilket resulterer i højere hukommelsesforbrug sammenlignet med nogle andre datastrukturer.

Implementering:

Filnavn: 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()); } } 

Produktion:

 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) Træsæt:

TreeSet er en implementering af SortedSet-grænsefladen i Java, der bruger et selvbalancerende binært søgetræ kaldet et rød-sort træ til at gemme elementer i sorteret rækkefølge.

Fordele:

    Sorteret rækkefølge:TreeSet vedligeholder automatisk elementerne i en sorteret rækkefølge baseret på deres naturlige rækkefølge eller en tilpasset komparator. Det giver mulighed for effektiv søgning og genfinding af elementer i stigende eller faldende rækkefølge.Ingen duplikerede elementer:TreeSet tillader ikke duplikerede elementer. Det sikrer, at hvert element i sættet er unikt, hvilket kan være nyttigt i scenarier, hvor duplikerede værdier bør undgås.Effektiv drift:TreeSet giver effektive operationer som indsættelse, sletning og søgning. Disse operationer har en tidskompleksitet på O(log n), hvor n er antallet af elementer i mængden.Navigerbare sætoperationer:TreeSet giver yderligere navigationsmetoder, såsom højere(), lower(), loft() og floor(), som giver dig mulighed for at finde elementer, der er større end, mindre end eller lig med en given værdi.

Ulemper:

    Overhead:TreeSet kræver yderligere hukommelse til at gemme den interne datastruktur, hvilket kan føre til højere hukommelsesomkostninger sammenlignet med andre sæt implementeringer.Langsommere indsættelse og fjernelse:Indsættelses- og fjernelsesoperationer i TreeSet involverer opretholdelse af den sorterede rækkefølge af elementer, hvilket kan kræve træomstrukturering. Det kan gøre disse operationer lidt langsommere sammenlignet med HashSet eller LinkedHashSet.Begrænset tilpasning:TreeSet er primært designet til naturlig bestilling eller en enkelt tilpasset komparator. Det kan have brug for mere fleksibilitet til flere sorteringskriterier eller kompleks sorteringslogik.

Funktioner:

    add(element):Tilføjer et element til træsættet, mens den sorterede rækkefølge bibeholdes.fjern(element):Fjerner det angivne element fra træsættet.indeholder(element):Kontrollerer, om træsættet indeholder det angivne element.størrelse():Returnerer antallet af elementer i træsættet.først():Returnerer det første (laveste) element i træsættet.sidst():Returnerer det sidste (højeste) element i træsættet.højere(element):Returnerer det mindste element i TreeSet, der er strengt taget større end det givne element.lavere(element):Returnerer det største element i TreeSet, der er strengt mindre end det givne element.

Implementering:

Filnavn: 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); } } } 

Produktion:

 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) Trækort:

TreeMap er en klasse i Java, der implementerer kortgrænsefladen og giver en sorteret nøgleværdi-mapping baseret på den naturlige rækkefølge af nøglerne eller en tilpasset komparator.

Fordele:

    Sorteret bestilling:TreeMap vedligeholder nøglerne i sorteret rækkefølge, hvilket giver mulighed for effektiv søgning, hentning og rækkevidde-baserede operationer.Kortlægning af nøgleværdier:TreeMap gemmer nøgle-værdi-par, hvilket muliggør effektiv opslag og genfinding af værdier baseret på de tilknyttede nøgler.Implementering af rød-sort træ:TreeMap bruger et afbalanceret binært søgetræ (Red-Black Tree) internt, hvilket sikrer effektiv ydeevne selv for store datasæt.Support til brugerdefinerede komparatorer:TreeMap tillader brugen af ​​brugerdefinerede komparatorer til at definere sorteringsrækkefølgen af ​​nøglerne, hvilket giver fleksibilitet i sorteringskriterier.

Ulemper:

    Hukommelse overhead:TreeMap kræver yderligere hukommelse til at gemme den interne træstruktur og tilknyttede objekter, hvilket resulterer i højere hukommelsesforbrug sammenlignet med enklere datastrukturer som HashMap.Langsommere indsættelse og sletning:Indsættelses- og sletningsoperationer i TreeMap har en tidskompleksitet på O(log n) på grund af behovet for træomstrukturering, hvilket gør dem langsommere sammenlignet med HashMap eller LinkedHashMap.Begrænset ydeevne for usorterede data:TreeMap fungerer effektivt for sorterede data, men dets ydeevne kan forringes, når der håndteres usorterede data eller hyppige ændringer, da det kræver at opretholde den sorterede rækkefølge.

Funktioner:

    put(nøgle, værdi):Indsætter et nøgleværdi-par i trækortet.få (nøgle):Henter den værdi, der er knyttet til den angivne nøgle.indeholderNøgle(nøgle):Kontrollerer, om trækortet indeholder en bestemt nøgle.fjern (nøgle):Fjerner det nøgleværdipar, der er knyttet til den angivne nøgle.størrelse():Returnerer antallet af nøgleværdi-par i trækortet.keySet():Returnerer et sæt af alle nøgler i trækortet.værdier():Returnerer en samling af alle værdier i trækortet.entrySet():Returnerer et sæt nøgleværdi-par i trækortet.

Implementering:

Filnavn: 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); } } } 

Produktion:

 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) Graf:

Grafer er datastrukturer, der repræsenterer en samling af indbyrdes forbundne noder eller knudepunkter. De er sammensat af toppunkter og kanter, hvor toppunkter repræsenterer entiteter og kanter repræsenterer relationerne mellem disse entiteter.

postordre krydsning

Fordele:

    Alsidighed:Grafer kan repræsentere en lang række scenarier i den virkelige verden, hvilket gør dem velegnede til forskellige applikationer såsom sociale netværk, transportsystemer og computernetværk.Relationsrepræsentation:Grafer giver en naturlig måde at repræsentere relationer og forbindelser mellem entiteter, hvilket giver mulighed for effektiv analyse og gennemgang af disse relationer.Effektiv søgning og gennemgang:Grafalgoritmer som Breadth-First Search (BFS) og Depth-First Search (DFS) muliggør effektiv gennemgang og søgning af grafens spidser og kanter.Modellering af komplekse relationer:Grafer kan modellere komplekse relationer, herunder hierarkiske strukturer, cykliske afhængigheder og flere forbindelser mellem enheder.

Ulemper:

    Rumkompleksitet:Grafer kan forbruge en betydelig mængde hukommelse, især grafer i stor skala med mange hjørner og kanter.Kompleksiteten af ​​operationer:Visse grafoperationer, såsom at finde den korteste vej eller detektere cyklusser, kan have høj tidskompleksitet, især i tætte grafer.Vedligeholdelsesbesvær:Ændring eller opdatering af en graf kan være kompleks, da ændringer i grafens struktur kan påvirke dens forbindelse og eksisterende algoritmer.

Implementering:

Filnavn: 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) Træ:

Et træ er en meget brugt datastruktur inden for datalogi, der repræsenterer en hierarkisk struktur. Den består af noder forbundet af kanter, hvor hver node kan have nul eller flere underordnede noder.

Fordele:

    Hierarkisk struktur:Træer giver en naturlig måde at repræsentere hierarkiske relationer på, såsom filsystemer, organisationsdiagrammer eller HTML/XML-dokumenter.Effektiv søgning:Binære søgetræer muliggør effektiv søgning med en tidskompleksitet på O(log n), hvilket gør dem velegnede til at gemme og hente sorterede data.Hurtig indsættelse og sletning:Trædatastrukturer tilbyder effektive indsættelses- og sletningsoperationer, især når de er afbalanceret, såsom AVL-træer eller rød-sorte træer.Bestilt iteration:Gennemgang i rækkefølge af et binært søgetræ giver elementer i en sorteret rækkefølge, hvilket er nyttigt til opgaver som at udskrive elementer i sorteret rækkefølge eller finde det næste/forrige element.

Ulemper:

    Høj hukommelsesomkostning:Træer kræver yderligere hukommelse til at gemme nodereferencer eller pointere, hvilket kan resultere i højere hukommelsesforbrug sammenlignet med lineære datastrukturer som arrays eller lister.Kompleks implementering:Implementering og vedligeholdelse af en trædatastruktur kan være mere kompleks sammenlignet med andre datastrukturer som arrays eller lister, især for balancerede trævarianter.Begrænset drift:Nogle trævarianter, såsom binære søgetræer, understøtter ikke effektive operationer som at finde det k. mindste element eller finde rangeringen af ​​et element.

Funktioner:

    Indskud:Tilføj en ny node til træet.Sletning:Fjern en node fra træet.Søg:Find en bestemt node eller et bestemt element i træet.Gennemgang:Kør gennem træet i forskellige rækkefølger, såsom i-ordre, pre-order eller post-order.Højde/dybde:Beregn højden eller dybden af ​​træet.Balance:Sørg for, at træet forbliver afbalanceret for at opretholde en effektiv drift.

Implementering:

Filnavn: 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)>