logo

Datastrukturer i Java

De många sätt som data kan ordnas, sparas och hanteras i ett datorprogram kallas datastrukturer i Java. Dessa strukturer erbjuder en metodisk metod för att hantera och hantera data effektivt, vilket möjliggör användbara operationer som infogning, radering, hämtning och genomgång.

Artikeln kommer att utforska allt relaterat till datastrukturerna i Java, och det hjälper nybörjare att förstå enkelt och effektivt.

  • Vad är Java?
  • Vad är datastrukturer i Java?
  • Typer av datastrukturer i Java
  • Fördelar med datastrukturer i Java
  • Klassificering av datastrukturer
  • Vanliga frågor om datastrukturer i Java

Vad är Java?

Java är ett populärt objektorienterat programmeringsspråk känt för sitt stora standardbibliotek och plattformsfrihet. Den erbjuder en solid arkitektur för att skapa program som körs utan omkompilering över olika plattformar. Det välkända biblioteket för Java har ett urval av registersystem som gör det lönsamt att hantera många datatyper effektivt.

Vad är datastrukturer i Java?

Sättet som data organiseras och lagras i ett datorprograms minne är starkt beroende av Java-poststrukturer. Det välkända Java-biblioteket innehåller en betydande typ av inbyggda statistikstrukturer. Några av de registersystem som tillåter programmerare korta och enkla sätt att spara och ordna data inkluderar anslutna listor, stackar, köer och arrayer. Utvecklare kan snabbt utföra operationer som att infoga, radera, söka och sortera eftersom de tillhandahåller en rad mekanismer för att få åtkomst till, ändra och hantera data. Java-programmerare kan minska minnesanvändningen och avsevärt öka den totala effektiviteten av sina program genom att använda dessa datastrukturer.

Typer av datastrukturer i Java

Listan över datastrukturer i Java listas nedan

  1. Matriser
  2. ArrayList
  3. Länkad lista
  4. Stack
  5. HashMap
  6. HashSet
  7. Träduppsättning
  8. Trädkarta
  9. Graf
  10. Träd

Diagrammet nedan förklarar tydligt typerna av datastrukturer i Java mycket tydligt.

Datastrukturer i Java

Ytterligare klassificering av typer av datastrukturer:

Det finns två typer av datastrukturer: -

  1. Primitiva datastrukturer
  2. Icke-primitiva datastrukturer

1) Primitiva datastrukturer: Även kända som primitiva datatyper, dessa är grundläggande inbyggda datatyper i Java. De inkluderar:

    Byte:Lagrar heltal från -128 till 127.kort:Lagrar heltal från -32 768 till 32 767.int:Lagrar heltal från -2 147 483 648 till 2 147 483 647.flyta:Lagrar flyttal med enkel precision.röding:Lagrar enskilda tecken.boolesk:Lagrar sanna eller falska värden.lång:Lagrar stora heltal.Dubbel:Lagrar flytande faktortal med dubbel precision.

2) Icke-primitiva datastrukturer: Icke-primitiva poststrukturer är mer komplexa och består av primitiva informationstyper. De kan dessutom kategoriseras i två sorter:

    Linjära datastrukturer:I linjära datastrukturer är elementen ordnade linjärt eller sekventiellt. Exempel inkluderar:
      Arrayer:En grupp av identiskt typade element placerade i en array enligt ett förutbestämt arrangemang.Stackar:En Last-In-First-Out (LIFO)-struktur där endast de översta objekten kan läggas till eller tas bort.Svansar:First-In-First-Out (FIFO)-strukturer används i köer, där föremål infogas på den returnerade och tas ut på framsidan.Länkad lista:En relaterad lista omfattar en samling prylar som kallas noder, som var och en har en referens till noden efter sig och statistik inuti den.
    Icke-linjära datastrukturer:I icke-linjära datastrukturer är elementen arrangerade på ett icke-sekventiellt sätt. Exempel inkluderar:
      Träd:Träd är en typ av nodbaserad hierarkisk struktur, med en rotnod överst och underordnade noder som förgrenar sig från den. Exempel inkluderar röd-svarta träd, AVL-träd, binära sökträd och binära träd.Grafer:En uppsättning noder länkade genom att använda kanter, där noder kan ha vilken mängd anslutningar som helst. Grafer används för att symbolisera komplexa relationer mellan objekt.Högen:En specialiserad trädbaserad struktur där varje bestämd nod har ett värde som är mer eller mindre än dess barn, beroende på om det är en maxhög eller en minhög.Hash:Datastrukturer som använder en hashfunktion för att mappa nycklar till värden. Exempel är hashuppsättningar och hashkartor, som ger grön hämtning och lagring av statistik baserad på exakta nycklar.
Datastrukturer i Java

Fördelar med datastrukturer i Java

    Effektiv dataorganisation:Datastrukturer tillhandahåller organiserade sätt att lagra och hantera data, vilket möjliggör effektiv åtkomst, manipulation och hämtning. De optimerar minnesanvändningen och underlättar snabbare exekvering av algoritmer.Bättre prestanda:Utvecklare kan förbättra prestanda när det gäller hastighet och minnesanvändning genom att välja lämplig datastruktur för en viss aktivitet. Prestanda optimeras eftersom specifika datastrukturer är gjorda för att utmärka sig vid särskilda åtgärder som att söka, sortera eller infoga information.Kod återanvändbarhet:Java erbjuder ett brett utbud av inbyggda datastrukturer som är enkla för programmerare att använda. Dessa återanvändbara datastrukturer sparar tid och ansträngning genom att ta bort behovet av att skapa sofistikerade algoritmer från grunden.Kodens enkelhet:Datastrukturer gör implementeringen av komplicerade processer enklare att koda. De erbjuder abstraktioner på hög nivå och kapslar in detaljerna i datahantering, vilket förbättrar kodens läsbarhet, underhållbarhet och tydlighet.Flexibilitet och anpassningsförmåga:Datastrukturer erbjuder flexibilitet vid hantering av olika typer och storlekar av data. De kan anpassas dynamiskt för att tillgodose ändrade datakrav och tillhandahålla mekanismer för effektiv datamanipulation.Standardiserad och väl testad:Standardbiblioteket för Java innehåller inbyggda datastrukturer som har genomgått betydande testning och optimering, vilket garanterar deras pålitlighet och prestanda. Att använda dessa vanliga datastrukturer minskar risken för fel och ger applikationsutveckling en solid grund.Skalbarhet:Datastrukturer ger skalbarhetsalternativ, vilket gör att applikationer kan hantera stora mängder data effektivt. De kan växa eller krympa dynamiskt baserat på datastorleken, vilket säkerställer optimal prestanda även med ökande databehov.Algoritmdesign:Datastrukturer är avgörande i algoritmdesign och analys. De tillhandahåller den underliggande strukturen och operationerna som krävs för att implementera olika algoritmer och lösa komplexa problem.

1) Arrayer:

En array är en grundläggande och ofta använd datastruktur i samband med Javas datastrukturer. Den erbjuder en metod för att lagra en samling av identiska komponenter i fast storlek. Eftersom de ger snabb och enkel åtkomst till element beroende på deras index, är arrayer ett avgörande verktyg för att hantera och organisera data.

Fördelar:

    Dataorganisation:Matriser ger ett strukturerat sätt att lagra och organisera element, vilket förbättrar datahanteringen.Slumpmässig tillgång:Element kan nås direkt med hjälp av deras index, vilket möjliggör effektiv hämtning och modifiering.Fixad storlek:Matriser har en förutbestämd storlek, vilket möjliggör effektiv minnesallokering.Homogena element:Matriser lagrar element av samma typ, vilket säkerställer datakonsistens och förenklar operationer.Iteration:Matriser stöder enkel iteration genom element, vilket underlättar genomgång och bearbetning.Sortering och sökning:Matriser fungerar bra med sorterings- och sökalgoritmer, vilket erbjuder effektiv drift.Minneseffektivitet:Arrayer optimerar minnesanvändningen genom att lagra element i angränsande regioner.Kompatibilitet:Arrayer stöds brett i Java, vilket gör dem kompatibla med olika ramverk och verktyg.

Nackdelar:

    Fixad storlek:Matriser kan inte ändras dynamiskt, vilket kräver rekreation för storleksändringar.Minnesförlust:Oanvända element i större arrayer kan leda till minnesförlust.Insättnings- och raderingskostnader:Att infoga eller ta bort element i mitten av en array kräver att efterföljande element flyttas, vilket resulterar i ineffektivitet.Brist på flexibilitet:Matriser har stela datatyper och kan inte ta emot olika datatyper utan ytterligare matriser eller datastrukturer.

Funktioner:

    Skapa en array:Deklarera och initiera en array med en specifik storlek med hjälp av arraytypen och det nya nyckelordet.Åtkomst till element:Använd indexet för att komma åt enskilda element i arrayen.Ändring av element:Uppdatera värdet på ett element genom att tilldela ett nytt värde till ett specifikt index i arrayen.Hitta längd:Använd längdattributet för att bestämma arrayens längd.Itererar genom Arrayen:Använd loopar för att gå igenom varje element i arrayen och exekvera

Genomförande:

Filnamn: 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 är en dynamisk datastruktur som möjliggör lagring och manipulering av element. Det är en del av Java Collections Framework och implementeras med en array internt.

Fördelar:

    Dynamisk storlek:Till skillnad från arrayer kan ArrayLists dynamiskt växa eller krympa i storlek när element läggs till eller tas bort. Det eliminerar behovet av manuell storleksändring och möjliggör hantering av varierande mängder data bekvämt.Enkel elementmanipulation:ArrayLists erbjuder metoder för att lägga till, ta bort och ändra element var som helst i listan. Dess flexibilitet förenklar vanliga operationer såsom infogning, radering och uppdatering, vilket gör elementmanipulation mer effektiv.Slumpmässig tillgång:ArrayLists stöder slumpmässig tillgång till element med hjälp av deras index, vilket möjliggör snabb hämtning och modifiering av element på specifika positioner i listan. Det underlättar effektiv tillgång till element och förbättrar den övergripande prestandan.Kompatibilitet med Java Collection Framework:ArrayLists implementerar List-gränssnittet, vilket gör dem kompatibla med andra samlingsklasser i Java Collections Framework. Dess kompatibilitet möjliggör sömlös integration med olika algoritmer och operationer som tillhandahålls av ramverket.

Nackdelar:

    Högre minneskostnader:ArrayLists kräver ytterligare minne för att behålla sin interna struktur, vilket resulterar i högre minneskostnader jämfört med arrays. Det kan vara ett bekymmer när man har att göra med stora samlingar av element.Långsammare infogning och radering:Att infoga eller ta bort element i mitten av en ArrayList kräver att element flyttas, vilket kan vara tidskrävande för stora listor. I scenarier där frekventa insättnings- eller raderingsoperationer förväntas kan andra datastrukturer som LinkedList erbjuda bättre prestanda.Begränsad prestanda för sökning:Att söka efter ett element i en osorterad ArrayList kräver iteration över elementen tills en matchning hittas. Det är en linjär sökmetod som resulterar i långsammare sökprestanda jämfört med datastrukturer optimerade för sökning, som HashSet eller TreeMap.Inget stöd för primitiv typ:ArrayLists kan bara lagra objekt och stöder inte direkt primitiva datatyper som int eller char. För att lagra primitiva typer måste omslagsklasser som Integer eller Character användas, vilket leder till potentiell autoboxning och uppackning.

Funktioner:

hur man hittar dolda saker på Android
    Skapa en ArrayList:Deklarera och initiera en ArrayList med klassen ArrayList och ange elementtypen inom vinkelparenteserna.Lägga till element:Använd add-metoden för att lägga till element i slutet av ArrayList.Åtkomst till element:Använd get-tekniken för att hämta detaljpriset vid ett valt index.Ändring av element:Uppdatera detaljkostnaden vid ett specifikt index för användningen av den inställda metoden.Hitta storlek:Använd dimensionsmetoden för att få fram det banbrytande antalet faktorer i ArrayList.Ta bort element:Använd borttagningsmetoden för att ta bort en detalj i ett specifikt index eller genom att tillhandahålla objektreferensen.Itererar genom ArrayList:Använd loopar för att iterera över varje element i ArrayList och utföra operationer på dem.

Genomförande:

Filnamn: 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) Länkad lista:

En länkad lista är en linjär datastruktur där element lagras i separata objekt som kallas noder. En referenslänk till följande nod i sekvensen ingår i varje nods dataelement. Listans sista nod länkar till null, vilket indikerar att listan har avslutats.

Till skillnad från arrayer kräver länkade listor inte sammanhängande minnesallokering. Varje nod i en länkad lista kan tilldelas oberoende, vilket möjliggör dynamisk minnesallokering och effektiva insättnings- och raderingsoperationer.

Fördelar:

    Dynamisk storlek:LinkedList kan växa eller krympa dynamiskt, vilket gör den lämplig för varierande eller okända datastorlekar.Effektiv infogning och radering:Att infoga eller ta bort element i en LinkedList är effektivt, eftersom det inte kräver att element flyttas.Inget kontinuerligt minneskrav:LinkedList behöver inte sammanhängande minnesallokering, vilket gör den flexibel och lämplig för oförutsägbara minnessituationer.Enkel modifiering:LinkedList tillåter enkel modifiering av element genom att ändra referenspekare, vilket möjliggör effektiv manipulation.

Nackdelar:

"vad är skillnaden mellan ett lejon och en tiger"
    Långsammare slumpmässig åtkomst:LinkedList har långsammare slumpmässig åtkomst eftersom den kräver att man går igenom listan för att komma åt element efter index.Ökat minneskostnader:LinkedList kräver ytterligare minne för referenser och noder, vilket ökar minneskostnaden jämfört med arrayer.Ineffektiv sökning:LinkedList har långsammare sökoperationer, vilket kräver sekventiell iteration för att hitta specifika element.

Funktioner:

    Skapa en länkad lista:Deklarera och initiera en LinkedList med klassen LinkedList.Lägga till element:Använd add-metoden för att lägga till element i slutet av LinkedList.Åtkomst till element:Använd get-metoden för att hämta värdet av ett element vid ett specifikt index.Ändring av element:Uppdatera värdet på ett element vid ett visst index med hjälp av set-metoden.Ta bort element:Använd borttagningsmetoden för att ta bort ett element vid ett specifikt index eller genom att tillhandahålla objektreferensen.

Genomförande:

Filnamn: 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) Stack:

Last-In-First-Out (LIFO)-principen dikterar att det element som senast infogades också är det element som tas bort först. En stack är en linjär datastruktur som följer denna regel. Den använder kommandona 'push' och 'pop' för att lägga till element i stacken och följaktligen ta bort det översta elementet från stacken. 'Peek'-tekniken möjliggör dessutom åtkomst till det övre elementet utan att ta bort det.

Funktioner hos en stack:

    LIFO beteende:Det sista elementet som skjuts på stapeln är det första som skjuts ut, vilket gör det lämpligt för applikationer där ordningen för insättning och borttagning är viktig.Begränsad åtkomst:Stackar ger vanligtvis begränsad åtkomst till element. Du kan bara komma åt det översta elementet, och för att nå andra element måste du poppa elementen ovanför dem.Dynamisk storlek:Stackar kan implementeras med hjälp av arrayer eller länkade listor, vilket möjliggör en dynamisk storlek. De kan växa eller krympa efter behov under körning.

Fördelar:

    Enkelhet:Stackar är lätta att förstå och implementera.Effektivitet:Insättnings- och raderingsoperationer har en tidskomplexitet på O(1).Funktionssamtalshantering:Stackar hanterar funktionsanrop och variabel lagring effektivt.Funktionen Ångra/Gör om:Stackar möjliggör ångra och gör om operationer i applikationer.

Nackdelar:

    Begränsad åtkomst:Tillgång till element är begränsad till toppen av stapeln.Storleksbegränsningar:Stackar kan ha storleksbegränsningar beroende på implementeringen.Inte lämplig för alla scenarier:Stackar är specifika för LIFO-beteende och kanske inte är lämpliga i andra fall.

Genomförande:

Filnamn: 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ö är en linjär datastruktur i Java som följer principen First-In-First-Out (FIFO). Den representerar en samling element där element sätts in på baksidan och tas bort från framsidan.

Funktioner:

    Kö:Lägga till ett element längst bak i kön.Avkö:Ta bort ett element från framsidan av kön.Titt:Hämta elementet längst fram i kön utan att ta bort det.Storlek:Bestämma antalet element i kön.Tom check:Kontrollerar om kön är tom.

Fördelar:

    FIFO-beteende:Element bearbetas i den ordning de infogas, vilket säkerställer bevarandet av den ursprungliga sekvensen.Effektiv insättning och borttagning:Att lägga till och ta bort element från en kö går snabbt och har en konstant tidskomplexitet på O(1).Synkronisering:Java tillhandahåller synkroniserade köimplementeringar, vilket gör dem säkra för samtidig programmering.Standardiserat gränssnitt:Kögränssnittet i Java erbjuder en gemensam uppsättning metoder, vilket möjliggör enkel utbytbarhet mellan olika köimplementeringar.

Nackdelar:

    Ingen slumpmässig åtkomst:Köer stöder inte direkt åtkomst till element i mitten. För att komma åt specifika positioner krävs att föregående element tas ur kö.Begränsad storlek:Vissa köimplementeringar har en fast storlek eller kapacitet, vilket leder till spill eller undantag när den maximala storleken överskrids.Ineffektiv sökning:Att söka efter ett element i en kö kräver avköning tills en matchning hittas, vilket resulterar i en linjär sökning med potentiellt hög tidskomplexitet.

Genomförande:

Filnamn: 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:

En HashMap är en datastruktur i Java som ger ett sätt att lagra och hämta nyckel-värdepar. Det är en del av Java Collections Framework och implementeras baserat på hashtabellens datastruktur.

Funktioner:

    put(nyckel, värde):Infogar det angivna nyckel-värdeparet i HashMap.få (nyckel):Hämtar värdet som är associerat med den angivna nyckeln.innehåller nyckel(nyckel):Kontrollerar om HashMap innehåller den angivna nyckeln.innehållerValue(värde):Kontrollerar om HashMap innehåller det angivna värdet.ta bort (nyckel):Tar bort nyckel-värdeparet som är associerat med den angivna nyckeln från HashMap.storlek():Returnerar antalet nyckel-värdepar i HashMap.är tom():Kontrollerar om HashMap är tom.keySet():Returnerar en uppsättning som innehåller alla nycklar i HashMap.värden():Returnerar en samling som innehåller alla värden i HashMap.klar():Tar bort alla nyckel-värdepar från HashMap.

Fördelar:

    Effektiv hämtning:HashMap ger snabb hämtning av värden baserat på nycklar med konstant-tidskomplexitet O(1).Flexibel nyckel-värde-parning:HashMap tillåter alla icke-nullobjekt som en nyckel, vilket möjliggör specialdefinierade nycklar för att lagra och hämta data.Dynamisk storlek:HashMap kan dynamiskt växa eller krympa i storlek för att hantera varierande mängder data.Kompatibilitet med Java Collections Framework:HashMap implementerar kartgränssnittet, vilket möjliggör sömlös integration med andra samlingsklasser.

Nackdelar:

    Brist på beställning:HashMap bevarar inte ordningen på elementen. Använd LinkedHashMap eller TreeMap för specifika beställningskrav.Ökat minneskostnader:HashMap kräver extra minne för hashkoder och intern struktur jämfört med enklare datastrukturer.Långsammare iteration:Iteration över en HashMap kan vara långsammare jämfört med arrayer eller listor på grund av att man korsar den underliggande hashtabellen.

Genomförande:

Filnamn: 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 är en datastruktur i Java som implementerar Set-gränssnittet och lagrar element i en hashtabell.

Funktioner:

    Lagrar unika element:HashSet tillåter inte dubbletter av element. Varje element i HashSet är unikt.Använder hash-baserad uppslagning:HashSet använder hashvärdet för varje element för att bestämma dess lagringsplats, vilket ger effektiv elementhämtning.Oordnad samling:Elementen i en HashSet lagras inte i en specifik ordning. Ordningen på element kan ändras med tiden.

Fördelar:

    Snabb elementsökning:HashSet ger snabba uppslagsoperationer, vilket gör det effektivt att kontrollera om ett element finns i uppsättningen.Inga dubbletter av element:HashSet hanterar automatiskt dubbletter av element och säkerställer att varje element är unikt.Integration med Java Collections Framework:HashSet implementerar Set-gränssnittet, vilket gör det kompatibelt med andra samlingsklasser i Java Collections Framework.

Nackdelar:

instans av i java
    Ingen garanterad beställning:HashSet upprätthåller inte ordningen på elementen. Om ordningen på element är viktig är HashSet inte lämpligt.Ingen indexering:HashSet ger inte direkt indexering eller positionell åtkomst till element. För att komma åt element måste du iterera över uppsättningen.Högre minneskostnader:HashSet kräver ytterligare minne för att lagra hashvärden och bibehålla hashtabellstrukturen, vilket resulterar i högre minnesanvändning jämfört med vissa andra datastrukturer.

Genomförande:

Filnamn: 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äduppsättning:

TreeSet är en implementering av SortedSet-gränssnittet i Java som använder ett självbalanserande binärt sökträd som kallas ett röd-svart träd för att lagra element i sorterad ordning.

Fördelar:

    Sorterad ordning:TreeSet underhåller automatiskt elementen i en sorterad ordning baserat på deras naturliga ordning eller en anpassad komparator. Det möjliggör effektiv sökning och hämtning av element i stigande eller fallande ordning.Inga dubbletter av element:TreeSet tillåter inte dubbletter av element. Det säkerställer att varje element i uppsättningen är unikt, vilket kan vara användbart i scenarier där dubbletter av värden bör undvikas.Effektiv drift:TreeSet tillhandahåller effektiva operationer som infogning, radering och sökning. Dessa operationer har en tidskomplexitet på O(log n), där n är antalet element i mängden.Navigerbara setoperationer:TreeSet tillhandahåller ytterligare navigeringsmetoder, såsom higher(), lower(), ceiling() och floor(), som låter dig hitta element som är större än, mindre än eller lika med ett givet värde.

Nackdelar:

    Över huvudet:TreeSet kräver ytterligare minne för att lagra den interna datastrukturen, vilket kan leda till högre minneskostnader jämfört med andra uppsättningsimplementeringar.Långsammare insättning och borttagning:Insättnings- och borttagningsoperationer i TreeSet involverar att upprätthålla den sorterade ordningen av element, vilket kan kräva omstrukturering av trädet. Det kan göra dessa operationer något långsammare jämfört med HashSet eller LinkedHashSet.Begränsad anpassning:TreeSet är främst designad för naturlig beställning eller en enda anpassad komparator. Det kan behöva mer flexibilitet för flera sorteringskriterier eller komplex sorteringslogik.

Funktioner:

    add(element):Lägger till ett element till TreeSet samtidigt som den sorterade ordningen bibehålls.remove(element):Tar bort det angivna elementet från TreeSet.innehåller(element):Kontrollerar om TreeSet innehåller det angivna elementet.storlek():Returnerar antalet element i TreeSet.först():Returnerar det första (lägsta) elementet i TreeSet.sista():Returnerar det sista (högsta) elementet i TreeSet.högre(element):Returnerar det minsta elementet i TreeSet som är strikt större än det givna elementet.lägre(element):Returnerar det största elementet i TreeSet som är strikt mindre än det givna elementet.

Genomförande:

Filnamn: 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ädkarta:

TreeMap är en klass i Java som implementerar Map-gränssnittet och tillhandahåller en sorterad nyckel-värde-mappning baserad på nycklarnas naturliga ordning eller en anpassad komparator.

Fördelar:

    Sorterad ordning:TreeMap underhåller nycklarna i sorterad ordning, vilket möjliggör effektiv sökning, hämtning och räckviddsbaserade operationer.Nyckel-värde-mappning:TreeMap lagrar nyckel-värdepar, vilket möjliggör effektiv sökning och hämtning av värden baserat på de associerade nycklarna.Implementering av röd-svart träd:TreeMap använder ett balanserat binärt sökträd (Red-Black Tree) internt, vilket säkerställer effektiv prestanda även för stora datamängder.Stöd för anpassade komparatorer:TreeMap tillåter användning av anpassade komparatorer för att definiera sorteringsordningen för nycklarna, vilket ger flexibilitet i sorteringskriterier.

Nackdelar:

    Minnesoverhead:TreeMap kräver ytterligare minne för att lagra den interna trädstrukturen och tillhörande objekt, vilket resulterar i högre minnesanvändning jämfört med enklare datastrukturer som HashMap.Långsammare infogning och radering:Insättnings- och raderingsoperationer i TreeMap har en tidskomplexitet på O(log n) på grund av behovet av trädomstrukturering, vilket gör dem långsammare jämfört med HashMap eller LinkedHashMap.Begränsad prestanda för osorterad data:TreeMap fungerar effektivt för sorterad data, men dess prestanda kan försämras vid hantering av osorterade data eller frekventa ändringar, eftersom det kräver att den sorterade ordningen upprätthålls.

Funktioner:

industri och fabrik
    put(nyckel, värde):Infogar ett nyckel-värdepar i trädkartan.få (nyckel):Hämtar värdet som är associerat med den angivna nyckeln.innehållerKey(nyckel):Kontrollerar om TreeMap innehåller en specifik nyckel.ta bort (nyckel):Tar bort nyckel-värdeparet som är kopplat till den angivna nyckeln.storlek():Returnerar antalet nyckel-värdepar i TreeMap.keySet():Returnerar en uppsättning av alla nycklar i TreeMap.värden():Returnerar en samling av alla värden i TreeMap.entrySet():Returnerar en uppsättning nyckel-värdepar i trädkartan.

Genomförande:

Filnamn: 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) Diagram:

Grafer är datastrukturer som representerar en samling sammankopplade noder eller hörn. De är sammansatta av hörn och kanter, där hörn representerar enheter och kanter representerar relationerna mellan dessa enheter.

Fördelar:

    Mångsidighet:Grafer kan representera ett brett utbud av verkliga scenarier, vilket gör dem lämpliga för olika applikationer som sociala nätverk, transportsystem och datornätverk.Relationsrepresentation:Grafer ger ett naturligt sätt att representera relationer och samband mellan enheter, vilket möjliggör effektiv analys och genomgång av dessa relationer.Effektiv sökning och genomgång:Grafalgoritmer som bredd-först-sökning (BFS) och djup-först-sökning (DFS) möjliggör effektiv korsning och sökning av grafens hörn och kanter.Modellera komplexa relationer:Grafer kan modellera komplexa relationer, inklusive hierarkiska strukturer, cykliska beroenden och flera kopplingar mellan enheter.

Nackdelar:

    Utrymmes komplexitet:Grafer kan konsumera en betydande mängd minne, särskilt storskaliga grafer med många hörn och kanter.Verksamhetens komplexitet:Vissa grafoperationer, som att hitta den kortaste vägen eller detektera cykler, kan ha hög tidskomplexitet, särskilt i täta grafer.Svårigheter med underhåll:Att ändra eller uppdatera ett diagram kan vara komplicerat, eftersom förändringar i grafens struktur kan påverka dess anslutningsmöjligheter och befintliga algoritmer.

Genomförande:

Filnamn: 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äd:

Ett träd är en mycket använd datastruktur inom datavetenskap som representerar en hierarkisk struktur. Den består av noder förbundna med kanter, där varje nod kan ha noll eller fler underordnade noder.

Fördelar:

    Hierarkisk struktur:Träd är ett naturligt sätt att representera hierarkiska relationer, som filsystem, organisationsdiagram eller HTML/XML-dokument.Effektiv sökning:Binära sökträd möjliggör effektiv sökning med en tidskomplexitet på O(log n), vilket gör dem lämpliga för att lagra och hämta sorterad data.Snabb insättning och radering:Träddatastrukturer erbjuder effektiva insättnings- och raderingsoperationer, särskilt när de är balanserade, såsom AVL-träd eller röd-svarta träd.Beställd iteration:Genomgång i ordning av ett binärt sökträd ger element i en sorterad ordning, vilket är användbart för uppgifter som att skriva ut element i sorterad ordning eller hitta nästa/föregående element.

Nackdelar:

    Hög minneskostnad:Träd kräver ytterligare minne för att lagra nodreferenser eller pekare, vilket kan resultera i högre minnesanvändning jämfört med linjära datastrukturer som arrayer eller listor.Komplext genomförande:Implementering och underhåll av en träddatastruktur kan vara mer komplex jämfört med andra datastrukturer som arrayer eller listor, särskilt för balanserade trädvarianter.Begränsad verksamhet:Vissa trädvarianter, som binära sökträd, stöder inte effektiva operationer som att hitta det k:te minsta elementet eller att hitta ett elements rangordning.

Funktioner:

    Införande:Lägg till en ny nod i trädet.Radering:Ta bort en nod från trädet.Sök:Hitta en specifik nod eller ett specifikt element i trädet.Traversering:Gå igenom trädet i olika ordningsföljder, till exempel i beställning, förbeställning eller efterbeställning.Höjd/djup:Beräkna trädets höjd eller djup.Balans:Se till att trädet förblir balanserat för att upprätthålla effektiv drift.

Genomförande:

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