logo

Datové struktury v Javě

Mnoho způsobů, jak lze data uspořádat, uložit a zpracovat v rámci počítačového programu, se v Javě nazývá datové struktury. Tyto struktury nabízejí metodickou metodu pro efektivní manipulaci a správu dat a umožňují užitečné operace, jako je vkládání, mazání, načítání a procházení.

Článek prozkoumá vše, co souvisí s datovými strukturami v Javě, a pomůže začátečníkům snadno a efektivně porozumět.

  • Co je Java?
  • Co jsou datové struktury v Javě?
  • Typy datových struktur v Javě
  • Výhody datových struktur v Javě
  • Klasifikace datových struktur
  • Časté otázky o datových strukturách v Javě

Co je Java?

Java je oblíbený objektově orientovaný programovací jazyk známý pro svou rozsáhlou standardní knihovnu a svobodu platformy. Nabízí solidní architekturu pro vytváření programů běžících bez rekompilace napříč různými platformami. Známá knihovna pro Javu má výběr systémů záznamů, díky nimž je životaschopné efektivně pracovat s mnoha typy dat.

Co jsou datové struktury v Javě?

Způsob, jakým jsou data organizována a uložena v paměti počítačového programu, úzce závisí na záznamových strukturách Java. Známá knihovna Java obsahuje významný typ vestavěných statistických struktur. Několik záznamových systémů, které umožňují programátorům krátké a jednoduché způsoby ukládání a uspořádání dat, zahrnují propojené seznamy, zásobníky, fronty a pole. Vývojáři mohou rychle provádět operace, jako je vkládání, mazání, vyhledávání a třídění, protože poskytují řadu mechanismů pro získání přístupu k datům, jejich změnu a správu. Java programátoři mohou pomocí těchto datových struktur snížit spotřebu paměti a výrazně zvýšit celkovou efektivitu svých programů.

Typy datových struktur v Javě

Seznam datových struktur v Javě je uveden níže

  1. Pole
  2. ArrayList
  3. Spojový seznam
  4. Zásobník
  5. Fronta
  6. HashMap
  7. HashSet
  8. TreeSet
  9. Stromová mapa
  10. Graf
  11. Strom

Níže uvedený diagram jasně vysvětluje typy datových struktur v Javě.

Datové struktury v Javě

Další klasifikace typů datových struktur:

Existují dva typy datových struktur: -

  1. Primitivní datové struktury
  2. Neprimitivní datové struktury

1) Primitivní datové struktury: Také známé jako primitivní datové typy, jedná se o základní vestavěné datové typy v Javě. Obsahují:

    Byte:Ukládá celá čísla od -128 do 127.krátký:Ukládá celá čísla od -32 768 do 32 767.int:Ukládá celá čísla od -2,147,483,648 do 2,147,483,647.plovák:Ukládá čísla s plovoucí desetinnou čárkou s jednoduchou přesností.znak:Ukládá jednotlivé postavy.boolean:Ukládá pravdivé nebo nepravdivé hodnoty.dlouho:Ukládá velká celá čísla.Dvojnásobek:Ukládá čísla s plovoucím faktorem s dvojnásobnou přesností.

2) Neprimitivní datové struktury: Neprimitivní struktury záznamů jsou složitější a skládají se z primitivních druhů informací. Kromě toho je lze rozdělit do dvou typů:

    Lineární datové struktury:V lineárních datových strukturách jsou prvky uspořádány lineárně nebo sekvenčně. Příklady:
      Pole:Skupina prvků stejného typu umístěných v poli podle předem určeného uspořádání.Hromady:Struktura Last-In-First-Out (LIFO), ve které lze přidávat nebo odebírat pouze nejvyšší položky.Ocasy:Struktury First-In-First-Out (FIFO) se používají ve frontách, kde jsou položky vkládány na vrácené a odebírány na přední straně.Spojový seznam:Související seznam obsahuje sbírku gadgetů označovaných jako uzly, z nichž každý má za sebou odkaz na uzel a statistiky v něm.
    Nelineární datové struktury:V nelineárních datových strukturách jsou prvky uspořádány nesekvenčně. Příklady:
      stromy:Stromy jsou typem hierarchické struktury založené na uzlech, s kořenovým uzlem nahoře a podřízenými uzly, které se z něj větví. Příklady zahrnují červeno-černé stromy, AVL stromy, binární vyhledávací stromy a binární stromy.Grafy:Sada uzlů spojených pomocí hran, přičemž uzly mohou mít libovolné množství spojení. Grafy se používají k symbolizaci složitých vztahů mezi položkami.Halda:Specializovaná stromová struktura, ve které má každý určený uzel hodnotu větší nebo menší než jeho děti, spoléhající na to, zda se jedná o maximální nebo minimální haldu.hash:Datové struktury, které používají hashovací funkci k mapování klíčů na hodnoty. Příklady sestávají z hash sad a hash map, které poskytují zelené vyhledávání a ukládání statistik na základě přesných klíčů.
Datové struktury v Javě

Výhody datových struktur v Javě

    Efektivní organizace dat:Datové struktury poskytují organizované způsoby ukládání a správy dat a umožňují efektivní operace přístupu, manipulace a získávání dat. Optimalizují využití paměti a umožňují rychlejší provádění algoritmů.Lepší výkon:Vývojáři mohou zlepšit výkon z hlediska rychlosti a využití paměti výběrem vhodné datové struktury pro konkrétní aktivitu. Výkon je optimalizován, protože specifické datové struktury jsou vytvořeny tak, aby vynikaly při konkrétních akcích, jako je vyhledávání, třídění nebo vkládání informací.Znovupoužitelnost kódu:Java nabízí širokou škálu vestavěných datových struktur, které programátoři snadno používají. Tyto opakovaně použitelné datové struktury šetří čas a námahu tím, že eliminují potřebu vytvářet sofistikované algoritmy od začátku.Jednoduchost kódu:Datové struktury usnadňují kódování implementace komplikovaných procesů. Nabízejí abstrakce na vysoké úrovni a zapouzdřují specifika správy dat, což zlepšuje čitelnost, udržovatelnost a přehlednost kódu.Flexibilita a přizpůsobivost:Datové struktury nabízejí flexibilitu při manipulaci s různými typy a velikostmi dat. Mohou se dynamicky přizpůsobovat měnícím se požadavkům na data a poskytovat mechanismy pro efektivní manipulaci s daty.Standardizované a dobře otestované:Standardní knihovna pro Javu obsahuje vestavěné datové struktury, které prošly významným testováním a optimalizací, což zaručuje jejich spolehlivost a výkon. Využití těchto společných datových struktur snižuje možnost chyb a dává vývoji aplikací pevný základ.Škálovatelnost:Datové struktury poskytují možnosti škálovatelnosti a umožňují aplikacím efektivně zpracovávat velké objemy dat. Mohou se dynamicky zvětšovat nebo zmenšovat v závislosti na velikosti dat, což zajišťuje optimální výkon i při rostoucích požadavcích na data.Návrh algoritmu:Datové struktury jsou klíčové při návrhu a analýze algoritmů. Poskytují základní strukturu a operace nezbytné pro implementaci různých algoritmů a řešení složitých problémů.

1) Pole:

Pole je základní a často používaná datová struktura v kontextu datových struktur Java. Nabízí způsob ukládání kolekce komponent stejného typu o pevné velikosti. Protože poskytují rychlý a snadný přístup k prvkům v závislosti na jejich indexu, jsou pole klíčovým nástrojem pro správu a organizaci dat.

výhody:

    Organizace dat:Pole poskytují strukturovaný způsob ukládání a organizace prvků a zlepšují správu dat.Náhodný přístup:K prvkům lze přistupovat přímo pomocí jejich indexu, což umožňuje efektivní vyhledávání a úpravy.Pevná velikost:Pole mají předem určenou velikost, což umožňuje efektivní alokaci paměti.Homogenní prvky:Pole ukládají prvky stejného typu, což zajišťuje konzistenci dat a zjednodušuje operace.Opakování:Pole podporují snadnou iteraci mezi prvky, což usnadňuje procházení a zpracování.Řazení a vyhledávání:Pole dobře fungují s třídicími a vyhledávacími algoritmy a nabízejí efektivní operace.Výkon paměti:Pole optimalizují využití paměti ukládáním prvků do souvislých oblastí.Kompatibilita:Pole jsou v Javě široce podporována, díky čemuž jsou kompatibilní s různými frameworky a nástroji.

Nevýhody:

    Pevná velikost:Velikost polí nelze dynamicky měnit, což vyžaduje změnu velikosti.Plýtvání pamětí:Nepoužité prvky ve větších polích mohou vést k plýtvání pamětí.Režie vkládání a mazání:Vkládání nebo odstraňování prvků uprostřed pole vyžaduje posunutí následujících prvků, což vede k neefektivitě.Nedostatek flexibility:Pole mají pevné datové typy a nemohou pojmout různé druhy dat bez dalších polí nebo datových struktur.

Funkce:

    Vytvoření pole:Deklarujte a inicializujte pole s konkrétní velikostí pomocí typu pole a klíčového slova new.Přístup k prvkům:Použijte index pro přístup k jednotlivým prvkům v poli.Modifikační prvky:Aktualizujte hodnotu prvku přiřazením nové hodnoty konkrétnímu indexu v poli.Délka nálezu:K určení délky pole použijte atribut length.Iterace přes pole:Pomocí smyček projděte každý prvek v poli a spusťte jej

Implementace:

Název souboru: 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 Javě je dynamická datová struktura, která umožňuje ukládání a manipulaci s prvky. Je součástí Java Collections Framework a je implementován pomocí pole interně.

výhody:

    Dynamická velikost:Na rozdíl od polí mohou ArrayLists dynamicky růst nebo zmenšovat velikost, jak jsou prvky přidávány nebo odebírány. Eliminuje potřebu ruční změny velikosti a umožňuje pohodlnou manipulaci s různým množstvím dat.Snadná manipulace s prvky:ArrayLists nabízejí metody pro přidání, odstranění a úpravu prvků na libovolné pozici v seznamu. Jeho flexibilita zjednodušuje běžné operace, jako je vkládání, mazání a aktualizace, čímž je manipulace s prvky efektivnější.Náhodný přístup:ArrayLists podporují náhodný přístup k prvkům pomocí jejich indexu, což umožňuje rychlé vyhledávání a úpravy prvků na konkrétních pozicích v seznamu. Usnadňuje efektivní přístup k prvkům a zvyšuje celkový výkon.Kompatibilita s Java Collection Framework:ArrayLists implementují rozhraní List, díky čemuž jsou kompatibilní s ostatními třídami Collection v Java Collections Framework. Jeho kompatibilita umožňuje bezproblémovou integraci s různými algoritmy a operacemi poskytovanými rámcem.

Nevýhody:

    Vyšší paměťová zátěž:ArrayLists vyžadují dodatečnou paměť k udržení své vnitřní struktury, což má za následek vyšší paměťovou režii ve srovnání s poli. Může to být problém při práci s velkými kolekcemi prvků.Pomalejší vkládání a mazání:Vkládání nebo odstraňování prvků uprostřed ArrayList vyžaduje posouvání prvků, což může být u velkých seznamů časově náročné. Ve scénářích, kde se očekávají časté operace vkládání nebo mazání, mohou jiné datové struktury, jako je LinkedList, nabídnout lepší výkon.Omezený výkon pro vyhledávání:Hledání prvku v neseřazeném seznamu ArrayList vyžaduje opakování prvků, dokud není nalezena shoda. Jedná se o lineární přístup k vyhledávání, jehož výsledkem je pomalejší výkon vyhledávání ve srovnání s datovými strukturami optimalizovanými pro vyhledávání, jako je HashSet nebo TreeMap.Žádná podpora primitivního typu:ArrayLists mohou ukládat pouze objekty a nepodporují přímo primitivní datové typy jako int nebo char. Pro uložení primitivních typů je třeba použít obalové třídy jako Integer nebo Character, což vede k potenciální režii automatického rozbalování a rozbalování.

Funkce:

hodnota řetězce
    Vytvoření ArrayList:Deklarujte a inicializujte ArrayList pomocí třídy ArrayList a určete typ prvku v lomených závorkách.Přidávání prvků:Použijte metodu add k připojení prvků na konec ArrayList.Přístup k prvkům:Použijte techniku ​​get k načtení ceny detailu u vybraného indexu.Modifikační prvky:Aktualizujte cenu podrobností na konkrétním indexu pro použití nastaveného přístupu.Velikost nálezu:Použijte metodu dimenzí k získání špičkového množství faktorů v ArrayList.Odebrání prvků:Použijte metodu odebrání k odstranění detailu v konkrétním indexu nebo poskytnutím odkazu na objekt.Iterace přes ArrayList:Použijte smyčky k iteraci přes každý prvek v ArrayList a provádějte s nimi operace.

Implementace:

Název souboru: 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ýstup:

 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) Propojený seznam:

Propojený seznam je lineární datová struktura, ve které jsou prvky uloženy v samostatných objektech nazývaných uzly. V datovém prvku každého uzlu je zahrnut referenční odkaz na následující uzel v sekvenci. Poslední uzel seznamu odkazuje na null, což znamená, že seznam skončil.

Na rozdíl od polí propojené seznamy nevyžadují souvislé přidělování paměti. Každý uzel v propojeném seznamu lze alokovat nezávisle, což umožňuje dynamické přidělování paměti a efektivní operace vkládání a mazání.

výhody:

    Dynamická velikost:LinkedList se může dynamicky zvětšovat nebo zmenšovat, takže je vhodný pro různé nebo neznámé velikosti dat.Efektivní vkládání a mazání:Vkládání nebo odstraňování prvků v rámci LinkedList je efektivní, protože nevyžaduje posouvání prvků.Žádné požadavky na souvislou paměť:LinkedList nepotřebuje souvislé přidělování paměti, díky čemuž je flexibilní a vhodný pro nepředvídatelné paměťové situace.Snadná úprava:LinkedList umožňuje snadnou úpravu prvků změnou referenčních ukazatelů, což umožňuje efektivní manipulaci.

Nevýhody:

    Pomalejší náhodný přístup:LinkedList má pomalejší náhodný přístup, protože pro přístup k prvkům podle indexu vyžaduje procházení seznamu.Zvýšená paměťová zátěž:LinkedList vyžaduje dodatečnou paměť pro odkazy a uzly, což ve srovnání s poli zvyšuje paměťovou režii.Neefektivní vyhledávání:LinkedList má pomalejší vyhledávací operace, které vyžadují sekvenční iteraci k nalezení konkrétních prvků.

Funkce:

    Vytvoření LinkedList:Deklarujte a inicializujte LinkedList pomocí třídy LinkedList.Přidávání prvků:Použijte metodu add k připojení prvků na konec LinkedList.Přístup k prvkům:Použijte metodu get k načtení hodnoty prvku na konkrétním indexu.Modifikační prvky:Aktualizujte hodnotu prvku na konkrétním indexu pomocí metody set.Odebrání prvků:Použijte metodu remove k odstranění prvku na konkrétním indexu nebo poskytnutím odkazu na objekt.

Implementace:

Název souboru: 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ýstup:

 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:

Princip Last-In-First-Out (LIFO) určuje, že prvek, který byl vložen naposledy, je také prvek, který je odstraněn jako první. Zásobník je lineární datová struktura, která se řídí tímto pravidlem. Využívá příkazy 'push' a 'pop' k přidání prvků do zásobníku a podle toho k odstranění horního prvku ze zásobníku. Technika „peek“ navíc umožňuje přístup k hornímu prvku bez jeho odstranění.

nejlepší úsměv na světě

Vlastnosti zásobníku:

    Chování LIFO:Poslední prvek nasunutý na stoh je první, který se vysune, takže je vhodný pro aplikace, kde je důležité pořadí vkládání a vyjímání.Omezený přístup:Zásobníky obvykle poskytují omezený přístup k prvkům. Můžete přistupovat pouze k nejvyššímu prvku a k dalším prvkům musíte prvky nad nimi vyskočit.Dynamická velikost:Zásobníky lze implementovat pomocí polí nebo propojených seznamů, což umožňuje dynamickou velikost. Mohou růst nebo zmenšovat podle potřeby během běhu.

výhody:

    Jednoduchost:Hromady jsou snadno pochopitelné a implementovatelné.Účinnost:Operace vkládání a mazání mají časovou složitost O(1).Správa volání funkcí:Stacks efektivně spravují volání funkcí a variabilní úložiště.Funkce Zpět/Znovu:Zásobníky umožňují vrátit a opakovat operace v aplikacích.

Nevýhody:

    Omezený přístup:Přístup k prvkům je omezen na horní část zásobníku.Omezení velikosti:Zásobníky mohou mít omezení velikosti v závislosti na implementaci.Nevhodné pro všechny scénáře:Zásobníky jsou specifické pro chování LIFO a v jiných případech nemusí být vhodné.

Implementace:

Název souboru: 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ýstup:

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

5) Fronta:

Fronta je lineární datová struktura v Javě, která se řídí principem First-In-First-Out (FIFO). Představuje kolekci prvků, kde jsou prvky vkládány zezadu a odebírány zepředu.

Funkce:

    Zařadit do fronty:Přidání prvku do zadní části fronty.Dequeue:Odebrání prvku z přední části fronty.Podívejte se:Načtěte prvek v přední části fronty, aniž byste jej odstranili.Velikost:Určení počtu prvků ve frontě.Prázdný šek:Kontrola, zda je fronta prázdná.

výhody:

    Chování FIFO:Prvky jsou zpracovávány v pořadí jejich vkládání, čímž je zajištěno zachování původní sekvence.Efektivní vkládání a vyjímání:Přidávání a odebírání prvků z fronty je rychlé a má konstantní časovou složitost O(1).Synchronizace:Java poskytuje synchronizované implementace front, takže jsou bezpečné pro souběžné programování.Standardizované rozhraní:Rozhraní Queue v Javě nabízí společnou sadu metod, což umožňuje snadnou zaměnitelnost mezi různými implementacemi fronty.

Nevýhody:

    Žádný náhodný přístup:Fronty nepodporují přímý přístup k prvkům uprostřed. Přístup ke konkrétním pozicím vyžaduje vyřazení předchozích prvků.Omezená velikost:Některé implementace fronty mají pevnou velikost nebo kapacitu, což vede k přetečení nebo výjimkám při překročení maximální velikosti.Neefektivní vyhledávání:Hledání prvku ve frontě vyžaduje vyřazení z fronty, dokud není nalezena shoda, což má za následek lineární vyhledávání s potenciálně vysokou časovou složitostí.

Implementace:

Název souboru: 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ýstup:

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

6) HashMap:

HashMap je datová struktura v Javě, která poskytuje způsob, jak ukládat a získávat páry klíč-hodnota. Je součástí Java Collections Framework a je implementován na základě datové struktury hashovací tabulky.

Funkce:

    dát(klíč, hodnota):Vloží zadaný pár klíč–hodnota do HashMap.získat (klíč):Načte hodnotu spojenou se zadaným klíčem.obsahujeKey(klíč):Zkontroluje, zda HashMap obsahuje zadaný klíč.obsahujeValue(hodnota):Zkontroluje, zda HashMap obsahuje zadanou hodnotu.odstranit (klíč):Odebere pár klíč–hodnota spojený se zadaným klíčem z HashMap.velikost():Vrátí počet párů klíč–hodnota v HashMap.je prázdný():Zkontroluje, zda je HashMap prázdná.keySet():Vrátí sadu obsahující všechny klíče v HashMap.hodnoty():Vrátí kolekci obsahující všechny hodnoty v HashMap.Průhledná():Odstraní všechny páry klíč–hodnota z HashMap.

výhody:

    Efektivní vyhledávání:HashMap poskytuje rychlé načítání hodnot na základě klíčů s konstantní časovou složitostí O(1).Flexibilní párování klíč–hodnota:HashMap umožňuje použít jakýkoli nenulový objekt jako klíč, což umožňuje vlastní definované klíče pro ukládání a načítání dat.Dynamická velikost:HashMap může dynamicky růst nebo zmenšovat velikost, aby zvládla různá množství dat.Kompatibilita s Java Collections Framework:HashMap implementuje rozhraní Map, které umožňuje bezproblémovou integraci s ostatními třídami Collection.

Nevýhody:

    Nedostatek objednávek:HashMap nezachovává pořadí prvků. Pro specifické požadavky na objednávku použijte LinkedHashMap nebo TreeMap.Zvýšená paměťová zátěž:HashMap vyžaduje další paměť pro hash kódy a vnitřní strukturu ve srovnání s jednoduššími datovými strukturami.Pomalejší opakování:Iterace přes HashMap může být pomalejší ve srovnání s poli nebo seznamy kvůli procházení základní hashovací tabulky.

Implementace:

Název souboru: 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ýstup:

 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 datová struktura v Javě, která implementuje rozhraní Set a ukládá prvky do hashovací tabulky.

Funkce:

    Ukládá jedinečné prvky:HashSet neumožňuje duplicitní prvky. Každý prvek v HashSet je jedinečný.Používá vyhledávání založené na hash:HashSet používá hodnotu hash každého prvku k určení jeho umístění úložiště, což poskytuje efektivní načítání prvků.Neobjednaná kolekce:Prvky v HashSet nejsou uloženy v určitém pořadí. Pořadí prvků se může v průběhu času měnit.

výhody:

    Rychlé vyhledávání prvků:HashSet poskytuje rychlé vyhledávací operace, takže je efektivní kontrolovat, zda prvek v sadě existuje.Žádné duplicitní prvky:HashSet automaticky zpracovává duplicitní prvky a zajišťuje, že každý prvek je jedinečný.Integrace s Java Collections Framework:HashSet implementuje rozhraní Set, takže je kompatibilní s ostatními třídami kolekcí v Java Collections Framework.

Nevýhody:

font gimp
    Žádná zaručená objednávka:HashSet neuchovává pořadí prvků. Pokud je důležité pořadí prvků, HashSet není vhodný.Žádné indexování:HashSet neposkytuje přímé indexování ani poziční přístup k prvkům. Chcete-li získat přístup k prvkům, musíte sadu iterovat.Vyšší paměťová zátěž:HashSet vyžaduje další paměť pro ukládání hodnot hash a udržování struktury hash tabulky, což má za následek vyšší využití paměti ve srovnání s některými jinými datovými strukturami.

Implementace:

Název souboru: 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ýstup:

 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 stromů:

TreeSet je implementace rozhraní SortedSet v Javě, která používá samovyvažující binární vyhledávací strom nazývaný červeno-černý strom k ukládání prvků v seřazeném pořadí.

výhody:

    Seřazené pořadí:TreeSet automaticky udržuje prvky v seřazeném pořadí na základě jejich přirozeného řazení nebo vlastního komparátoru. Umožňuje efektivní vyhledávání a načítání prvků ve vzestupném nebo sestupném pořadí.Žádné duplicitní prvky:TreeSet neumožňuje duplicitní prvky. Zajišťuje, že každý prvek v sadě je jedinečný, což může být užitečné ve scénářích, kde je třeba se vyhnout duplicitním hodnotám.Efektivní operace:TreeSet poskytuje efektivní operace, jako je vkládání, mazání a vyhledávání. Tyto operace mají časovou složitost O(log n), kde n je počet prvků v množině.Operace navigační sady:TreeSet poskytuje další navigační metody, jako je vyšší(), nižší(), strop() a podlaha(), které umožňují najít prvky, které jsou větší, menší nebo rovné dané hodnotě.

Nevýhody:

    Režie:TreeSet vyžaduje další paměť pro uložení vnitřní datové struktury, což může vést k vyšší paměťové režii ve srovnání s implementacemi jiných sad.Pomalejší vkládání a vyjímání:Operace vkládání a odebírání v TreeSet zahrnují udržování setříděného pořadí prvků, což může vyžadovat restrukturalizaci stromu. Může tyto operace mírně zpomalit ve srovnání s HashSet nebo LinkedHashSet.Omezené přizpůsobení:TreeSet je primárně určen pro přirozené řazení nebo jeden vlastní komparátor. Může vyžadovat větší flexibilitu pro více kritérií třídění nebo složitou logiku třídění.

Funkce:

    přidat (prvek):Přidá prvek do TreeSet při zachování seřazeného pořadí.odstranit (prvek):Odebere zadaný prvek ze sady stromů.obsahuje (prvek):Zkontroluje, zda sada TreeSet obsahuje zadaný prvek.velikost():Vrátí počet prvků ve stromové sadě.První():Vrátí první (nejnižší) prvek v sadě stromů.poslední():Vrátí poslední (nejvyšší) prvek v sadě stromů.vyšší (prvek):Vrátí nejmenší prvek v sadě stromů, který je přísně větší než daný prvek.nižší (prvek):Vrátí největší prvek v sadě stromů, který je přísně menší než daný prvek.

Implementace:

Název souboru: TreeSetExample.java

java získává aktuální datum
 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ýstup:

 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 třída v Javě, která implementuje rozhraní Map a poskytuje seřazené mapování klíč-hodnota na základě přirozeného pořadí klíčů nebo vlastního komparátoru.

výhody:

    Seřazené řazení:TreeMap udržuje klíče v seřazeném pořadí, což umožňuje efektivní vyhledávání, načítání a operace založené na rozsahu.Mapování klíč-hodnota:TreeMap ukládá páry klíč-hodnota, což umožňuje efektivní vyhledávání a načítání hodnot na základě přidružených klíčů.Realizace červeno-černého stromu:TreeMap interně používá vyvážený binární vyhledávací strom (Red-Black Tree), který zajišťuje efektivní výkon i pro velké datové sady.Podpora pro vlastní komparátory:TreeMap umožňuje použití vlastních komparátorů k definování pořadí řazení klíčů, což poskytuje flexibilitu v kritériích řazení.

Nevýhody:

    Režie paměti:TreeMap vyžaduje další paměť pro uložení vnitřní stromové struktury a souvisejících objektů, což má za následek vyšší využití paměti ve srovnání s jednoduššími datovými strukturami, jako je HashMap.Pomalejší vkládání a mazání:Operace vkládání a mazání v TreeMap mají časovou složitost O(log n) kvůli potřebě restrukturalizace stromu, takže jsou pomalejší ve srovnání s HashMap nebo LinkedHashMap.Omezený výkon pro netříděná data:TreeMap funguje efektivně pro setříděná data, ale její výkon se může zhoršit při práci s netříděnými daty nebo častými úpravami, protože vyžaduje zachování setříděného pořadí.

Funkce:

    dát(klíč, hodnota):Vloží pár klíč–hodnota do stromové mapy.získat (klíč):Načte hodnotu spojenou se zadaným klíčem.obsahujeKey(klíč):Zkontroluje, zda stromová mapa obsahuje konkrétní klíč.odstranit (klíč):Odebere pár klíč–hodnota spojený se zadaným klíčem.velikost():Vrátí počet párů klíč–hodnota ve stromové mapě.keySet():Vrátí sadu všech klíčů ve stromové mapě.hodnoty():Vrátí kolekci všech hodnot ve stromové mapě.entrySet():Vrátí sadu párů klíč–hodnota ve stromové mapě.

Implementace:

Název souboru: 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ýstup:

 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 jsou datové struktury, které představují kolekci vzájemně propojených uzlů nebo vrcholů. Skládají se z vrcholů a hran, kde vrcholy představují entity a hrany představují vztahy mezi těmito entitami.

výhody:

    Všestrannost:Grafy mohou představovat širokou škálu scénářů reálného světa, díky čemuž jsou vhodné pro různé aplikace, jako jsou sociální sítě, dopravní systémy a počítačové sítě.Zastoupení vztahu:Grafy poskytují přirozený způsob, jak reprezentovat vztahy a spojení mezi entitami, což umožňuje efektivní analýzu a procházení těchto vztahů.Efektivní vyhledávání a procházení:Algoritmy grafů jako prohledávání do šířky (BFS) a prohledávání do hloubky (DFS) umožňují efektivní procházení a prohledávání vrcholů a hran grafu.Modelování komplexních vztahů:Grafy mohou modelovat složité vztahy, včetně hierarchických struktur, cyklických závislostí a vícenásobných spojení mezi entitami.

Nevýhody:

    Prostorová složitost:Grafy mohou spotřebovat značné množství paměti, zejména grafy ve velkém měřítku s mnoha vrcholy a hranami.Složitost operací:Některé operace s grafy, jako je nalezení nejkratší cesty nebo detekce cyklů, mohou být časově velmi složité, zejména v hustých grafech.Obtížnost údržby:Úprava nebo aktualizace grafu může být složitá, protože změny ve struktuře grafu mohou ovlivnit jeho konektivitu a existující algoritmy.

Implementace:

Název souboru: 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 široce používaná datová struktura v informatice, která představuje hierarchickou strukturu. Skládá se z uzlů spojených hranami, kde každý uzel může mít nula nebo více podřízených uzlů.

výhody:

    Hierarchická struktura:Stromy poskytují přirozený způsob, jak reprezentovat hierarchické vztahy, jako jsou systémy souborů, organizační schémata nebo dokumenty HTML/XML.Efektivní vyhledávání:Binární vyhledávací stromy umožňují efektivní vyhledávání s časovou složitostí O(log n), díky čemuž jsou vhodné pro ukládání a získávání setříděných dat.Rychlé vkládání a mazání:Stromové datové struktury nabízejí efektivní operace vkládání a mazání, zvláště když jsou vyvážené, jako jsou stromy AVL nebo stromy Red-Black.Objednaná iterace:Procházení binárního vyhledávacího stromu v pořadí poskytuje prvky v seřazeném pořadí, což je užitečné pro úkoly, jako je tisk prvků v seřazeném pořadí nebo hledání dalšího/předchozího prvku.

Nevýhody:

    Vysoká paměťová zátěž:Stromy vyžadují dodatečnou paměť pro ukládání odkazů na uzly nebo ukazatelů, což může vést k vyššímu využití paměti ve srovnání s lineárními datovými strukturami, jako jsou pole nebo seznamy.Komplexní implementace:Implementace a údržba stromové datové struktury může být složitější ve srovnání s jinými datovými strukturami, jako jsou pole nebo seznamy, zejména u variant vyvážených stromů.Omezený provoz:Některé varianty stromu, jako jsou binární vyhledávací stromy, nepodporují efektivní operace, jako je nalezení k-tého nejmenšího prvku nebo nalezení hodnosti prvku.

Funkce:

    Vložení:Přidejte do stromu nový uzel.Vymazání:Odstraňte uzel ze stromu.Vyhledávání:Najděte konkrétní uzel nebo prvek ve stromu.Průjezd:Procházejte strom v různých pořadích, jako je pořadí, předobjednávka nebo po objednávce.Výška/hloubka:Vypočítejte výšku nebo hloubku stromu.Zůstatek:Zajistěte, aby strom zůstal vyvážený, aby byly zachovány efektivní operace.

Implementace:

Název souboru: 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)>