logo

Adatszerkezetek Java nyelven

Az adatok számítógépes programon belüli elrendezésének, mentésének és kezelésének számos módját a Java adatstruktúráknak nevezik. Ezek a struktúrák módszeres módszert kínálnak az adatok hatékony kezelésére és kezelésére, lehetővé téve az olyan hasznos műveleteket, mint a beillesztés, törlés, visszakeresés és bejárás.

A cikk mindent megvizsgál, ami a Java adatstruktúráival kapcsolatos, és segít a kezdőknek az egyszerű és hatékony megértéshez.

  • Mi az a Java?
  • Mik azok az adatstruktúrák a Java-ban?
  • A Java adatstruktúráinak típusai
  • A Java adatstruktúráinak előnyei
  • Adatstruktúrák osztályozása
  • Adatstruktúrák a Java-ban – GYIK

Mi az a Java?

A Java egy népszerű objektum-orientált programozási nyelv, amely hatalmas szabványos könyvtáráról és platformszabadságáról ismert. Szilárd architektúrát kínál a különféle platformokon történő újrafordítás nélkül futó programok létrehozásához. A jól ismert Java-könyvtár olyan rekordrendszereket kínál, amelyek lehetővé teszik számos adattípus hatékony kezelését.

Mik azok az adatstruktúrák a Java-ban?

Az adatok rendszerezése és tárolása a számítógépes program memóriájában szorosan a Java rekordstruktúrákon múlik. A Java jól ismert könyvtára jelentős típusú beépített statisztikai struktúrákat tartalmaz. Néhány olyan nyilvántartási rendszer, amely lehetővé teszi a programozók számára, hogy rövid és egyszerű módokat menthessenek el és rendezzenek el adatokat, például összekapcsolt listák, veremek, sorok és tömbök. A fejlesztők gyorsan végrehajthatnak olyan műveleteket, mint a beszúrás, törlés, keresés és rendezés, mivel számos mechanizmust biztosítanak az adatokhoz való hozzáféréshez, azok módosításához és kezeléséhez. A Java programozók csökkenthetik a memóriahasználatot és jelentősen növelhetik programjaik általános hatékonyságát ezen adatstruktúrák használatával.

A Java adatstruktúráinak típusai

Az alábbiakban felsoroljuk a Java adatstruktúrák listáját

  1. Tömbök
  2. Tömb lista
  3. LinkedList
  4. Kazal
  5. Sor
  6. HashMap
  7. HashSet
  8. TreeSet
  9. TreeMap
  10. Grafikon
  11. Fa

Az alábbi diagram egyértelműen elmagyarázza a Java adatstruktúráinak típusait.

Adatszerkezetek Java nyelven

Az adatstruktúrák típusainak további osztályozása:

Kétféle adatszerkezet létezik: -

  1. Primitív adatszerkezetek
  2. Nem primitív adatszerkezetek

1) Primitív adatstruktúrák: Primitív adattípusoknak is nevezik, ezek a Java alapvető beépített adattípusai. Tartalmazzák:

    Byte:Egész számokat tárol -128 és 127 között.rövid:Egész számokat tárol -32 768 és 32 767 között.int:Egész számokat tárol -2 147 483 648 és 2 147 483 647 között.úszó:A lebegőpontos számokat egyetlen pontossággal tárolja.char:Egyedi karaktereket tárol.logikai érték:Igaz vagy hamis értékeket tárol.hosszú:Nagy egész számokat tárol.Kettős:Dupla pontossággal tárolja a lebegőtényezős számokat.

2) Nem primitív adatstruktúrák: A nem primitív rekordstruktúrák összetettebbek, és primitív információtípusokból állnak. Ezenkívül két típusba sorolhatók:

    Lineáris adatstruktúrák:A lineáris adatstruktúrákban az elemek lineárisan vagy szekvenciálisan vannak elrendezve. Példák:
      Tömbök:Azonos típusú elemek egy csoportja, amelyek egy tömbbe vannak elhelyezve egy előre meghatározott elrendezés szerint.Stackek:A Last-In-First-Out (LIFO) struktúra, amelyben csak a legfelső elemeket lehet hozzáadni vagy eltávolítani.Frakk:A FIFO (First-In-First-Out) struktúrák a sorokban használatosak, ahol a tételeket a visszaküldött és az elülső oldalon veszik ki.Linkelt lista:A kapcsolódó lista csomópontoknak nevezett modulok gyűjteményét tartalmazza, amelyek mindegyike hivatkozik az utána lévő csomópontra és a benne lévő statisztikákra.
    Nemlineáris adatstruktúrák:A nemlineáris adatstruktúrákban az elemek nem szekvenciálisan vannak elrendezve. Példák:
      Fák:A fák egyfajta csomópont-alapú hierarchikus struktúra, tetején egy gyökércsomóponttal, és abból ágaznak ki a gyermek csomópontok. Ilyenek például a vörös-fekete fák, az AVL-fák, a bináris keresési fák és a bináris fák.Grafikonok:Élekkel összekapcsolt csomópontok halmaza, ahol a csomópontok tetszőleges mennyiségű kapcsolattal rendelkezhetnek. A grafikonokat az elemek közötti összetett kapcsolatok szimbolizálására használják.Halom:Speciális fa alapú struktúra, amelyben minden meghatározott csomópont értéke nagyobb vagy kisebb, mint a gyerekei, attól függően, hogy max kupacról vagy minimális kupacról van-e szó.Hash:Olyan adatstruktúrák, amelyek hash függvényt használnak a kulcsok értékekhez való hozzárendeléséhez. A példák közé tartoznak a hash készletek és a hash térképek, amelyek zöld lekérdezést és statisztikai adatok tárolását biztosítják precíz kulcsok alapján.
Adatszerkezetek Java nyelven

A Java adatstruktúráinak előnyei

    Hatékony adatszervezés:Az adatstruktúrák szervezett módokat biztosítanak az adatok tárolására és kezelésére, lehetővé téve a hatékony hozzáférési, kezelési és visszakeresési műveleteket. Optimalizálják a memóriahasználatot és megkönnyítik az algoritmusok gyorsabb végrehajtását.Jobb teljesítmény:A fejlesztők javíthatják a teljesítményt a sebesség és a memória kihasználtság tekintetében, ha kiválasztják az adott tevékenységhez megfelelő adatstruktúrát. A teljesítmény optimalizált, mivel meghatározott adatstruktúrák kiválóan alkalmasak bizonyos műveletekre, például keresésre, rendezésre vagy információk beszúrására.A kód újrafelhasználhatósága:A Java a beépített adatstruktúrák széles skáláját kínálja, amelyek használata egyszerű a programozók számára. Ezek az újrafelhasználható adatstruktúrák időt és erőfeszítést takarítanak meg, mivel nincs szükség kifinomult algoritmusok létrehozására a semmiből.A kód egyszerűsége:Az adatstruktúrák egyszerűbbé teszik a bonyolult folyamatok kódolását. Magas szintű absztrakciókat kínálnak, és magukba foglalják az adatkezelés sajátosságait, ami javítja a kód olvashatóságát, karbantarthatóságát és áttekinthetőségét.Rugalmasság és alkalmazkodóképesség:Az adatszerkezetek rugalmasságot kínálnak a különböző típusú és méretű adatok kezelésében. Dinamikusan alkalmazkodhatnak a változó adatigényekhez, és mechanizmusokat biztosítanak a hatékony adatkezeléshez.Szabványosított és jól tesztelt:A Java szabványos könyvtára olyan beépített adatstruktúrákat tartalmaz, amelyek jelentős tesztelésen és optimalizálásán estek át, garantálva megbízhatóságukat és teljesítményüket. Ezeknek a közös adatstruktúráknak a használata csökkenti a hibák lehetőségét, és szilárd alapot biztosít az alkalmazásfejlesztéshez.Méretezhetőség:Az adatstruktúrák méretezhetőséget biztosítanak, lehetővé téve az alkalmazások számára, hogy hatékonyan kezeljenek nagy mennyiségű adatot. Dinamikusan növekedhetnek vagy csökkenhetnek az adatméret alapján, így biztosítva az optimális teljesítményt a növekvő adatigények mellett is.Algoritmus tervezés:Az adatszerkezetek kulcsfontosságúak az algoritmusok tervezésében és elemzésében. Ezek biztosítják a különböző algoritmusok megvalósításához és összetett problémák megoldásához szükséges mögöttes struktúrát és műveleteket.

1) Tömbök:

A tömb egy alapvető és gyakran használt adatstruktúra a Java adatstruktúráival összefüggésben. Egy módszert kínál az azonos típusú alkatrészek rögzített méretű gyűjteményének tárolására. Mivel indexüktől függően gyors és egyszerű hozzáférést biztosítanak az elemekhez, a tömbök kulcsfontosságú eszközt jelentenek az adatok kezeléséhez és rendszerezéséhez.

Előnyök:

    Adatszervezés:A tömbök strukturált módot biztosítanak az elemek tárolására és rendszerezésére, javítva az adatkezelést.Véletlen hozzáférés:Az elemek közvetlenül elérhetők indexük segítségével, ami lehetővé teszi a hatékony visszakeresést és módosítást.Fix méret:A tömbök előre meghatározott méretűek, lehetővé téve a hatékony memóriafoglalást.Homogén elemek:A tömbök azonos típusú elemeket tárolnak, biztosítva az adatok konzisztenciáját és leegyszerűsítve a műveleteket.Ismétlés:A tömbök támogatják az elemek egyszerű iterációját, megkönnyítve a bejárást és a feldolgozást.Rendezés és keresés:A tömbök jól működnek a rendezési és keresési algoritmusokkal, és hatékony műveleteket kínálnak.Memória hatékonyság:A tömbök optimalizálják a memóriahasználatot azáltal, hogy az elemeket összefüggő régiókban tárolják.Kompatibilitás:A Java széles körben támogatja a tömböket, így kompatibilisek különféle keretrendszerekkel és eszközökkel.

Hátrányok:

    Fix méret:A tömböket nem lehet dinamikusan átméretezni, ezért a méret módosításához újra kell alkotni.Memória pazarlás:A nagyobb tömbök nem használt elemei memóriaveszteséghez vezethetnek.Beszúrási és törlési költség:Az elemek beszúrása vagy törlése egy tömb közepén megköveteli a következő elemek eltolását, ami hatástalanságot eredményez.Rugalmasság hiánya:A tömbök merev adattípusokkal rendelkeznek, és nem fogadhatnak el különböző típusú adatokat további tömbök vagy adatstruktúrák nélkül.

Funkciók:

    Tömb létrehozása:Adott méretű tömb deklarálása és inicializálása a tömbtípus és az új kulcsszó használatával.Elemek elérése:Használja az indexet a tömb egyes elemeinek eléréséhez.Elemek módosítása:Frissítse egy elem értékét úgy, hogy új értéket rendel egy adott indexhez a tömbben.Keresési hossz:Használja a length attribútumot a tömb hosszának meghatározásához.Iteráció a tömbön keresztül:Használjon hurkokat a tömb egyes elemeinek áthaladásához és végrehajtásához

Végrehajtás:

Fájl név: 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:

A Java ArrayList egy dinamikus adatstruktúra, amely lehetővé teszi az elemek tárolását és kezelését. A Java Collections Framework része, és belső tömb segítségével valósítják meg.

Előnyök:

    Dinamikus méret:A tömbökkel ellentétben az ArrayLists mérete dinamikusan nőhet vagy csökkenhet az elemek hozzáadásával vagy eltávolításával. Kiküszöböli a kézi átméretezés szükségességét, és lehetővé teszi a változó mennyiségű adat kényelmes kezelését.Egyszerű elemkezelés:Az ArrayLists módszereket kínál az elemek hozzáadására, eltávolítására és módosítására a lista bármely pontján. Rugalmassága leegyszerűsíti az olyan általános műveleteket, mint a beszúrás, törlés és frissítés, így hatékonyabbá válik az elemkezelés.Véletlen hozzáférés:Az ArrayLists támogatják az elemekhez való véletlenszerű hozzáférést az indexük segítségével, lehetővé téve az elemek gyors visszakeresését és módosítását a lista meghatározott helyein. Megkönnyíti az elemek hatékony elérését és javítja az általános teljesítményt.Kompatibilitás a Java Collection Framework-el:Az ArrayLists megvalósítja a List felületet, így kompatibilisek a Java Collections Framework más Collection osztályaival. Kompatibilitása lehetővé teszi a zökkenőmentes integrációt a keretrendszer által biztosított különféle algoritmusokkal és műveletekkel.

Hátrányok:

    Nagyobb memória többlet:A tömblistáknak további memóriára van szükségük a belső szerkezetük fenntartásához, ami a tömbökhöz képest nagyobb memóriaterhelést eredményez. Ez aggodalomra ad okot nagy elemgyűjtemények kezelésekor.Lassabb beillesztés és törlés:Elemek beszúrása vagy törlése egy ArrayList közepén elemek eltolását igényli, ami nagy listák esetén időigényes lehet. Olyan esetekben, amikor gyakori beszúrási vagy törlési műveletek várhatók, más adatstruktúrák, például a LinkedList jobb teljesítményt nyújthatnak.Korlátozott teljesítmény a kereséshez:Ha egy elemet nem rendezett ArrayList-ben szeretne keresni, addig ismételni kell az elemeket, amíg egyezést nem talál. Ez egy lineáris keresési megközelítés, amely lassabb keresési teljesítményt eredményez a keresésre optimalizált adatstruktúrákhoz képest, mint például a HashSet vagy a TreeMap.Nincs primitív típus támogatás:Az ArrayLists csak objektumokat tárolhat, és nem támogat közvetlenül olyan primitív adattípusokat, mint az int vagy a char. A primitív típusok tárolásához olyan burkolóosztályokat kell használni, mint az Integer vagy Character, ami potenciálisan automatikus dobozoláshoz és kicsomagoláshoz vezet.

Funkciók:

iphone hangulatjelek androidon
    ArrayList létrehozása:Deklaráljon és inicializáljon egy ArrayList-et az ArrayList osztály használatával, és adja meg az elem típusát a szögletes zárójelben.Elemek hozzáadása:Használja az add metódust az elemek hozzáfűzéséhez az ArrayList végére.Elemek elérése:Használja a get technikát a részletek árának lekéréséhez egy kiválasztott indexnél.Elemek módosítása:Frissítse a részletek költségét egy adott indexen a beállított megközelítés használatához.Találat mérete:Használja a dimenziós módszert az ArrayList faktorainak élvonalbeli mennyiségének lekéréséhez.Elemek eltávolítása:Használja az eltávolítási megközelítést egy részlet törléséhez egy adott indexben vagy az objektumhivatkozás megadásával.Iteráció az ArrayList-en keresztül:Használjon hurkokat az ArrayList egyes elemei közötti iterációhoz és műveletek végrehajtásához.

Végrehajtás:

Fájl név: 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); } } } 

Kimenet:

 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) Linkelt lista:

A linkelt lista egy lineáris adatstruktúra, amelyben az elemeket külön objektumok, úgynevezett csomópontok tárolják. A sorozat következő csomópontjára mutató hivatkozási hivatkozás minden csomópont adatelemében szerepel. A lista utolsó csomópontja nullra hivatkozik, jelezve, hogy a lista véget ért.

A tömbökkel ellentétben a csatolt listák nem igényelnek folyamatos memóriafoglalást. A csatolt lista minden csomópontja egymástól függetlenül allokálható, ami lehetővé teszi a dinamikus memóriafoglalást, valamint a hatékony beillesztési és törlési műveleteket.

Előnyök:

    Dinamikus méret:A LinkedList dinamikusan növekedhet vagy csökkenhet, így alkalmas változó vagy ismeretlen adatméretekre.Hatékony beszúrás és törlés:A LinkedList-en belüli elemek beszúrása vagy törlése hatékony, mivel nem igényel elemeket eltolni.Nincs összefüggő memóriaigény:A LinkedList nem igényel folyamatos memóriafoglalást, így rugalmas és alkalmas a kiszámíthatatlan memóriahelyzetekre.Könnyű módosítás:A LinkedList lehetővé teszi az elemek egyszerű módosítását a referenciamutatók megváltoztatásával, lehetővé téve a hatékony manipulációt.

Hátrányok:

    Lassabb véletlenszerű hozzáférés:A LinkedList lassabb véletlenszerű hozzáféréssel rendelkezik, mivel az elemek index szerinti eléréséhez a lista bejárása szükséges.Megnövekedett memóriaterhelés:A LinkedList további memóriát igényel a hivatkozásokhoz és csomópontokhoz, ami növeli a memória többletterhelését a tömbökhöz képest.Nem hatékony keresés:A LinkedList lassabb keresési műveletekkel rendelkezik, és szekvenciális iterációt igényel bizonyos elemek megtalálásához.

Funkciók:

    LinkedList létrehozása:LinkedList deklarálása és inicializálása a LinkedList osztály használatával.Elemek hozzáadása:Használja az add metódust az elemek hozzáfűzéséhez a LinkedList végéhez.Elemek elérése:Használja a get metódust egy adott indexen lévő elem értékének lekéréséhez.Elemek módosítása:Frissítse egy elem értékét egy adott indexen a set módszerrel.Elemek eltávolítása:Az eltávolítási módszerrel törölhet egy elemet egy adott indexből, vagy az objektumhivatkozás megadásával.

Végrehajtás:

Fájl név: 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); } } 

Kimenet:

java számot karakterláncra
 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) Verem:

A Last-In-First-Out (LIFO) elv azt diktálja, hogy a legutóbb beszúrt elem legyen az elsőként eltávolított elem is. A verem egy lineáris adatstruktúra, amely követi ezt a szabályt. A „push” és „pop” parancsokat használja, hogy elemeket adjon a veremhez, és ennek megfelelően távolítsa el a legfelső elemet a veremből. A „peek” technika emellett lehetővé teszi a felső elemhez való hozzáférést annak eltávolítása nélkül.

A verem jellemzői:

    LIFO viselkedés:A veremre utoljára tolt elem az első, amelyik kiugrik, így alkalmas olyan alkalmazásokra, ahol fontos a behelyezés és eltávolítás sorrendje.Korlátozott hozzáférés:A veremek általában korlátozott hozzáférést biztosítanak az elemekhez. Csak a legfelső elemhez férhet hozzá, a többi elem eléréséhez pedig a fölé kell helyeznie az elemeket.Dinamikus méret:A veremek tömbök vagy linkelt listák segítségével valósíthatók meg, lehetővé téve a dinamikus méretet. Futás közben szükség szerint növekedhetnek vagy zsugorodhatnak.

Előnyök:

    Egyszerűség:A halmokat könnyű megérteni és megvalósítani.Hatékonyság:A beillesztési és törlési műveletek időbeli összetettsége O(1).Funkcióhíváskezelés:A veremek hatékonyan kezelik a függvényhívásokat és a változótárolást.Visszavonás/Újra funkció:A veremek lehetővé teszik a visszavonási és újbóli műveleteket az alkalmazásokban.

Hátrányok:

    Korlátozott hozzáférés:Az elemekhez való hozzáférés a verem tetejére korlátozódik.Méretkorlátozások:A veremek méretkorlátozással rendelkezhetnek a megvalósítástól függően.Nem minden forgatókönyvre alkalmas:A veremek a LIFO viselkedésére jellemzőek, és előfordulhat, hogy más esetekben nem megfelelőek.

Végrehajtás:

Fájl név: 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); } } } 

Kimenet:

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

5) Sor:

A sor egy lineáris adatstruktúra a Java nyelvben, amely a FIFO (First-In-First-Out) elvet követi. Olyan elemek gyűjteményét képviseli, ahol az elemeket hátul helyezik be, és elölről eltávolítják.

Jellemzők:

    Sorba állás:Elem hozzáadása a sor hátuljához.Sorból:Elem eltávolítása a sor elejéről.Kandikál:A sor elején található elem lekérése anélkül, hogy eltávolítaná.Méret:A sorban lévő elemek számának meghatározása.Üres csekk:Ellenőrzi, hogy a sor üres-e.

Előnyök:

    FIFO viselkedés:Az elemek feldolgozása beillesztésük sorrendjében történik, biztosítva az eredeti sorrend megőrzését.Hatékony behelyezés és eltávolítás:Az elemek hozzáadása és eltávolítása a sorból gyors, és állandó időbonyolultsága O(1).Szinkronizálás:A Java szinkronizált sormegvalósításokat biztosít, így biztonságossá teszi őket a párhuzamos programozáshoz.Szabványosított interfész:A Java Queue felülete közös metóduskészletet kínál, lehetővé téve a különböző várólista-megvalósítások közötti egyszerű felcserélhetőséget.

Hátrányok:

    Nincs véletlenszerű hozzáférés:A sorok nem támogatják a középső elemekhez való közvetlen hozzáférést. Adott pozíciókhoz való hozzáférés megköveteli az előző elemek sorból történő eltávolítását.Korlátozott méret:Egyes várólista-megvalósítások fix méretűek vagy kapacitással rendelkeznek, ami túlcsorduláshoz vagy kivételekhez vezet a maximális méret túllépése esetén.Nem hatékony keresés:Egy elem keresése a sorban megköveteli a sorból való felállást, amíg egyezést nem talál, ami lineáris keresést eredményez, potenciálisan nagy időbonyolítással.

Végrehajtás:

Fájl név: 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); } } } 

Kimenet:

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

6) HashMap:

A HashMap egy olyan Java adatstruktúra, amely lehetőséget biztosít kulcs-érték párok tárolására és lekérésére. A Java Collections Framework része, és a hash tábla adatszerkezetén alapul.

Funkciók:

    put(kulcs, érték):Beszúrja a megadott kulcs-érték párt a HashMap-be.get (kulcs):Lekéri a megadott kulcshoz tartozó értéket.tartalmazzaKulcs(kulcs):Ellenőrzi, hogy a HashMap tartalmazza-e a megadott kulcsot.tartalmazzaÉrték(érték):Ellenőrzi, hogy a HashMap tartalmazza-e a megadott értéket.eltávolítás (kulcs):Eltávolítja a megadott kulccsal társított kulcs-érték párt a HashMap-ről.méret():A HashMap kulcs-érték párjainak számát adja vissza.üres():Ellenőrzi, hogy a HashMap üres-e.keySet():A HashMap összes kulcsát tartalmazó készletet ad vissza.értékek():Egy gyűjteményt ad vissza, amely tartalmazza a HashMap összes értékét.egyértelmű():Eltávolítja az összes kulcs-érték párt a HashMap-ről.

Előnyök:

    Hatékony visszakeresés:A HashMap az értékek gyors lekérését biztosítja az állandó idejű O(1) összetettségű kulcsok alapján.Rugalmas kulcs-érték párosítás:A HashMap bármilyen nem null objektumot engedélyez kulcsként, lehetővé téve az egyénileg definiált kulcsokat az adatok tárolására és lekérésére.Dinamikus méret:A HashMap mérete dinamikusan nőhet vagy csökkenhet, hogy kezelje a változó mennyiségű adatot.Kompatibilitás a Java Collections Framework-el:A HashMap megvalósítja a Map felületet, lehetővé téve a zökkenőmentes integrációt más Collection osztályokkal.

Hátrányok:

    Megrendelés hiánya:A HashMap nem őrzi meg az elemek sorrendjét. Használja a LinkedHashMap-et vagy a TreeMap-et bizonyos rendelési követelményekhez.Megnövekedett memóriaterhelés:A HashMap több memóriát igényel a hash kódokhoz és a belső struktúrához az egyszerűbb adatstruktúrákhoz képest.Lassabb iteráció:A HashMap feletti iteráció lassabb lehet a tömbökhöz vagy listákhoz képest az alapul szolgáló hash-tábla bejárása miatt.

Végrehajtás:

Fájl név: 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()); } } 

Kimenet:

 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:

A HashSet egy Java adatstruktúra, amely megvalósítja a Set felületet, és az elemeket egy hash táblában tárolja.

Jellemzők:

    Egyedi elemeket tárol:A HashSet nem engedélyezi az elemek ismétlődését. A HashSet minden eleme egyedi.Hash-alapú keresést használ:A HashSet az egyes elemek hash értékét használja a tárolási hely meghatározásához, így hatékony elemlekérést biztosít.Rendeletlen gyűjtemény:A HashSet elemei nincsenek meghatározott sorrendben tárolva. Az elemek sorrendje idővel változhat.

Előnyök:

    Gyors elemkeresés:A HashSet gyors keresési műveleteket biztosít, így hatékonyan ellenőrizhető, hogy létezik-e elem a halmazban.Nincsenek ismétlődő elemek:A HashSet automatikusan kezeli az ismétlődő elemeket, és biztosítja, hogy minden elem egyedi legyen.Integráció a Java Collections Framework-el:A HashSet megvalósítja a Set felületet, így kompatibilis a Java Collections Framework más gyűjteményosztályaival.

Hátrányok:

absztrakt módszerek
    Nincs garantált rendelés:A HashSet nem tartja fenn az elemek sorrendjét. Ha fontos az elemek sorrendje, a HashSet nem megfelelő.Nincs indexelés:A HashSet nem biztosít közvetlen indexelést vagy pozíciós hozzáférést az elemekhez. Az elemek eléréséhez ismételni kell a halmazon.Magasabb memória:A HashSet további memóriát igényel a hash értékek tárolásához és a hash tábla szerkezetének fenntartásához, ami magasabb memóriahasználatot eredményez néhány más adatszerkezethez képest.

Végrehajtás:

Fájl név: 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()); } } 

Kimenet:

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

A TreeSet a SortedSet interfész Java-ban való megvalósítása, amely egy önkiegyensúlyozó bináris keresési fát használ, amelyet vörös-fekete fának neveznek az elemek rendezett sorrendben való tárolására.

Előnyök:

    Rendezett sorrend:A TreeSet automatikusan rendezi az elemeket a természetes sorrend vagy egy egyéni összehasonlító alapján. Lehetővé teszi az elemek növekvő vagy csökkenő sorrendben történő hatékony keresését és visszakeresését.Nincsenek ismétlődő elemek:A TreeSet nem engedélyezi az elemek ismétlődését. Biztosítja, hogy a készlet minden eleme egyedi legyen, ami hasznos lehet olyan forgatókönyvekben, ahol kerülni kell az értékek ismétlődését.Hatékony műveletek:A TreeSet olyan hatékony műveleteket biztosít, mint a beillesztés, törlés és keresés. Ezeknek a műveleteknek az időbonyolultsága O(log n), ahol n a halmaz elemeinek száma.Navigálható készlet műveletei:A TreeSet további navigációs módszereket biztosít, mint például a high(), az alsó(), a plafon() és a floor(), amelyek lehetővé teszik egy adott értéknél nagyobb, kisebb vagy azzal egyenlő elemek megtalálását.

Hátrányok:

0,04 törtként
    Felső:A TreeSet további memóriát igényel a belső adatstruktúra tárolásához, ami a többi készletmegvalósításhoz képest nagyobb memóriaterheléshez vezethet.Lassabb behelyezés és eltávolítás:A TreeSet beillesztési és eltávolítási műveletei az elemek rendezett sorrendjének fenntartását foglalják magukban, ami a fa szerkezetének átalakítását teheti szükségessé. Valamivel lelassíthatja ezeket a műveleteket a HashSethez vagy a LinkedHashSethez képest.Korlátozott testreszabás:A TreeSet elsősorban természetes rendezésre vagy egyetlen egyéni összehasonlításra készült. Több rendezési feltételhez vagy összetett rendezési logikához nagyobb rugalmasságra lehet szükség.

Funkciók:

    add(elem):Hozzáad egy elemet a TreeSethez, miközben megtartja a rendezett sorrendet.eltávolítás(elem):Eltávolítja a megadott elemet a TreeSet-ből.(elemet) tartalmaz:Ellenőrzi, hogy a TreeSet tartalmazza-e a megadott elemet.méret():A TreeSet elemeinek számát adja vissza.első():A TreeSet első (legalacsonyabb) elemét adja vissza.utolsó():A TreeSet utolsó (legmagasabb) elemét adja vissza.magasabb(elem):A TreeSet legkisebb elemét adja vissza, amely szigorúan nagyobb, mint az adott elem.alsó(elem):A TreeSet legnagyobb elemét adja vissza, amely szigorúan kisebb, mint az adott elem.

Végrehajtás:

Fájl név: 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); } } } 

Kimenet:

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

A TreeMap egy olyan Java osztály, amely megvalósítja a Map felületet, és rendezett kulcsérték-leképezést biztosít a kulcsok természetes sorrendje vagy egy egyéni összehasonlító alapján.

Előnyök:

    Rendezési sorrend:A TreeMap a kulcsokat rendezett sorrendben tartja, ami lehetővé teszi a hatékony keresést, visszakeresést és tartományalapú műveleteket.Kulcsérték-leképezés:A TreeMap kulcs-érték párokat tárol, lehetővé téve az értékek hatékony keresését és visszakeresését a kapcsolódó kulcsok alapján.Piros-fekete fa megvalósítás:A TreeMap belsőleg kiegyensúlyozott bináris keresési fát (Red-Black Tree) használ, amely még nagy adatkészletek esetén is hatékony teljesítményt biztosít.Egyéni összehasonlítók támogatása:A TreeMap lehetővé teszi egyéni összehasonlítók használatát a kulcsok rendezési sorrendjének meghatározásához, rugalmasságot biztosítva a rendezési feltételekben.

Hátrányok:

    Memória felett:A TreeMap további memóriát igényel a belső fastruktúra és a kapcsolódó objektumok tárolásához, ami magasabb memóriahasználatot eredményez, mint az egyszerűbb adatstruktúrák, például a HashMap.Lassabb beillesztés és törlés:A TreeMap beszúrási és törlési műveleteinek időbeli összetettsége O(log n) a fa átstrukturálásának szükségessége miatt, ami lassabb a HashMaphez vagy a LinkedHashMaphez képest.Korlátozott teljesítmény a rendezetlen adatokhoz:A TreeMap hatékonyan teljesít a rendezett adatok esetében, de teljesítménye romolhat, ha nem rendezett adatokkal vagy gyakori módosításokkal foglalkozik, mivel megköveteli a rendezett sorrend fenntartását.

Funkciók:

    put(kulcs, érték):Kulcs-érték párt szúr be a TreeMapbe.get (kulcs):Lekéri a megadott kulcshoz tartozó értéket.tartalmazzaKulcs(kulcs):Ellenőrzi, hogy a TreeMap tartalmaz-e egy adott kulcsot.eltávolítás (kulcs):Eltávolítja a megadott kulccsal társított kulcs-érték párt.méret():A TreeMap kulcs-érték párjainak számát adja vissza.keySet():A TreeMap összes kulcsát adja vissza.értékek():A TreeMap összes értékének gyűjteményét adja vissza.entrySet():A TreeMap kulcs-érték párjainak készletét adja vissza.

Végrehajtás:

Fájl név: 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); } } } 

Kimenet:

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

A grafikonok olyan adatszerkezetek, amelyek összekapcsolt csomópontok vagy csúcsok gyűjteményét reprezentálják. Csúcsokból és élekből állnak, ahol a csúcsok entitásokat, az élek pedig az entitások közötti kapcsolatokat képviselik.

Előnyök:

    Sokoldalúság:A grafikonok a valós forgatókönyvek széles skáláját képviselhetik, így alkalmasak különféle alkalmazásokhoz, például közösségi hálózatokhoz, közlekedési rendszerekhez és számítógépes hálózatokhoz.Kapcsolatok képviselete:A grafikonok természetes módot biztosítanak az entitások közötti kapcsolatok és kapcsolatok ábrázolására, lehetővé téve e kapcsolatok hatékony elemzését és bejárását.Hatékony keresés és bejárás:A gráfalgoritmusok, mint például a szélesség-első keresés (BFS) és a mélység-első keresés (DFS) lehetővé teszik a gráf csúcsainak és éleinek hatékony bejárását és keresését.Komplex kapcsolatok modellezése:A grafikonok összetett kapcsolatokat tudnak modellezni, beleértve a hierarchikus struktúrákat, a ciklikus függőségeket és az entitások közötti többszörös kapcsolatokat.

Hátrányok:

    A tér összetettsége:A grafikonok jelentős mennyiségű memóriát fogyaszthatnak, különösen a nagyméretű, sok csúcsot és élt tartalmazó gráfok.A műveletek összetettsége:Bizonyos gráfműveletek, mint például a legrövidebb út megkeresése vagy a ciklusok detektálása, nagyon bonyolultak lehetnek az időben, különösen sűrű gráfokban.Karbantartási nehézségek:A gráf módosítása vagy frissítése bonyolult lehet, mivel a gráf szerkezetében bekövetkezett változások hatással lehetnek a kapcsolatra és a meglévő algoritmusokra.

Végrehajtás:

Fájl név: 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) Fa:

A fa a számítástechnikában széles körben használt adatstruktúra, amely hierarchikus struktúrát képvisel. Élekkel összekapcsolt csomópontokból áll, ahol minden csomópontnak nulla vagy több gyermekcsomópontja lehet.

Előnyök:

    Hierarchikus struktúra:A fák természetes módot biztosítanak a hierarchikus kapcsolatok, például fájlrendszerek, szervezeti diagramok vagy HTML/XML dokumentumok ábrázolására.Hatékony keresés:A bináris keresőfák hatékony keresést tesznek lehetővé O(log n) időbonyolítás mellett, így alkalmasak rendezett adatok tárolására és visszakeresésére.Gyors beillesztés és törlés:A fa adatstruktúrák hatékony beszúrási és törlési műveleteket kínálnak, különösen akkor, ha kiegyensúlyozottak, például AVL fák vagy vörös-fekete fák.Rendezett iteráció:A bináris keresési fa sorrendben történő bejárása rendezett sorrendben adja meg az elemeket, ami hasznos lehet például az elemek rendezett sorrendben történő nyomtatásához vagy a következő/előző elem megkereséséhez.

Hátrányok:

    Magas memória többlet:A fák további memóriát igényelnek a csomóponthivatkozások vagy mutatók tárolására, ami magasabb memóriahasználatot eredményezhet, mint a lineáris adatstruktúrák, például a tömbök vagy listák.Komplex megvalósítás:A fa adatstruktúra megvalósítása és karbantartása bonyolultabb lehet más adatstruktúrákhoz, például tömbökhöz vagy listákhoz képest, különösen a kiegyensúlyozott faváltozatok esetében.Korlátozott működés:Egyes faváltozatok, például a bináris keresési fák, nem támogatják a hatékony műveleteket, például a k-adik legkisebb elem megtalálását vagy egy elem rangjának megállapítását.

Funkciók:

    Beillesztés:Adjon hozzá egy új csomópontot a fához.Törlés:Távolítson el egy csomópontot a fából.Keresés:Keressen egy adott csomópontot vagy elemet a fában.Bejárás:Haladjon át a fán különböző sorrendben, például rendelésben, előrendelésben vagy utórendelésben.Magasság/mélység:Számítsa ki a fa magasságát vagy mélységét.Egyensúly:Győződjön meg arról, hogy a fa kiegyensúlyozott marad a hatékony működés fenntartásához.

Végrehajtás:

Fájl név: 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)>