logo

Dátové štruktúry v Jave

Množstvo spôsobov, ako môžu byť dáta usporiadané, ukladané a spracovávané v rámci počítačového programu, sa v jazyku Java nazývajú dátové štruktúry. Tieto štruktúry ponúkajú metodickú metódu na efektívne zaobchádzanie s údajmi a ich správu a umožňujú užitočné operácie, ako je vkladanie, mazanie, vyhľadávanie a prechod.

Článok preskúma všetko, čo súvisí s dátovými štruktúrami v Jave, a pomáha začiatočníkom ľahko a efektívne porozumieť.

  • Čo je Java?
  • Čo sú dátové štruktúry v jazyku Java?
  • Typy dátových štruktúr v Jave
  • Výhody dátových štruktúr v Jave
  • Klasifikácia dátových štruktúr
  • Časté otázky o dátových štruktúrach v jazyku Java

Čo je Java?

Java je populárny objektovo orientovaný programovací jazyk známy svojou rozsiahlou štandardnou knižnicou a voľnosťou platformy. Ponúka solídnu architektúru na vytváranie programov bežiacich bez rekompilácie na rôznych platformách. Známa knižnica pre Java má na výber systémy záznamov, ktoré umožňujú efektívne zaobchádzať s mnohými typmi údajov.

Čo sú dátové štruktúry v jazyku Java?

Spôsob, akým sú údaje organizované a uložené v pamäti počítačového programu, úzko závisí od štruktúry záznamov Java. Známa knižnica Java obsahuje významný typ vstavaných štatistických štruktúr. Niekoľko záznamových systémov, ktoré umožňujú programátorom krátke a jednoduché spôsoby ukladania a usporiadania údajov, zahŕňa prepojené zoznamy, zásobníky, fronty a polia. Vývojári môžu rýchlo vykonávať operácie, ako je vkladanie, mazanie, vyhľadávanie a triedenie, pretože poskytujú celý rad mechanizmov na získanie prístupu k údajom, ich zmenu a správu. Java programátori môžu pomocou týchto dátových štruktúr znížiť využitie pamäte a výrazne zvýšiť celkovú efektivitu svojich programov.

Typy dátových štruktúr v Jave

Zoznam dátových štruktúr v jazyku Java je uvedený nižšie

  1. Polia
  2. ArrayList
  3. LinkedList
  4. Stoh
  5. Fronta
  6. HashMap
  7. HashSet
  8. TreeSet
  9. Stromová mapa
  10. Graf
  11. Strom

Nižšie uvedený diagram jasne vysvetľuje typy dátových štruktúr v Jave veľmi jasne.

Dátové štruktúry v Jave

Ďalšia klasifikácia typov dátových štruktúr:

Existujú dva typy dátových štruktúr: -

  1. Primitívne dátové štruktúry
  2. Neprimitívne dátové štruktúry

1) Primitívne dátové štruktúry: Tiež známe ako primitívne dátové typy, sú to základné vstavané dátové typy v Jave. Zahŕňajú:

    Bajt:Ukladá celé čísla od -128 do 127.krátky:Ukladá celé čísla od -32 768 do 32 767.int:Ukladá celé čísla od -2 147 483 648 do 2 147 483 647.plavák:Ukladá čísla s pohyblivou rádovou čiarkou s jednoduchou presnosťou.znak:Ukladá jednotlivé postavy.boolean:Ukladá pravdivé alebo nepravdivé hodnoty.dlhý:Ukladá veľké celé čísla.Dvojité:Ukladá čísla s pohyblivým faktorom s dvojnásobnou presnosťou.

2) Neprimitívne dátové štruktúry: Neprimitívne štruktúry záznamov sú zložitejšie a pozostávajú z primitívnych druhov informácií. Okrem toho môžu byť rozdelené do dvoch typov:

    Lineárne dátové štruktúry:V lineárnych dátových štruktúrach sú prvky usporiadané lineárne alebo sekvenčne. Príklady:
      Polia:Skupina prvkov rovnakého typu umiestnených v poli podľa vopred určeného usporiadania.Hromady:Štruktúra Last-In-First-Out (LIFO), v ktorej možno pridať alebo odstrániť iba najvyššie položky.Chvosty:Štruktúry First-In-First-Out (FIFO) sa využívajú v radoch, kde sa položky vkladajú na vrátené a vyberajú sa na prednej strane.Prepojený zoznam:Súvisiaci zoznam obsahuje kolekciu modulov gadget označovaných ako uzly, z ktorých každý má za sebou odkaz na uzol a štatistiku v ňom.
    Nelineárne dátové štruktúry:V nelineárnych dátových štruktúrach sú prvky usporiadané nesekvenčne. Príklady:
      stromy:Stromy sú typom hierarchickej štruktúry založenej na uzloch s koreňovým uzlom na vrchu a podriadenými uzlami, ktoré sa z neho rozvetvujú. Príklady zahŕňajú červeno-čierne stromy, AVL stromy, binárne vyhľadávacie stromy a binárne stromy.Grafy:Množina uzlov spojených pomocou hrán, pričom uzly môžu mať ľubovoľné množstvo spojení. Grafy sa používajú na symbolizáciu zložitých vzťahov medzi položkami.halda:Špecializovaná stromová štruktúra, v ktorej má každý určený uzol hodnotu väčšiu alebo menšiu ako jeho deti, pričom sa spolieha na to, či ide o maximálnu alebo minimálnu haldu.Hash:Dátové štruktúry, ktoré používajú hašovaciu funkciu na mapovanie kľúčov na hodnoty. Príklady pozostávajú z hašovacích sád a hašovacích máp, ktoré poskytujú zelené vyhľadávanie a ukladanie štatistík na základe presných kľúčov.
Dátové štruktúry v Jave

Výhody dátových štruktúr v Jave

    Efektívna organizácia údajov:Dátové štruktúry poskytujú organizované spôsoby ukladania a správy údajov, čo umožňuje efektívny prístup, manipuláciu a operácie získavania. Optimalizujú využitie pamäte a uľahčujú rýchlejšie vykonávanie algoritmov.Lepší výkon:Vývojári môžu zlepšiť výkon z hľadiska rýchlosti a využitia pamäte výberom vhodnej dátovej štruktúry pre konkrétnu aktivitu. Výkon je optimalizovaný, pretože špecifické dátové štruktúry sú vytvorené tak, aby excelovali pri konkrétnych akciách, ako je vyhľadávanie, triedenie alebo vkladanie informácií.Opätovná použiteľnosť kódu:Java ponúka širokú škálu vstavaných dátových štruktúr, ktoré sú pre programátorov jednoduché na používanie. Tieto opätovne použiteľné dátové štruktúry šetria čas a námahu tým, že odstraňujú potrebu vytvárať sofistikované algoritmy od začiatku.Jednoduchosť kódu:Dátové štruktúry zjednodušujú kódovanie implementácie komplikovaných procesov. Ponúkajú abstrakcie na vysokej úrovni a zahŕňajú špecifiká správy údajov, čo zlepšuje čitateľnosť, udržiavateľnosť a prehľadnosť kódu.Flexibilita a prispôsobivosť:Dátové štruktúry ponúkajú flexibilitu pri manipulácii s rôznymi typmi a veľkosťami údajov. Môžu sa dynamicky prispôsobovať meniacim sa požiadavkám na údaje a poskytujú mechanizmy na efektívnu manipuláciu s údajmi.Štandardizované a dobre otestované:Štandardná knižnica pre Java obsahuje vstavané dátové štruktúry, ktoré prešli významným testovaním a optimalizáciou, čo zaručuje ich spoľahlivosť a výkon. Využitie týchto spoločných dátových štruktúr znižuje možnosť chýb a dáva vývoju aplikácií pevný základ.Škálovateľnosť:Dátové štruktúry poskytujú možnosti škálovateľnosti a umožňujú aplikáciám efektívne spracovávať veľké objemy údajov. Môžu sa dynamicky zväčšovať alebo zmenšovať na základe veľkosti údajov, čím zaisťujú optimálny výkon aj pri zvyšujúcich sa nárokoch na údaje.Návrh algoritmu:Dátové štruktúry sú kľúčové pri návrhu a analýze algoritmov. Poskytujú základnú štruktúru a operácie potrebné na implementáciu rôznych algoritmov a riešenie zložitých problémov.

1) Polia:

Pole je základná a často používaná dátová štruktúra v kontexte dátových štruktúr Java. Ponúka spôsob uloženia kolekcie s pevnou veľkosťou komponentov rovnakého typu. Pretože poskytujú rýchly a jednoduchý prístup k prvkom v závislosti od ich indexu, polia sú kľúčovým nástrojom na správu a organizáciu údajov.

Výhody:

    Organizácia údajov:Polia poskytujú štruktúrovaný spôsob ukladania a organizácie prvkov, čím zlepšujú správu údajov.Náhodný prístup:K prvkom možno pristupovať priamo pomocou ich indexu, čo umožňuje efektívne vyhľadávanie a úpravu.Pevná veľkosť:Polia majú vopred určenú veľkosť, čo umožňuje efektívne prideľovanie pamäte.Homogénne prvky:Polia ukladajú prvky rovnakého typu, čím zaisťujú konzistenciu údajov a zjednodušujú operácie.Iterácia:Polia podporujú jednoduchú iteráciu cez prvky, čím uľahčujú prechod a spracovanie.Triedenie a vyhľadávanie:Polia dobre fungujú s triediacimi a vyhľadávacími algoritmami a ponúkajú efektívne operácie.Výkon pamäte:Polia optimalizujú využitie pamäte ukladaním prvkov do súvislých oblastí.Kompatibilita:Polia sú v jazyku Java široko podporované, vďaka čomu sú kompatibilné s rôznymi rámcami a nástrojmi.

Nevýhody:

    Pevná veľkosť:Veľkosť polí nie je možné dynamicky meniť, čo si vyžaduje zmenu veľkosti.Strata pamäte:Nepoužité prvky vo väčších poliach môžu viesť k plytvaniu pamäťou.Režijné náklady na vkladanie a odstraňovanie:Vkladanie alebo odstraňovanie prvkov v strede poľa vyžaduje posunutie nasledujúcich prvkov, čo vedie k neefektívnosti.Nedostatok flexibility:Polia majú pevné dátové typy a nemôžu sa prispôsobiť rôznym druhom dát bez ďalších polí alebo dátových štruktúr.

Funkcie:

    Vytvorenie poľa:Deklarujte a inicializujte pole so špecifickou veľkosťou pomocou typu poľa a kľúčového slova new.Prístup k prvkom:Na prístup k jednotlivým prvkom v poli použite index.Modifikačné prvky:Aktualizujte hodnotu prvku priradením novej hodnoty konkrétnemu indexu v poli.Dĺžka nájdenia:Na určenie dĺžky poľa použite atribút dĺžky.Iterácia cez pole:Použite slučky na prechod cez každý prvok v poli a vykonanie

Implementácia:

Názov súboru: 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 v jazyku Java je dynamická dátová štruktúra, ktorá umožňuje ukladanie a manipuláciu s prvkami. Je súčasťou Java Collections Framework a je implementovaný pomocou poľa interne.

Výhody:

    Dynamická veľkosť:Na rozdiel od polí môžu ArrayLists dynamicky rásť alebo zmenšovať veľkosť pri pridávaní alebo odstraňovaní prvkov. Eliminuje potrebu ručnej zmeny veľkosti a umožňuje pohodlnú manipuláciu s rôznym množstvom údajov.Jednoduchá manipulácia s prvkami:ArrayLists ponúkajú metódy na pridávanie, odstraňovanie a upravovanie prvkov na ľubovoľnej pozícii v zozname. Jeho flexibilita zjednodušuje bežné operácie, ako je vkladanie, mazanie a aktualizácia, čím je manipulácia s prvkami efektívnejšia.Náhodný prístup:ArrayLists podporujú náhodný prístup k prvkom pomocou ich indexu, čo umožňuje rýchle vyhľadávanie a úpravu prvkov na konkrétnych pozíciách v zozname. Uľahčuje efektívny prístup k prvkom a zvyšuje celkový výkon.Kompatibilita s Java Collection Framework:ArrayLists implementujú rozhranie List, vďaka čomu sú kompatibilné s inými triedami Collection v Java Collections Framework. Jeho kompatibilita umožňuje bezproblémovú integráciu s rôznymi algoritmami a operáciami poskytovanými rámcom.

Nevýhody:

    Vyššia réžia pamäte:ArrayLists vyžadujú dodatočnú pamäť na udržanie ich vnútornej štruktúry, čo vedie k vyššej réžii pamäte v porovnaní s poliami. Môže to byť problém pri práci s veľkými zbierkami prvkov.Pomalšie vkladanie a mazanie:Vkladanie alebo odstraňovanie prvkov v strede ArrayList vyžaduje posúvanie prvkov, čo môže byť pri veľkých zoznamoch časovo náročné. V scenároch, kde sa očakávajú časté operácie vkladania alebo odstraňovania, môžu iné dátové štruktúry ako LinkedList ponúkať lepší výkon.Obmedzený výkon pre vyhľadávanie:Vyhľadávanie prvku v nezoradenom ArrayList vyžaduje iteráciu prvkov, kým sa nenájde zhoda. Ide o lineárny prístup k vyhľadávaniu, ktorého výsledkom je pomalší výkon vyhľadávania v porovnaní s dátovými štruktúrami optimalizovanými na vyhľadávanie, ako sú HashSet alebo TreeMap.Žiadna podpora primitívnych typov:ArrayLists môžu ukladať iba objekty a priamo nepodporujú primitívne dátové typy ako int alebo char. Na ukladanie primitívnych typov je potrebné použiť obalové triedy ako Integer alebo Character, čo vedie k potenciálnej réžii automatického rozbaľovania a rozbaľovania.

Funkcie:

vlastnosti java
    Vytvorenie ArrayList:Deklarujte a inicializujte ArrayList pomocou triedy ArrayList a špecifikujte typ prvku v lomených zátvorkách.Pridanie prvkov:Na pridanie prvkov na koniec ArrayList použite metódu add.Prístup k prvkom:Použite techniku ​​get na získanie ceny detailov na vybranom indexe.Modifikačné prvky:Aktualizujte cenu podrobností na konkrétnom indexe pre použitie nastaveného prístupu.Veľkosť nálezu:Použite metódu rozmerov na získanie špičkového množstva faktorov v ArrayList.Odstránenie prvkov:Na odstránenie detailu v konkrétnom indexe alebo poskytnutím odkazu na objekt použite metódu odstránenia.Iterácia cez ArrayList:Použite slučky na iteráciu nad každým prvkom v ArrayList a na vykonávanie operácií s nimi.

Implementácia:

Názov súboru: 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); } } } 

Výkon:

 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) Prepojený zoznam:

Prepojený zoznam je lineárna dátová štruktúra, v ktorej sú prvky uložené v samostatných objektoch nazývaných uzly. V dátovom prvku každého uzla je zahrnuté referenčné prepojenie na nasledujúci uzol v sekvencii. Posledný uzol zoznamu odkazuje na null, čo znamená, že zoznam skončil.

Na rozdiel od polí prepojené zoznamy nevyžadujú súvislú alokáciu pamäte. Každý uzol v prepojenom zozname môže byť pridelený nezávisle, čo umožňuje dynamické prideľovanie pamäte a efektívne operácie vkladania a vymazávania.

Výhody:

    Dynamická veľkosť:LinkedList môže dynamicky rásť alebo sa zmenšovať, vďaka čomu je vhodný pre rôzne alebo neznáme veľkosti údajov.Efektívne vkladanie a odstraňovanie:Vkladanie alebo odstraňovanie prvkov v rámci LinkedList je efektívne, pretože nevyžaduje presúvanie prvkov.Žiadna súvislá pamäť:LinkedList nepotrebuje súvislú alokáciu pamäte, vďaka čomu je flexibilný a vhodný pre nepredvídateľné pamäťové situácie.Jednoduchá úprava:LinkedList umožňuje jednoduchú úpravu prvkov zmenou referenčných ukazovateľov, čo umožňuje efektívnu manipuláciu.

Nevýhody:

    Pomalší náhodný prístup:LinkedList má pomalší náhodný prístup, pretože vyžaduje prechádzanie zoznamom na prístup k prvkom podľa indexu.Zvýšená réžia pamäte:LinkedList vyžaduje dodatočnú pamäť pre referencie a uzly, čím sa zvyšuje réžia pamäte v porovnaní s poliami.Neefektívne vyhľadávanie:LinkedList má pomalšie operácie vyhľadávania a vyžaduje sekvenčnú iteráciu na nájdenie konkrétnych prvkov.

Funkcie:

    Vytvorenie LinkedList:Deklarujte a inicializujte LinkedList pomocou triedy LinkedList.Pridanie prvkov:Použite metódu add na pripojenie prvkov na koniec LinkedList.Prístup k prvkom:Na získanie hodnoty prvku v konkrétnom indexe použite metódu get.Modifikačné prvky:Aktualizujte hodnotu prvku v konkrétnom indexe pomocou metódy set.Odstránenie prvkov:Na odstránenie prvku v konkrétnom indexe alebo poskytnutím odkazu na objekt použite metódu remove.

Implementácia:

Názov súboru: 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); } } 

Výkon:

 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) Zásobník:

Princíp Last-In-First-Out (LIFO) určuje, že prvok, ktorý bol vložený naposledy, je tiež prvok, ktorý sa odstráni ako prvý. Zásobník je lineárna dátová štruktúra, ktorá sa riadi týmto pravidlom. Používa príkazy 'push' a 'pop' na pridávanie prvkov do zásobníka a podľa toho na odstránenie horného prvku zo zásobníka. Technika „peek“ navyše umožňuje prístup k hornému prvku bez jeho odstránenia.

Vlastnosti zásobníka:

    Správanie LIFO:Posledný prvok zasunutý na stoh je prvý, ktorý sa vysunie, takže je vhodný pre aplikácie, kde je dôležité poradie vkladania a vyberania.Obmedzený prístup:Zásobníky zvyčajne poskytujú obmedzený prístup k prvkom. Môžete pristupovať iba k najvrchnejšiemu prvku a na ďalšie prvky musíte vyklopiť prvky nad nimi.Dynamická veľkosť:Zásobníky možno implementovať pomocou polí alebo prepojených zoznamov, čo umožňuje dynamickú veľkosť. Počas prevádzky môžu podľa potreby rásť alebo sa zmenšovať.

Výhody:

    jednoduchosť:Hromady sú ľahko pochopiteľné a implementovateľné.Účinnosť:Operácie vkladania a vymazania majú časovú zložitosť O(1).Správa hovorov funkcií:Stacky efektívne spravujú volania funkcií a variabilné úložisko.Funkcia Späť/Znova:Zásobníky umožňujú vrátiť a zopakovať operácie v aplikáciách.

Nevýhody:

    Obmedzený prístup:Prístup k prvkom je obmedzený na hornú časť zásobníka.Obmedzenia veľkosti:Zásobníky môžu mať obmedzenia veľkosti v závislosti od implementácie.Nevhodné pre všetky scenáre:Zásobníky sú špecifické pre správanie LIFO a nemusia byť vhodné v iných prípadoch.

Implementácia:

Názov súboru: 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); } } } 

Výkon:

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

5) Poradie:

Front je lineárna dátová štruktúra v jazyku Java, ktorá sa riadi princípom First-In-First-Out (FIFO). Predstavuje kolekciu prvkov, kde sú prvky vložené vzadu a odstránené spredu.

uložiť video z youtube vlc

Vlastnosti:

    Zaradiť do poradia:Pridanie prvku do zadnej časti frontu.Dequeue:Odstránenie prvku z prednej časti frontu.Nahliadnuť:Získajte prvok v prednej časti frontu bez jeho odstránenia.Veľkosť:Určenie počtu prvkov vo fronte.Prázdny šek:Kontrola, či je front prázdny.

Výhody:

    Správanie FIFO:Prvky sú spracované v poradí ich vloženia, čím sa zabezpečí zachovanie pôvodnej sekvencie.Efektívne vkladanie a vyberanie:Pridávanie a odstraňovanie prvkov z frontu je rýchle a má konštantnú časovú zložitosť O(1).synchronizácia:Java poskytuje synchronizované implementácie frontu, vďaka čomu sú bezpečné pre súbežné programovanie.Štandardizované rozhranie:Rozhranie Queue v Jave ponúka spoločnú sadu metód, čo umožňuje jednoduchú zameniteľnosť medzi rôznymi implementáciami frontu.

Nevýhody:

    Žiadny náhodný prístup:Fronty nepodporujú priamy prístup k prvkom v strede. Prístup k špecifickým pozíciám vyžaduje vyradenie predchádzajúcich prvkov.Obmedzená veľkosť:Niektoré implementácie frontu majú pevnú veľkosť alebo kapacitu, čo vedie k pretečeniu alebo výnimkám pri prekročení maximálnej veľkosti.Neefektívne vyhľadávanie:Vyhľadávanie prvku vo fronte vyžaduje vyradenie z radu, kým sa nenájde zhoda, výsledkom čoho je lineárne vyhľadávanie s potenciálne vysokou časovou zložitosťou.

Implementácia:

Názov súboru: 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); } } } 

Výkon:

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

6) HashMap:

HashMap je dátová štruktúra v jazyku Java, ktorá poskytuje spôsob ukladania a získavania párov kľúč – hodnota. Je súčasťou Java Collections Framework a je implementovaný na základe dátovej štruktúry hash tabuľky.

Funkcie:

    dať (kľúč, hodnota):Vloží zadaný pár kľúč – hodnota do HashMap.získať (kľúč):Načíta hodnotu spojenú so zadaným kľúčom.obsahujeKľúč (kľúč):Skontroluje, či HashMap obsahuje zadaný kľúč.obsahujeHodnotu(hodnota):Skontroluje, či HashMap obsahuje zadanú hodnotu.odstrániť (kľúč):Odstráni pár kľúč – hodnota priradený k zadanému kľúču z HashMap.veľkosť ():Vráti počet párov kľúč – hodnota v HashMape.je prázdny():Skontroluje, či je HashMap prázdna.keySet():Vráti sadu obsahujúcu všetky kľúče v HashMape.hodnoty():Vráti kolekciu obsahujúcu všetky hodnoty v HashMape.jasný():Odstráni všetky páry kľúč – hodnota z HashMap.

Výhody:

    Efektívne vyhľadávanie:HashMap poskytuje rýchle získavanie hodnôt na základe kľúčov s konštantnou časovou zložitosťou O(1).Flexibilné párovanie kľúč – hodnota:HashMap povoľuje ako kľúč akýkoľvek nenulový objekt, čím umožňuje vlastné definované kľúče na ukladanie a získavanie údajov.Dynamická veľkosť:HashMap môže dynamicky rásť alebo zmenšovať veľkosť, aby zvládla rôzne množstvá údajov.Kompatibilita s Java Collections Framework:HashMap implementuje rozhranie Map, ktoré umožňuje bezproblémovú integráciu s inými triedami Collection.

Nevýhody:

    Nedostatok objednávky:HashMap nezachováva poradie prvkov. Pre špecifické požiadavky na objednávanie použite LinkedHashMap alebo TreeMap.Zvýšená réžia pamäte:HashMap vyžaduje dodatočnú pamäť pre hash kódy a vnútornú štruktúru v porovnaní s jednoduchšími dátovými štruktúrami.Pomalšia iterácia:Iterácia cez HashMap môže byť pomalšia v porovnaní s poliami alebo zoznamami kvôli prechádzaniu základnej hašovacej tabuľky.

Implementácia:

Názov súboru: 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()); } } 

Výkon:

 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 je dátová štruktúra v jazyku Java, ktorá implementuje rozhranie Set a ukladá prvky do hašovacej tabuľky.

Vlastnosti:

    Ukladá jedinečné prvky:HashSet nepovoľuje duplicitné prvky. Každý prvok v HashSet je jedinečný.Používa vyhľadávanie založené na hash:HashSet používa hodnotu hash každého prvku na určenie jeho miesta uloženia, čím poskytuje efektívne vyhľadávanie prvkov.Neobjednaná kolekcia:Prvky v HashSet nie sú uložené v určitom poradí. Poradie prvkov sa môže časom meniť.

Výhody:

    Rýchle vyhľadávanie prvkov:HashSet poskytuje rýchle operácie vyhľadávania, vďaka čomu je efektívne kontrolovať, či prvok v množine existuje.Žiadne duplicitné prvky:HashSet automaticky spracováva duplicitné prvky a zabezpečuje, že každý prvok je jedinečný.Integrácia s Java Collections Framework:HashSet implementuje rozhranie Set, vďaka čomu je kompatibilné s ostatnými triedami kolekcií v rámci Java Collections Framework.

Nevýhody:

metóda reťazcov v jave
    Žiadna zaručená objednávka:HashSet nezachováva poradie prvkov. Ak je dôležité poradie prvkov, HashSet nie je vhodný.Žiadne indexovanie:HashSet neposkytuje priame indexovanie ani pozičný prístup k prvkom. Ak chcete získať prístup k prvkom, musíte množinu iterovať.Vyššia réžia pamäte:HashSet vyžaduje dodatočnú pamäť na ukladanie hašovacích hodnôt a udržiavanie štruktúry hašovacej tabuľky, čo má za následok vyššie využitie pamäte v porovnaní s niektorými inými dátovými štruktúrami.

Implementácia:

Názov súboru: 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()); } } 

Výkon:

 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) Sada stromov:

TreeSet je implementácia rozhrania SortedSet v jazyku Java, ktorá používa samovyvažujúci binárny vyhľadávací strom nazývaný červeno-čierny strom na ukladanie prvkov v zoradenom poradí.

Výhody:

    Zoradené poradie:TreeSet automaticky udržiava prvky v zoradenom poradí na základe ich prirodzeného usporiadania alebo vlastného porovnávača. Umožňuje efektívne vyhľadávanie a získavanie prvkov vo vzostupnom alebo zostupnom poradí.Žiadne duplicitné prvky:TreeSet nepovoľuje duplicitné prvky. Zabezpečuje, že každý prvok v množine je jedinečný, čo môže byť užitočné v scenároch, kde sa treba vyhnúť duplicitným hodnotám.Efektívne operácie:TreeSet poskytuje efektívne operácie, ako je vkladanie, mazanie a vyhľadávanie. Tieto operácie majú časovú zložitosť O(log n), kde n je počet prvkov v množine.Operácie navigačnej sady:TreeSet poskytuje ďalšie navigačné metódy, ako je vyššia (), nižšia (), strop () a podlaha (), ktoré vám umožňujú nájsť prvky, ktoré sú väčšie, menšie alebo rovné danej hodnote.

Nevýhody:

    Režijné náklady:TreeSet vyžaduje dodatočnú pamäť na uloženie vnútornej dátovej štruktúry, čo môže viesť k vyššej réžii pamäte v porovnaní s inými implementáciami sady.Pomalšie vkladanie a vyberanie:Operácie vkladania a odstraňovania v TreeSet zahŕňajú udržiavanie zoradeného poradia prvkov, čo môže vyžadovať reštrukturalizáciu stromu. Môže tieto operácie mierne spomaliť v porovnaní s HashSet alebo LinkedHashSet.Obmedzené prispôsobenie:TreeSet je primárne určený pre prirodzené usporiadanie alebo jeden vlastný porovnávač. Môže potrebovať väčšiu flexibilitu pre viaceré kritériá triedenia alebo zložitú logiku triedenia.

Funkcie:

    pridať (prvok):Pridá prvok do TreeSet pri zachovaní zoradeného poradia.odstrániť (prvok):Odstráni zadaný prvok zo sady TreeSet.obsahuje (prvok):Skontroluje, či sada stromov obsahuje zadaný prvok.veľkosť ():Vráti počet prvkov v množine stromov.najprv():Vráti prvý (najnižší) prvok v množine stromov.posledný():Vráti posledný (najvyšší) prvok v množine stromov.vyšší (prvok):Vráti najmenší prvok v množine stromov, ktorý je striktne väčší ako daný prvok.nižší (prvok):Vráti najväčší prvok v množine stromov, ktorý je striktne menší ako daný prvok.

Implementácia:

Názov súboru: 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); } } } 

Výkon:

reťazec na char java
 Elements in the TreeSet:[1, 2, 4, 5, 8] Does TreeSet contain 4? true Elements in the TreeSet after removal:[1, 4, 5, 8] Size of the TreeSet:4First element:1 Last element:8 Iterating over the TreeSet: 1 4 5 8 

9) Stromová mapa:

TreeMap je trieda v jazyku Java, ktorá implementuje rozhranie Map a poskytuje triedené mapovanie kľúč-hodnota na základe prirodzeného poradia kľúčov alebo vlastného komparátora.

Výhody:

    Zoradené zoradenie:TreeMap udržiava kľúče v zoradenom poradí, čo umožňuje efektívne vyhľadávanie, získavanie a operácie založené na rozsahu.Mapovanie hodnôt kľúča:TreeMap ukladá páry kľúč-hodnota, čo umožňuje efektívne vyhľadávanie a získavanie hodnôt na základe priradených kľúčov.Implementácia červeno-čierneho stromu:TreeMap interne používa vyvážený binárny vyhľadávací strom (červeno-čierny strom), ktorý zabezpečuje efektívny výkon aj pre veľké súbory údajov.Podpora pre vlastné porovnávače:TreeMap umožňuje použitie vlastných komparátorov na definovanie poradia triedenia kľúčov, čím poskytuje flexibilitu pri kritériách triedenia.

Nevýhody:

    Pamäťová réžia:TreeMap vyžaduje dodatočnú pamäť na uloženie vnútornej stromovej štruktúry a pridružených objektov, čo vedie k vyššej spotrebe pamäte v porovnaní s jednoduchšími dátovými štruktúrami, ako je HashMap.Pomalšie vkladanie a mazanie:Operácie vkladania a vymazávania v TreeMap majú časovú zložitosť O(log n) kvôli potrebe reštrukturalizácie stromu, vďaka čomu sú pomalšie v porovnaní s HashMap alebo LinkedHashMap.Obmedzený výkon pre netriedené údaje:TreeMap funguje efektívne pre zoradené údaje, ale jeho výkon sa môže zhoršiť pri práci s nezoradenými údajmi alebo častými úpravami, pretože vyžaduje udržiavanie zoradeného poradia.

Funkcie:

    dať (kľúč, hodnota):Vloží pár kľúč – hodnota do stromovej mapy.získať (kľúč):Načíta hodnotu spojenú so zadaným kľúčom.obsahujeKľúč (kľúč):Skontroluje, či stromová mapa obsahuje špecifický kľúč.odstrániť (kľúč):Odstráni pár kľúč – hodnota priradený k zadanému kľúču.veľkosť ():Vráti počet párov kľúč – hodnota v stromovej mape.keySet():Vráti sadu všetkých kľúčov v stromovej mape.hodnoty():Vráti kolekciu všetkých hodnôt v stromovej mape.entrySet():Vráti množinu párov kľúč – hodnota v stromovej mape.

Implementácia:

Názov súboru: 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); } } } 

Výkon:

 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:

Grafy sú dátové štruktúry, ktoré predstavujú kolekciu vzájomne prepojených uzlov alebo vrcholov. Skladajú sa z vrcholov a hrán, kde vrcholy predstavujú entity a hrany predstavujú vzťahy medzi týmito entitami.

Výhody:

    Všestrannosť:Grafy môžu predstavovať širokú škálu scenárov reálneho sveta, vďaka čomu sú vhodné pre rôzne aplikácie, ako sú sociálne siete, dopravné systémy a počítačové siete.Zastúpenie vo vzťahu:Grafy poskytujú prirodzený spôsob, ako reprezentovať vzťahy a prepojenia medzi entitami, čo umožňuje efektívnu analýzu a prechod týchto vzťahov.Efektívne vyhľadávanie a prechod:Algoritmy grafov ako vyhľadávanie do šírky (BFS) a vyhľadávanie do hĺbky (DFS) umožňujú efektívne prechádzanie a vyhľadávanie vrcholov a hrán grafu.Modelovanie zložitých vzťahov:Grafy môžu modelovať zložité vzťahy vrátane hierarchických štruktúr, cyklických závislostí a viacnásobných prepojení medzi entitami.

Nevýhody:

    Priestorová zložitosť:Grafy môžu spotrebovať značné množstvo pamäte, najmä veľké grafy s mnohými vrcholmi a hranami.Zložitosť operácií:Určité operácie s grafmi, ako je nájdenie najkratšej cesty alebo zisťovanie cyklov, môžu byť časovo náročné, najmä v hustých grafoch.Ťažkosti s údržbou:Úprava alebo aktualizácia grafu môže byť zložitá, pretože zmeny v štruktúre grafu môžu ovplyvniť jeho konektivitu a existujúce algoritmy.

Implementácia:

Názov súboru: 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) Strom:

Strom je široko používaná dátová štruktúra v informatike, ktorá predstavuje hierarchickú štruktúru. Pozostáva z uzlov spojených hranami, pričom každý uzol môže mať nula alebo viac podriadených uzlov.

Výhody:

    Hierarchická štruktúra:Stromy poskytujú prirodzený spôsob reprezentácie hierarchických vzťahov, ako sú systémy súborov, organizačné schémy alebo dokumenty HTML/XML.Efektívne vyhľadávanie:Binárne vyhľadávacie stromy umožňujú efektívne vyhľadávanie s časovou zložitosťou O(log n), vďaka čomu sú vhodné na ukladanie a získavanie triedených dát.Rýchle vkladanie a mazanie:Stromové dátové štruktúry ponúkajú efektívne operácie vkladania a vymazávania, najmä keď sú vyvážené, ako sú AVL stromy alebo červeno-čierne stromy.Objednaná iterácia:Priebeh binárneho vyhľadávacieho stromu v poradí dáva prvky v zoradenom poradí, čo je užitočné pri úlohách, ako je tlač prvkov v zoradenom poradí alebo hľadanie ďalšieho/predchádzajúceho prvku.

Nevýhody:

    Vysoká réžia pamäte:Stromy vyžadujú dodatočnú pamäť na ukladanie referencií uzlov alebo ukazovateľov, čo môže viesť k vyššej spotrebe pamäte v porovnaní s lineárnymi dátovými štruktúrami, ako sú polia alebo zoznamy.Komplexná implementácia:Implementácia a udržiavanie stromovej dátovej štruktúry môže byť zložitejšie v porovnaní s inými dátovými štruktúrami, ako sú polia alebo zoznamy, najmä pre vyvážené stromové varianty.Obmedzené operácie:Niektoré varianty stromov, ako napríklad binárne vyhľadávacie stromy, nepodporujú efektívne operácie, ako je nájdenie k-tého najmenšieho prvku alebo nájdenie hodnosti prvku.

Funkcie:

    Vloženie:Pridajte nový uzol do stromu.vymazanie:Odstráňte uzol zo stromu.Vyhľadávanie:Nájdite konkrétny uzol alebo prvok v strome.Priebeh:Prechádzajte stromom v rôznych poradiach, ako napríklad v poradí, predobjednávka alebo po objednávke.Výška/Hĺbka:Vypočítajte výšku alebo hĺbku stromu.Zostatok:Zabezpečte, aby strom zostal vyvážený, aby sa zachovali efektívne operácie.

Implementácia:

Názov súboru: 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)>