logo

Datastrukturer i Java

De mange måtene data kan ordnes, lagres og håndteres i et dataprogram, blir referert til som datastrukturer i Java. Disse strukturene tilbyr en metodisk metode for å håndtere og administrere data effektivt, og muliggjør nyttige operasjoner som innsetting, sletting, gjenfinning og kryssing.

Artikkelen vil utforske alt relatert til datastrukturene i Java, og den hjelper nybegynnere å forstå enkelt og effektivt.

  • Hva er Java?
  • Hva er datastrukturer i Java?
  • Typer datastrukturer i Java
  • Fordeler med datastrukturer i Java
  • Klassifisering av datastrukturer
  • Vanlige spørsmål om datastrukturer i Java

Hva er Java?

Java er et populært objektorientert programmeringsspråk kjent for sitt enorme standardbibliotek og plattformfrihet. Den tilbyr en solid arkitektur for å lage programmer som kjører uten rekompilering på tvers av ulike plattformer. Det velkjente biblioteket for Java har et utvalg journalsystemer som gjør det mulig å håndtere en rekke datatyper effektivt.

Hva er datastrukturer i Java?

Måten data er organisert og lagret i et dataprograms minne er nært avhengig av Java-poststrukturer. Det velkjente Java-biblioteket inkluderer en betydelig type innebygde statistikkstrukturer. Noen få av postsystemene som tillater programmerere korte og enkle måter å lagre og ordne data på inkluderer tilkoblede lister, stabler, køer og matriser. Utviklere kan raskt utføre operasjoner som innsetting, sletting, søking og sortering fordi de tilbyr en rekke mekanismer for å få tilgang til, endre og administrere data. Java-programmerere kan redusere minnebruken og øke den generelle effektiviteten til programmene betraktelig ved å bruke disse datastrukturene.

Typer datastrukturer i Java

Listen over datastrukturer i Java er oppført nedenfor

  1. Matriser
  2. ArrayList
  3. LinkedList
  4. Stable
  5. HashMap
  6. HashSet
  7. Tresett
  8. Trekart
  9. Kurve
  10. Tre

Diagrammet nedenfor forklarer tydelig typene datastrukturer i Java veldig tydelig.

Datastrukturer i Java

Ytterligere klassifisering av typer datastrukturer:

Det er to typer datastrukturer: -

  1. Primitive datastrukturer
  2. Ikke-primitive datastrukturer

1) Primitive datastrukturer: Også kjent som primitive datatyper, disse er grunnleggende innebygde datatyper i Java. De inkluderer:

    Byte:Lagrer hele tall fra -128 til 127.kort:Lagrer hele tall fra -32 768 til 32 767.int:Lagrer hele tall fra -2.147.483.648 til 2.147.483.647.flyte:Lagrer flyttallstall med enkel presisjon.røye:Lagrer individuelle tegn.boolsk:Lagrer sanne eller usanne verdier.lang:Lagrer store hele tall.Dobbelt:Lagrer tall med flytende faktor med dobbel presisjon.

2) Ikke-primitive datastrukturer: Ikke-primitive arkivstrukturer er mer komplekse og er sammensatt av primitive informasjonstyper. De kan i tillegg kategoriseres i to typer:

    Lineære datastrukturer:I lineære datastrukturer er elementene ordnet lineært eller sekvensielt. Eksempler inkluderer:
      Matriser:En gruppe av identisk type elementer plassert i en gruppe i henhold til et forhåndsbestemt arrangement.Stabler:En Last-In-First-Out (LIFO)-struktur der bare de øverste elementene kan legges til eller fjernes.Haler:First-In-First-Out (FIFO)-strukturer brukes i køer, hvor varer settes inn på den returnerte og tas ut på forsiden.Koblet liste:En relatert liste omfatter en samling av gadgets referert til som noder, som hver har en referanse til noden etter seg og statistikk inne i den.
    Ikke-lineære datastrukturer:I ikke-lineære datastrukturer er elementene ordnet på en ikke-sekvensiell måte. Eksempler inkluderer:
      Trær:Trær er en type nodebasert hierarkisk struktur, med en rotnode øverst og underordnede noder som forgrener seg fra den. Eksempler inkluderer rød-svarte trær, AVL-trær, binære søketrær og binære trær.Grafer:Et sett med noder koblet sammen ved hjelp av kanter, der noder kan ha en hvilken som helst mengde forbindelser. Grafer brukes til å symbolisere komplekse forhold mellom elementer.haug:En spesialisert trebasert struktur der hver bestemt node har en verdi som er mer eller mindre enn dens barn, avhengig av om det er en maksimal haug eller en min haug.Hash:Datastrukturer som bruker en hash-funksjon for å tilordne nøkler til verdier. Eksempler består av hasjsett og hasjkart, som gir grønn gjenfinning og lagring av statistikk basert på presise nøkler.
Datastrukturer i Java

Fordeler med datastrukturer i Java

    Effektiv dataorganisasjon:Datastrukturer gir organiserte måter å lagre og administrere data på, noe som muliggjør effektiv tilgang, manipulering og gjenfinningsoperasjoner. De optimerer minnebruken og muliggjør raskere utførelse av algoritmer.Bedre ytelse:Utviklere kan forbedre ytelsen når det gjelder hastighet og minneutnyttelse ved å velge passende datastruktur for en bestemt aktivitet. Ytelsen er optimalisert fordi spesifikke datastrukturer er laget for å utmerke seg ved bestemte handlinger som å søke, sortere eller sette inn informasjon.Gjenbrukbarhet av kode:Java tilbyr et bredt spekter av innebygde datastrukturer som er enkle å bruke for programmerere. Disse gjenbrukbare datastrukturene sparer tid og krefter ved å fjerne behovet for å lage sofistikerte algoritmer fra bunnen av.Kode enkelhet:Datastrukturer gjør implementeringen av kompliserte prosesser enklere å kode. De tilbyr abstraksjoner på høyt nivå og innkapsler detaljene ved databehandling, noe som forbedrer kodens lesbarhet, vedlikeholdbarhet og klarhet.Fleksibilitet og tilpasningsevne:Datastrukturer gir fleksibilitet i håndtering av ulike typer og størrelser av data. De kan justeres dynamisk for å imøtekomme endrede datakrav og gi mekanismer for effektiv datamanipulering.Standardisert og godt testet:Standardbiblioteket for Java inneholder innebygde datastrukturer som har gjennomgått betydelig testing og optimalisering, og garanterer deres pålitelighet og ytelse. Bruk av disse vanlige datastrukturene reduserer muligheten for feil og gir applikasjonsutvikling et solid fundament.Skalerbarhet:Datastrukturer gir skalerbarhetsalternativer, slik at applikasjoner kan håndtere store datamengder effektivt. De kan vokse eller krympe dynamisk basert på datastørrelsen, og sikre optimal ytelse selv med økende datakrav.Algoritmedesign:Datastrukturer er avgjørende i algoritmedesign og analyse. De gir den underliggende strukturen og operasjonene som er nødvendige for å implementere ulike algoritmer og løse komplekse problemer.

1) Matriser:

En array er en grunnleggende og ofte brukt datastruktur i sammenheng med Javas datastrukturer. Den tilbyr en metode for å lagre en samling av identiske komponenter i fast størrelse. Fordi de gir rask og enkel tilgang til elementer avhengig av deres indeks, er matriser et avgjørende verktøy for å administrere og organisere data.

Fordeler:

    Dataorganisasjon:Matriser gir en strukturert måte å lagre og organisere elementer på, og forbedre databehandlingen.Tilfeldig tilgang:Elementer kan nås direkte ved å bruke deres indeks, noe som muliggjør effektiv gjenfinning og modifikasjon.Fast størrelse:Matriser har en forhåndsbestemt størrelse, noe som muliggjør effektiv minneallokering.Homogene elementer:Matriser lagrer elementer av samme type, noe som sikrer datakonsistens og forenkler operasjoner.Iterasjon:Arrays støtter enkel iterasjon gjennom elementer, noe som letter gjennomkjøring og prosessering.Sortering og søking:Matriser fungerer godt med sorterings- og søkealgoritmer, og tilbyr effektiv drift.Minneeffektivitet:Arrays optimerer minnebruken ved å lagre elementer i sammenhengende områder.Kompatibilitet:Arrays støttes bredt i Java, noe som gjør dem kompatible med ulike rammeverk og verktøy.

Ulemper:

    Fast størrelse:Matriser kan ikke endres dynamisk, og krever rekreasjon for størrelsesendringer.Sløsing med minne:Ubrukte elementer i større arrays kan føre til minnesløsing.Overhead for innsetting og sletting:Å sette inn eller slette elementer i midten av en matrise krever forskyvning av påfølgende elementer, noe som resulterer i ineffektivitet.Mangel på fleksibilitet:Matriser har stive datatyper og kan ikke romme forskjellige datatyper uten ekstra matriser eller datastrukturer.

Funksjoner:

    Opprette en matrise:Deklarer og initialiser en matrise med en bestemt størrelse ved å bruke matrisetypen og det nye nøkkelordet.Tilgang til elementer:Bruk indeksen for å få tilgang til individuelle elementer i matrisen.Endre elementer:Oppdater verdien til et element ved å tilordne en ny verdi til en bestemt indeks i matrisen.Finnelengde:Bruk lengdeattributtet for å bestemme matrisens lengde.Iterering gjennom matrisen:Bruk loops for å gå gjennom hvert element i matrisen og utfør

Gjennomføring:

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 som tillater lagring og manipulering av elementer. Det er en del av Java Collections Framework og implementeres ved hjelp av en matrise internt.

Fordeler:

    Dynamisk størrelse:I motsetning til arrays, kan ArrayLists dynamisk vokse eller krympe i størrelse når elementer legges til eller fjernes. Det eliminerer behovet for manuell endring av størrelse og gjør det enkelt å håndtere varierende mengder data.Enkel elementmanipulering:ArrayLists tilbyr metoder for å legge til, fjerne og endre elementer hvor som helst i listen. Dens fleksibilitet forenkler vanlige operasjoner som innsetting, sletting og oppdatering, noe som gjør elementmanipulering mer effektiv.Tilfeldig tilgang:ArrayLists støtter tilfeldig tilgang til elementer ved å bruke deres indeks, noe som muliggjør rask gjenfinning og modifikasjon av elementer på bestemte posisjoner i listen. Det forenkler effektiv tilgang til elementer og forbedrer den generelle ytelsen.Kompatibilitet med Java Collection Framework:ArrayLists implementerer List-grensesnittet, noe som gjør dem kompatible med andre samlingsklasser i Java Collections Framework. Dens kompatibilitet tillater sømløs integrasjon med ulike algoritmer og operasjoner levert av rammeverket.

Ulemper:

    Høyere minneoverhead:ArrayLists krever ekstra minne for å opprettholde sin interne struktur, noe som resulterer i høyere minneoverhead sammenlignet med arrays. Det kan være en bekymring når man arbeider med store samlinger av elementer.Langsommere innsetting og sletting:Å sette inn eller slette elementer i midten av en ArrayList krever skiftende elementer, noe som kan være tidkrevende for store lister. I scenarier der hyppige innsettings- eller slettingsoperasjoner er forventet, kan andre datastrukturer som LinkedList tilby bedre ytelse.Begrenset ytelse for søk:Å søke etter et element i en usortert ArrayList krever iterasjon over elementene til en match blir funnet. Det er en lineær søketilnærming som resulterer i tregere søkeytelse sammenlignet med datastrukturer optimalisert for søk, for eksempel HashSet eller TreeMap.Ingen støtte for primitiv type:ArrayLists kan bare lagre objekter og støtter ikke direkte primitive datatyper som int eller char. For å lagre primitive typer, må innpakningsklasser som Integer eller Character brukes, noe som fører til potensiell autoboksing og unboxing overhead.

Funksjoner:

hvordan kaste streng til int i java
    Opprette en ArrayList:Deklarer og initialiser en ArrayList ved å bruke ArrayList-klassen og spesifiser elementtypen innenfor vinkelparentesene.Legge til elementer:Bruk add-metoden for å legge til elementer på slutten av ArrayList.Tilgang til elementer:Bruk get-teknikken for å hente detaljprisen ved en valgt indeks.Endre elementer:Oppdater detaljkostnadene ved en spesifikk indeks for bruken av den angitte tilnærmingen.Finne størrelse:Bruk dimensjonsmetoden for å få banebrytende antall faktorer i ArrayList.Fjerning av elementer:Bruk fjerntilnærmingen for å slette en detalj ved en spesifikk indeks eller ved å oppgi objektreferansen.Iterering gjennom ArrayList:Bruk loops til å iterere over hvert element i ArrayList og utføre operasjoner på dem.

Gjennomføring:

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

Produksjon:

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

En koblet liste er en lineær datastruktur der elementer er lagret i separate objekter kalt noder. En referanselenke til følgende node i sekvensen er inkludert i hver nodes dataelement. Listens siste node lenker til null, noe som indikerer at listen er avsluttet.

I motsetning til arrays, krever koblede lister ikke sammenhengende minneallokering. Hver node i en koblet liste kan tildeles uavhengig, noe som muliggjør dynamisk minneallokering og effektive innsettings- og slettingsoperasjoner.

Fordeler:

    Dynamisk størrelse:LinkedList kan vokse eller krympe dynamisk, noe som gjør den egnet for varierende eller ukjente datastørrelser.Effektiv innsetting og sletting:Å sette inn eller slette elementer i en LinkedList er effektivt, siden det ikke krever skiftende elementer.Ingen sammenhengende minnekrav:LinkedList trenger ikke sammenhengende minneallokering, noe som gjør den fleksibel og egnet for uforutsigbare minnesituasjoner.Enkel modifikasjon:LinkedList tillater enkel modifikasjon av elementer ved å endre referansepekere, noe som muliggjør effektiv manipulering.

Ulemper:

    Langsommere tilfeldig tilgang:LinkedList har langsommere tilfeldig tilgang da den krever å krysse listen for å få tilgang til elementer etter indeks.Økt minneoverhead:LinkedList krever ekstra minne for referanser og noder, noe som øker minneoverhead sammenlignet med arrays.Ineffektivt søk:LinkedList har langsommere søkeoperasjoner, som krever sekvensiell iterasjon for å finne spesifikke elementer.

Funksjoner:

    Opprette en lenket liste:Deklarer og initialiser en LinkedList ved å bruke LinkedList-klassen.Legge til elementer:Bruk add-metoden for å legge til elementer på slutten av LinkedList.Tilgang til elementer:Bruk get-metoden for å hente verdien av et element ved en bestemt indeks.Endre elementer:Oppdater verdien til et element ved en bestemt indeks ved å bruke settmetoden.Fjerning av elementer:Bruk fjernmetoden for å slette et element ved en bestemt indeks eller ved å oppgi objektreferansen.

Gjennomføring:

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

Produksjon:

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

Last-In-First-Out (LIFO)-prinsippet tilsier at elementet som sist ble satt inn også er elementet som fjernes først. En stabel er en lineær datastruktur som følger denne regelen. Den bruker kommandoene 'push' og 'pop' for å legge til elementer i stabelen og følgelig fjerne toppelementet fra stabelen. 'Titt'-teknikken gir i tillegg tilgang til toppelementet uten å fjerne det.

Egenskaper til en stabel:

    LIFO-adferd:Det siste elementet som skyves inn på stabelen er det første som skal sprettes ut, noe som gjør det egnet for applikasjoner der rekkefølgen på innsetting og fjerning er viktig.Begrenset tilgang:Stabler gir vanligvis begrenset tilgang til elementer. Du kan bare få tilgang til det øverste elementet, og for å nå andre elementer må du sette elementene over dem.Dynamisk størrelse:Stabler kan implementeres ved hjelp av matriser eller koblede lister, noe som gir mulighet for en dynamisk størrelse. De kan vokse eller krympe etter behov under kjøring.

Fordeler:

    Enkelhet:Stabler er enkle å forstå og implementere.Effektivitet:Innsettings- og slettingsoperasjoner har en tidskompleksitet på O(1).Funksjonsanropsadministrasjon:Stabler administrerer funksjonsanrop og variabel lagring effektivt.Angre/Gjør om funksjonalitet:Stabler gjør det mulig å angre og gjøre om operasjoner i applikasjoner.

Ulemper:

css-justeringsbilder
    Begrenset tilgang:Tilgang til elementer er begrenset til toppen av stabelen.Størrelsesbegrensninger:Stabler kan ha størrelsesbegrensninger avhengig av implementeringen.Ikke egnet for alle scenarier:Stabler er spesifikke for LIFO-adferd og er kanskje ikke passende i andre tilfeller.

Gjennomføring:

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

Produksjon:

 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 som følger First-In-First-Out (FIFO)-prinsippet. Den representerer en samling av elementer der elementer settes inn bak og fjernes fra forsiden.

Egenskaper:

    Kø:Legge til et element bak i køen.Dekø:Fjerne et element fra forsiden av køen.Kikk:Hent elementet foran i køen uten å fjerne det.Størrelse:Bestemme antall elementer i køen.Tom sjekk:Sjekker om køen er tom.

Fordeler:

    FIFO-atferd:Elementer behandles i rekkefølgen de ble satt inn, noe som sikrer bevaring av den opprinnelige sekvensen.Effektiv innsetting og fjerning:Å legge til og fjerne elementer fra en kø er raskt og har en konstant tidskompleksitet på O(1).Synkronisering:Java gir synkroniserte køimplementeringer, noe som gjør dem trygge for samtidig programmering.Standardisert grensesnitt:Kø-grensesnittet i Java tilbyr et felles sett med metoder, som muliggjør enkel utskiftbarhet mellom ulike køimplementeringer.

Ulemper:

    Ingen tilfeldig tilgang:Køer støtter ikke direkte tilgang til elementer i midten. Tilgang til spesifikke posisjoner krever fjerning av foregående elementer.Begrenset størrelse:Noen køimplementeringer har en fast størrelse eller kapasitet, noe som fører til overløp eller unntak når maksimalstørrelsen overskrides.Ineffektivt søk:Å søke etter et element i en kø krever dekøing til et samsvar er funnet, noe som resulterer i et lineært søk med potensielt høy tidskompleksitet.

Gjennomføring:

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

Produksjon:

 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 som gir en måte å lagre og hente nøkkelverdi-par. Det er en del av Java Collections Framework og er implementert basert på hashtabelldatastrukturen.

Funksjoner:

    put(nøkkel, verdi):Setter inn det angitte nøkkelverdi-paret i HashMap.få (nøkkel):Henter verdien knyttet til den angitte nøkkelen.inneholder nøkkel(nøkkel):Sjekker om HashMap inneholder den angitte nøkkelen.inneholderVerdi(verdi):Sjekker om HashMap inneholder den angitte verdien.fjern (nøkkel):Fjerner nøkkel-verdi-paret knyttet til den angitte nøkkelen fra HashMap.størrelse():Returnerer antall nøkkelverdi-par i HashMap.er tom():Sjekker om HashMap er tomt.keySet():Returnerer et sett som inneholder alle nøklene i HashMap.verdier():Returnerer en samling som inneholder alle verdiene i HashMap.klar():Fjerner alle nøkkelverdi-parene fra HashMap.

Fordeler:

    Effektiv henting:HashMap gir rask gjenfinning av verdier basert på nøkler med konstanttidskompleksitet O(1).Fleksibel nøkkel-verdi-paring:HashMap tillater ethvert ikke-null-objekt som en nøkkel, noe som muliggjør spesialdefinerte nøkler for lagring og henting av data.Dynamisk størrelse:HashMap kan dynamisk vokse eller krympe i størrelse for å håndtere varierende mengder data.Kompatibilitet med Java Collections Framework:HashMap implementerer kartgrensesnittet, og muliggjør sømløs integrasjon med andre samlingsklasser.

Ulemper:

    Mangel på bestilling:HashMap bevarer ikke rekkefølgen på elementene. Bruk LinkedHashMap eller TreeMap for spesifikke bestillingskrav.Økt minneoverhead:HashMap krever ekstra minne for hash-koder og intern struktur sammenlignet med enklere datastrukturer.Langsommere iterasjon:Iterering over et HashMap kan være tregere sammenlignet med arrays eller lister på grunn av å krysse den underliggende hashtabellen.

Gjennomføring:

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

Produksjon:

 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 som implementerer Set-grensesnittet og lagrer elementer i en hashtabell.

Egenskaper:

    Lagrer unike elementer:HashSet tillater ikke dupliserte elementer. Hvert element i HashSet er unikt.Bruker hash-basert oppslag:HashSet bruker hash-verdien til hvert element for å bestemme lagringsplasseringen, noe som gir effektiv elementhenting.Uordnet samling:Elementene i et HashSet er ikke lagret i en bestemt rekkefølge. Rekkefølgen på elementene kan endres over tid.

Fordeler:

    Rask elementoppslag:HashSet gir raske oppslagsoperasjoner, noe som gjør det effektivt å sjekke om et element finnes i settet.Ingen dupliserte elementer:HashSet håndterer automatisk dupliserte elementer og sikrer at hvert element er unikt.Integrasjon med Java Collections Framework:HashSet implementerer Set-grensesnittet, noe som gjør det kompatibelt med andre samlingsklasser i Java Collections Framework.

Ulemper:

gi nytt navn til linux-mappen
    Ingen garantert bestilling:HashSet opprettholder ikke rekkefølgen på elementene. Hvis rekkefølgen på elementene er viktig, er ikke HashSet egnet.Ingen indeksering:HashSet gir ikke direkte indeksering eller posisjonell tilgang til elementer. For å få tilgang til elementer, må du iterere over settet.Høyere minne overhead:HashSet krever ekstra minne for å lagre hashverdier og opprettholde hashtabellstrukturen, noe som resulterer i høyere minnebruk sammenlignet med noen andre datastrukturer.

Gjennomføring:

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

Produksjon:

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

TreeSet er en implementering av SortedSet-grensesnittet i Java som bruker et selvbalanserende binært søketre kalt et rød-svart tre for å lagre elementer i sortert rekkefølge.

Fordeler:

    Sortert rekkefølge:TreeSet opprettholder automatisk elementene i en sortert rekkefølge basert på deres naturlige rekkefølge eller en tilpasset komparator. Det muliggjør effektiv søking og gjenfinning av elementer i stigende eller synkende rekkefølge.Ingen dupliserte elementer:TreeSet tillater ikke dupliserte elementer. Det sikrer at hvert element i settet er unikt, noe som kan være nyttig i scenarier der dupliserte verdier bør unngås.Effektiv drift:TreeSet gir effektive operasjoner som innsetting, sletting og søk. Disse operasjonene har en tidskompleksitet på O(log n), der n er antall elementer i settet.Navigerbare settoperasjoner:TreeSet gir ytterligere navigasjonsmetoder, for eksempel høyere(), lower(), loft() og floor(), som lar deg finne elementer som er større enn, mindre enn eller lik en gitt verdi.

Ulemper:

    Overhead:TreeSet krever ekstra minne for å lagre den interne datastrukturen, noe som kan føre til høyere minnekostnader sammenlignet med andre settimplementeringer.Langsommere innsetting og fjerning:Innsettings- og fjerningsoperasjoner i TreeSet innebærer å opprettholde den sorterte rekkefølgen av elementer, noe som kan kreve trerestrukturering. Det kan gjøre disse operasjonene litt tregere sammenlignet med HashSet eller LinkedHashSet.Begrenset tilpasning:TreeSet er først og fremst designet for naturlig bestilling eller en enkelt tilpasset komparator. Det kan trenge mer fleksibilitet for flere sorteringskriterier eller kompleks sorteringslogikk.

Funksjoner:

    add(element):Legger til et element til TreeSet mens den sorterte rekkefølgen opprettholdes.fjern(element):Fjerner det angitte elementet fra TreeSet.inneholder(element):Sjekker om TreeSet inneholder det spesifiserte elementet.størrelse():Returnerer antall elementer i TreeSet.først():Returnerer det første (laveste) elementet i TreeSet.siste():Returnerer det siste (høyeste) elementet i TreeSet.høyere(element):Returnerer det minste elementet i TreeSet som er strengt tatt større enn det gitte elementet.lavere(element):Returnerer det største elementet i TreeSet som er strengt tatt mindre enn det gitte elementet.

Gjennomføring:

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

Produksjon:

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

TreeMap er en klasse i Java som implementerer kartgrensesnittet og gir en sortert nøkkelverdi-kartlegging basert på den naturlige rekkefølgen til nøklene eller en tilpasset komparator.

Fordeler:

    Sortert bestilling:TreeMap opprettholder nøklene i sortert rekkefølge, noe som muliggjør effektiv søking, gjenfinning og rekkeviddebaserte operasjoner.Nøkkel-verdi-kartlegging:TreeMap lagrer nøkkel-verdi-par, noe som muliggjør effektivt oppslag og gjenfinning av verdier basert på de tilknyttede nøklene.Implementering av rød-svart tre:TreeMap bruker et balansert binært søketre (Red-Black Tree) internt, og sikrer effektiv ytelse selv for store datasett.Støtte for tilpassede komparatorer:TreeMap tillater bruk av tilpassede komparatorer for å definere sorteringsrekkefølgen til nøklene, noe som gir fleksibilitet i sorteringskriterier.

Ulemper:

    Minneoverhead:TreeMap krever ekstra minne for å lagre den interne trestrukturen og tilknyttede objekter, noe som resulterer i høyere minnebruk sammenlignet med enklere datastrukturer som HashMap.Langsommere innsetting og sletting:Innsettings- og slettingsoperasjoner i TreeMap har en tidskompleksitet på O(log n) på grunn av behovet for trerestrukturering, noe som gjør dem tregere sammenlignet med HashMap eller LinkedHashMap.Begrenset ytelse for usorterte data:TreeMap fungerer effektivt for sorterte data, men ytelsen kan forringes når det håndteres usorterte data eller hyppige modifikasjoner, da det krever å opprettholde den sorterte rekkefølgen.

Funksjoner:

    put(nøkkel, verdi):Setter inn et nøkkelverdi-par i TreeMap.få (nøkkel):Henter verdien knyttet til den angitte nøkkelen.inneholder nøkkel(nøkkel):Sjekker om TreeMap inneholder en bestemt nøkkel.fjern (nøkkel):Fjerner nøkkelverdi-paret knyttet til den angitte nøkkelen.størrelse():Returnerer antall nøkkelverdi-par i TreeMap.keySet():Returnerer et sett med alle nøkler i TreeMap.verdier():Returnerer en samling av alle verdier i TreeMap.entrySet():Returnerer et sett med nøkkelverdi-par i TreeMap.

Gjennomføring:

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

Produksjon:

 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 som representerer en samling av sammenkoblede noder eller toppunkter. De er sammensatt av toppunkter og kanter, der toppunkter representerer enheter og kanter representerer relasjonene mellom disse enhetene.

kø og prioritert kø i java

Fordeler:

    Allsidighet:Grafer kan representere et bredt spekter av virkelige scenarier, noe som gjør dem egnet for ulike applikasjoner som sosiale nettverk, transportsystemer og datanettverk.Relasjonsrepresentasjon:Grafer gir en naturlig måte å representere relasjoner og forbindelser mellom enheter, noe som muliggjør effektiv analyse og kryssing av disse relasjonene.Effektivt søk og gjennomgang:Grafalgoritmer som bredde-først-søk (BFS) og dybde-først-søk (DFS) muliggjør effektiv kryssing og søking av grafens toppunkter og kanter.Modellering av komplekse forhold:Grafer kan modellere komplekse relasjoner, inkludert hierarkiske strukturer, sykliske avhengigheter og flere forbindelser mellom enheter.

Ulemper:

    Plass kompleksitet:Grafer kan forbruke en betydelig mengde minne, spesielt grafer i stor skala med mange hjørner og kanter.Kompleksiteten til operasjoner:Visse grafoperasjoner, som å finne den korteste veien eller oppdage sykluser, kan ha høy tidskompleksitet, spesielt i tette grafer.Vanskeligheter med vedlikehold:Å endre eller oppdatere en graf kan være komplisert, ettersom endringer i grafens struktur kan påvirke tilkoblingen og eksisterende algoritmer.

Gjennomføring:

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

Et tre er en mye brukt datastruktur i informatikk som representerer en hierarkisk struktur. Den består av noder forbundet med kanter, der hver node kan ha null eller flere underordnede noder.

Fordeler:

    Hierarkisk struktur:Trær gir en naturlig måte å representere hierarkiske relasjoner, for eksempel filsystemer, organisasjonskart eller HTML/XML-dokumenter.Effektivt søk:Binære søketrær muliggjør effektivt søk med en tidskompleksitet på O(log n), noe som gjør dem egnet for å lagre og hente sorterte data.Rask innsetting og sletting:Tredatastrukturer tilbyr effektive innsettings- og slettingsoperasjoner, spesielt når de er balanserte, for eksempel AVL-trær eller rød-svarte trær.Bestilt iterasjon:Gjennomgang i rekkefølge av et binært søketre gir elementer i en sortert rekkefølge, noe som er nyttig for oppgaver som å skrive ut elementer i sortert rekkefølge eller finne neste/forrige element.

Ulemper:

    Høyt minne overhead:Trær krever ekstra minne for å lagre nodereferanser eller pekere, noe som kan resultere i høyere minnebruk sammenlignet med lineære datastrukturer som matriser eller lister.Kompleks implementering:Implementering og vedlikehold av en tredatastruktur kan være mer kompleks sammenlignet med andre datastrukturer som matriser eller lister, spesielt for balanserte trevarianter.Begrenset drift:Noen trevarianter, som binære søketrær, støtter ikke effektive operasjoner som å finne det kth minste elementet eller å finne rangeringen til et element.

Funksjoner:

    Innsetting:Legg til en ny node i treet.Sletting:Fjern en node fra treet.Søk:Finn en bestemt node eller element i treet.Traversering:Gå gjennom treet i forskjellige rekkefølger, for eksempel i rekkefølge, forhåndsbestilling eller etterbestilling.Høyde/dybde:Beregn høyden eller dybden på treet.Balansere:Sørg for at treet forblir balansert for å opprettholde effektiv drift.

Gjennomføring:

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