logo

Struktury danych w Javie

Liczne sposoby porządkowania, zapisywania i przetwarzania danych w programie komputerowym nazywane są w języku Java strukturami danych. Struktury te oferują metodyczną metodę efektywnej obsługi i zarządzania danymi, umożliwiając przydatne operacje, takie jak wstawianie, usuwanie, pobieranie i przeglądanie.

W artykule omówimy wszystko, co jest związane ze strukturami danych w Javie, co pomoże początkującym zrozumieć je łatwo i skutecznie.

  • Co to jest Java?
  • Czym są struktury danych w Javie?
  • Typy struktur danych w Javie
  • Zalety struktur danych w Javie
  • Klasyfikacja struktur danych
  • Struktury danych w Javie — często zadawane pytania

Co to jest Java?

Java to popularny obiektowy język programowania, znany z ogromnej biblioteki standardowej i swobody działania platformy. Oferuje solidną architekturę do tworzenia programów działających bez rekompilacji na różnych platformach. Dobrze znana biblioteka dla języka Java oferuje wybór systemów rekordów, które umożliwiają efektywne radzenie sobie z wieloma typami danych.

Czym są struktury danych w Javie?

Sposób, w jaki dane są zorganizowane i przechowywane w pamięci programu komputerowego, zależy ściśle od struktur rekordów Java. Dobrze znana biblioteka Java zawiera znaczną liczbę wbudowanych struktur statystycznych. Do kilku systemów rekordów, które pozwalają programistom na krótkie i proste sposoby zapisywania i porządkowania danych, zaliczają się połączone listy, stosy, kolejki i tablice. Programiści mogą szybko wykonywać operacje, takie jak wstawianie, usuwanie, wyszukiwanie i sortowanie, ponieważ zapewniają szereg mechanizmów uzyskiwania dostępu do danych, modyfikowania ich i zarządzania nimi. Korzystając z tych struktur danych, programiści Java mogą zmniejszyć zużycie pamięci i znacznie zwiększyć ogólną wydajność swoich programów.

Typy struktur danych w Javie

Lista struktur danych w Javie znajduje się poniżej

  1. Tablice
  2. Lista tablic
  3. Połączona lista
  4. Stos
  5. Kolejka
  6. HashMapa
  7. Zestaw skrótów
  8. Zestaw drzew
  9. Mapa Drzewa
  10. Wykres
  11. Drzewo

Poniższy diagram bardzo wyraźnie wyjaśnia typy struktur danych w Javie.

Struktury danych w Javie

Dalsza klasyfikacja typów struktur danych:

Istnieją dwa typy struktur danych: -

  1. Prymitywne struktury danych
  2. Nieprymitywne struktury danych

1) Prymitywne struktury danych: Są to podstawowe, wbudowane typy danych, zwane także prymitywnymi typami danych. Zawierają:

    Bajt:Przechowuje liczby całkowite od -128 do 127.krótki:Przechowuje liczby całkowite od -32 768 do 32 767.int:Przechowuje liczby całkowite od -2 147 483 648 do 2 147 483 647.platforma:Przechowuje liczby zmiennoprzecinkowe z pojedynczą precyzją.zwęglać:Przechowuje pojedyncze znaki.wartość logiczna:Przechowuje wartości prawdziwe lub fałszywe.długi:Przechowuje duże liczby całkowite.Podwójnie:Przechowuje liczby zmiennoprzecinkowe z podwójną precyzją.

2) Nieprymitywne struktury danych: Struktury rekordów nieprymitywnych są bardziej złożone i składają się z prymitywnych rodzajów informacji. Można je dodatkowo podzielić na dwa rodzaje:

    Liniowe struktury danych:W liniowych strukturach danych elementy są ułożone liniowo lub sekwencyjnie. Przykłady obejmują:
      Tablice:Grupa identycznie typowanych elementów umieszczonych w szyku według z góry ustalonego układu.Półki na książki:Struktura „ostatnie weszło, pierwsze wyszło” (LIFO), w której można dodawać lub usuwać tylko elementy znajdujące się na samej górze.Ogony:W kolejkach stosowane są struktury „pierwszy na wejściu, pierwszy na wyjściu” (FIFO), w których pozycje są wkładane po zwróceniu i wyjmowane z przodu.Połączona lista:Powiązana lista zawiera zbiór gadżetów zwanych węzłami, z których każdy zawiera odwołanie do węzła i zawarte w nim statystyki.
    Nieliniowe struktury danych:W nieliniowych strukturach danych elementy są ułożone niesekwencyjnie. Przykłady obejmują:
      Drzewa:Drzewa to rodzaj hierarchicznej struktury opartej na węzłach, z węzłem głównym na górze i węzłami podrzędnymi odchodzącymi od niego. Przykładami są drzewa czerwono-czarne, drzewa AVL, drzewa wyszukiwania binarnego i drzewa binarne.Wykresy:Zbiór węzłów połączonych krawędziami, przy czym węzły mogą mieć dowolną liczbę połączeń. Wykresy służą do symbolizowania złożonych relacji między elementami.Sterta:Wyspecjalizowana struktura oparta na drzewie, w której każdy określony węzeł ma wartość większą lub mniejszą niż jego dzieci, w zależności od tego, czy jest to sterta maksymalna czy minimalna.Haszysz:Struktury danych korzystające z funkcji skrótu do mapowania kluczy na wartości. Przykładami są zestawy skrótów i mapy skrótów, które zapewniają zielone pobieranie i przechowywanie statystyk w oparciu o precyzyjne klucze.
Struktury danych w Javie

Zalety struktur danych w Javie

    Efektywna organizacja danych:Struktury danych zapewniają zorganizowane sposoby przechowywania danych i zarządzania nimi, umożliwiając efektywny dostęp, manipulację i operacje wyszukiwania. Optymalizują wykorzystanie pamięci i ułatwiają szybsze wykonywanie algorytmów.Lepsza wydajność:Programiści mogą poprawić wydajność pod względem szybkości i wykorzystania pamięci, wybierając odpowiednią strukturę danych dla konkretnego działania. Wydajność jest zoptymalizowana, ponieważ określone struktury danych są przystosowane do określonych działań, takich jak wyszukiwanie, sortowanie lub wstawianie informacji.Możliwość ponownego wykorzystania kodu:Java oferuje szeroką gamę wbudowanych struktur danych, które są proste w użyciu dla programistów. Te struktury danych wielokrotnego użytku oszczędzają czas i wysiłek, eliminując potrzebę tworzenia od podstaw skomplikowanych algorytmów.Prostota kodu:Struktury danych ułatwiają kodowanie skomplikowanych procesów. Oferują abstrakcje wysokiego poziomu i hermetyzują specyfikę zarządzania danymi, co poprawia czytelność, łatwość konserwacji i przejrzystość kodu.Elastyczność i zdolność adaptacji:Struktury danych oferują elastyczność w obsłudze różnych typów i rozmiarów danych. Mogą dynamicznie dostosowywać się do zmieniających się wymagań dotyczących danych i zapewniać mechanizmy efektywnej manipulacji danymi.Standaryzowane i dobrze przetestowane:Standardowa biblioteka Java zawiera wbudowane struktury danych, które przeszły znaczące testy i optymalizację, gwarantując ich niezawodność i wydajność. Wykorzystanie tych wspólnych struktur danych zmniejsza ryzyko błędów i zapewnia solidne podstawy do tworzenia aplikacji.Skalowalność:Struktury danych zapewniają opcje skalowalności, umożliwiając aplikacjom wydajną obsługę dużych ilości danych. Mogą dynamicznie rosnąć lub zmniejszać się w zależności od rozmiaru danych, zapewniając optymalną wydajność nawet przy rosnącym zapotrzebowaniu na dane.Projekt algorytmu:Struktury danych mają kluczowe znaczenie w projektowaniu i analizie algorytmów. Zapewniają podstawową strukturę i operacje niezbędne do implementowania różnych algorytmów i rozwiązywania złożonych problemów.

1) Tablice:

Tablica to podstawowa i często używana struktura danych w kontekście struktur danych Java. Oferuje metodę przechowywania kolekcji komponentów identycznego typu o stałym rozmiarze. Ponieważ zapewniają szybki i łatwy dostęp do elementów w zależności od ich indeksu, tablice są kluczowym narzędziem do zarządzania i organizowania danych.

Zalety:

    Organizacja danych:Tablice zapewniają uporządkowany sposób przechowywania i organizowania elementów, usprawniając zarządzanie danymi.Losowy dostęp:Dostęp do elementów można uzyskać bezpośrednio za pomocą ich indeksu, co pozwala na efektywne wyszukiwanie i modyfikację.Naprawiono rozmiar:Tablice mają z góry określony rozmiar, co umożliwia efektywną alokację pamięci.Elementy jednorodne:Tablice przechowują elementy tego samego typu, zapewniając spójność danych i upraszczając operacje.Iteracja:Tablice umożliwiają łatwą iterację elementów, ułatwiając przechodzenie i przetwarzanie.Sortowanie i wyszukiwanie:Tablice dobrze współpracują z algorytmami sortowania i wyszukiwania, oferując wydajne operacje.Wydajność pamięci:Tablice optymalizują wykorzystanie pamięci, przechowując elementy w sąsiadujących regionach.Zgodność:Tablice są szeroko obsługiwane w Javie, dzięki czemu są kompatybilne z różnymi frameworkami i narzędziami.

Niedogodności:

    Naprawiono rozmiar:Tablic nie można dynamicznie zmieniać rozmiaru, co wymaga odtworzenia w celu zmiany rozmiaru.Zużycie pamięci:Nieużywane elementy w większych tablicach mogą prowadzić do marnowania pamięci.Koszty wstawiania i usuwania:Wstawianie lub usuwanie elementów w środku tablicy wymaga przesuwania kolejnych elementów, co skutkuje nieefektywnością.Brak elastyczności:Tablice mają sztywne typy danych i nie mogą pomieścić różnych typów danych bez dodatkowych tablic lub struktur danych.

Funkcje:

    Tworzenie tablicy:Zadeklaruj i zainicjuj tablicę o określonym rozmiarze, używając typu tablicy i słowa kluczowego new.Dostęp do elementów:Użyj indeksu, aby uzyskać dostęp do poszczególnych elementów tablicy.Modyfikowanie elementów:Zaktualizuj wartość elementu, przypisując nową wartość do określonego indeksu w tablicy.Znalezienie długości:Użyj atrybutu długości, aby określić długość tablicy.Iteracja po tablicy:Użyj pętli, aby przejść przez każdy element tablicy i wykonać

Realizacja:

Nazwa pliku: 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) Lista tablic:

ArrayList w Javie to dynamiczna struktura danych, która pozwala na przechowywanie i manipulowanie elementami. Jest częścią Java Collections Framework i jest implementowany wewnętrznie przy użyciu tablicy.

Zalety:

    Rozmiar dynamiczny:W przeciwieństwie do tablic, ArrayLists mogą dynamicznie zwiększać się lub zmniejszać w miarę dodawania lub usuwania elementów. Eliminuje potrzebę ręcznej zmiany rozmiaru i umożliwia wygodną obsługę różnych ilości danych.Łatwa manipulacja elementami:ArrayLists oferują metody dodawania, usuwania i modyfikowania elementów w dowolnej pozycji na liście. Jego elastyczność upraszcza typowe operacje, takie jak wstawianie, usuwanie i aktualizacja, dzięki czemu manipulacja elementami jest bardziej wydajna.Losowy dostęp:ArrayLists obsługują losowy dostęp do elementów przy użyciu ich indeksu, umożliwiając szybkie wyszukiwanie i modyfikację elementów w określonych pozycjach na liście. Ułatwia skuteczny dostęp do elementów i poprawia ogólną wydajność.Zgodność z platformą zbierania Java:ArrayLists implementują interfejs List, dzięki czemu są kompatybilne z innymi klasami kolekcji w Java Collections Framework. Jego kompatybilność pozwala na bezproblemową integrację z różnymi algorytmami i operacjami udostępnianymi przez framework.

Niedogodności:

    Wyższe obciążenie pamięci:ArrayLists wymagają dodatkowej pamięci, aby utrzymać swoją wewnętrzną strukturę, co skutkuje większym obciążeniem pamięci w porównaniu z tablicami. Może to stanowić problem w przypadku dużych kolekcji elementów.Wolniejsze wstawianie i usuwanie:Wstawianie lub usuwanie elementów w środku ArrayList wymaga przesuwania elementów, co może być czasochłonne w przypadku dużych list. W scenariuszach, w których oczekuje się częstych operacji wstawiania lub usuwania, inne struktury danych, takie jak LinkedList, mogą zapewniać lepszą wydajność.Ograniczona wydajność wyszukiwania:Wyszukiwanie elementu w nieposortowanej ArrayList wymaga iteracji po elementach, aż do znalezienia dopasowania. Jest to podejście do wyszukiwania liniowego, które skutkuje mniejszą wydajnością wyszukiwania w porównaniu ze strukturami danych zoptymalizowanymi pod kątem wyszukiwania, takimi jak HashSet lub TreeMap.Brak obsługi typów pierwotnych:ArrayLists mogą przechowywać tylko obiekty i nie obsługują bezpośrednio prymitywnych typów danych, takich jak int lub char. Aby przechowywać typy pierwotne, należy użyć klas opakowań, takich jak Integer lub Character, co prowadzi do potencjalnego obciążenia związanego z automatycznym pakowaniem i rozpakowywaniem.

Funkcje:

Podstawowe informacje o kompilacji Ubuntu
    Tworzenie listy tablic:Zadeklaruj i zainicjuj ArrayList przy użyciu klasy ArrayList i określ typ elementu w nawiasach ostrych.Dodawanie elementów:Użyj metody add, aby dołączyć elementy na końcu listy ArrayList.Dostęp do elementów:Użyj techniki get, aby pobrać cenę szczegółu w wybranym indeksie.Modyfikowanie elementów:Zaktualizuj koszt szczegółów według określonego indeksu w celu zastosowania ustalonego podejścia.Znalezienie rozmiaru:Użyj metody wymiarów, aby uzyskać najnowocześniejszą liczbę czynników w ArrayList.Usuwanie elementów:Użyj metody usuwania, aby usunąć szczegół pod określonym indeksem lub poprzez podanie odniesienia do obiektu.Iteracja po ArrayList:Użyj pętli, aby iterować po każdym elemencie ArrayList i wykonywać na nich operacje.

Realizacja:

Nazwa pliku: 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); } } } 

Wyjście:

 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) Połączona lista:

Lista połączona to liniowa struktura danych, w której elementy są przechowywane w oddzielnych obiektach zwanych węzłami. Link referencyjny do kolejnego węzła w sekwencji jest zawarty w elemencie danych każdego węzła. Ostatni węzeł listy łączy się z wartością null, co oznacza, że ​​lista się zakończyła.

W przeciwieństwie do tablic, listy połączone nie wymagają ciągłej alokacji pamięci. Każdy węzeł na połączonej liście może być przydzielany niezależnie, co pozwala na dynamiczną alokację pamięci oraz wydajne operacje wstawiania i usuwania.

Zalety:

    Rozmiar dynamiczny:LinkedList może dynamicznie rosnąć lub zmniejszać się, dzięki czemu nadaje się do różnych lub nieznanych rozmiarów danych.Efektywne wstawianie i usuwanie:Wstawianie lub usuwanie elementów w obrębie listy LinkedList jest wydajne, ponieważ nie wymaga przesuwania elementów.Brak wymagań dotyczących ciągłej pamięci:LinkedList nie wymaga ciągłej alokacji pamięci, dzięki czemu jest elastyczny i nadaje się do nieprzewidywalnych sytuacji związanych z pamięcią.Łatwa modyfikacja:LinkedList pozwala na łatwą modyfikację elementów poprzez zmianę wskaźników referencyjnych, umożliwiając sprawną manipulację.

Niedogodności:

    Wolniejszy dostęp losowy:LinkedList ma wolniejszy dostęp losowy, ponieważ wymaga przechodzenia po liście w celu uzyskania dostępu do elementów według indeksu.Zwiększone obciążenie pamięci:LinkedList wymaga dodatkowej pamięci na odniesienia i węzły, co zwiększa obciążenie pamięci w porównaniu z tablicami.Nieefektywne wyszukiwanie:LinkedList ma wolniejsze operacje wyszukiwania, co wymaga sekwencyjnej iteracji w celu znalezienia określonych elementów.

Funkcje:

    Tworzenie połączonej listy:Zadeklaruj i zainicjuj listę LinkedList przy użyciu klasy LinkedList.Dodawanie elementów:Użyj metody add, aby dołączyć elementy na końcu listy LinkedList.Dostęp do elementów:Użyj metody get, aby pobrać wartość elementu o określonym indeksie.Modyfikowanie elementów:Zaktualizuj wartość elementu w określonym indeksie, używając metody set.Usuwanie elementów:Użyj metody usuwania, aby usunąć element o określonym indeksie lub podając odwołanie do obiektu.

Realizacja:

Nazwa pliku: 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); } } 

Wyjście:

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

Zasada LIFO (ostatni na wejściu, pierwsza na wyjściu) stanowi, że element wstawiany jako ostatni jest jednocześnie elementem usuwanym jako pierwszy. Stos to liniowa struktura danych, która podlega tej regule. Wykorzystuje polecenia „push” i „pop” do dodawania elementów do stosu i w związku z tym usuwania górnego elementu ze stosu. Technika „peek” dodatkowo umożliwia dostęp do górnego elementu bez jego wyjmowania.

Cechy stosu:

    Zachowanie LIFO:Ostatni element wsuwany na stos jest pierwszym, który wyskakuje, dzięki czemu nadaje się do zastosowań, w których istotna jest kolejność wkładania i wyjmowania.Ograniczony dostęp:Stosy zazwyczaj zapewniają ograniczony dostęp do elementów. Dostęp można uzyskać tylko do najwyższego elementu. Aby dotrzeć do innych elementów, należy przesunąć elementy znajdujące się nad nimi.Rozmiar dynamiczny:Stosy można implementować za pomocą tablic lub list połączonych, co pozwala na dynamiczny rozmiar. Mogą rosnąć lub zmniejszać się w miarę potrzeb w czasie wykonywania.

Zalety:

    Prostota:Stosy są łatwe do zrozumienia i wdrożenia.Efektywność:Operacje wstawiania i usuwania mają złożoność czasową O(1).Zarządzanie wywołaniami funkcji:Stosy efektywnie zarządzają wywołaniami funkcji i pamięcią zmiennych.Funkcja Cofnij/Ponów:Stosy umożliwiają operacje cofania i ponawiania w aplikacjach.

Niedogodności:

    Ograniczony dostęp:Dostęp do elementów jest ograniczony do góry stosu.Ograniczenia dotyczące rozmiaru:Stosy mogą mieć ograniczenia rozmiaru w zależności od implementacji.Nie nadaje się do wszystkich scenariuszy:Stosy są specyficzne dla zachowania LIFO i mogą nie być odpowiednie w innych przypadkach.

Realizacja:

Nazwa pliku: 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); } } } 

Wyjście:

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

5) Kolejka:

Kolejka to liniowa struktura danych w języku Java zgodna z zasadą „pierwszy na wejściu, pierwszy na wyjściu” (FIFO). Reprezentuje zbiór elementów, w których elementy są wkładane z tyłu i usuwane z przodu.

cout

Cechy:

    Kolejka:Dodanie elementu na końcu kolejki.Usuń z kolejki:Usunięcie elementu z przodu kolejki.Zerkać:Pobierz element z przodu kolejki bez jego usuwania.Rozmiar:Ustalanie ilości elementów w kolejce.Pusty czek:Sprawdzanie, czy kolejka jest pusta.

Zalety:

    Zachowanie FIFO:Elementy przetwarzane są w kolejności ich wstawiania, zapewniając zachowanie oryginalnej sekwencji.Skuteczne wkładanie i wyjmowanie:Dodawanie i usuwanie elementów z kolejki jest szybkie i ma stałą złożoność czasową O(1).Synchronizacja:Java zapewnia implementacje zsynchronizowanych kolejek, dzięki czemu są bezpieczne dla programowania współbieżnego.Znormalizowany interfejs:Interfejs kolejki w Javie oferuje wspólny zestaw metod, umożliwiający łatwą wymienność pomiędzy różnymi implementacjami kolejek.

Niedogodności:

    Brak losowego dostępu:Kolejki nie obsługują bezpośredniego dostępu do elementów znajdujących się w środku. Dostęp do określonych pozycji wymaga usunięcia z kolejki poprzednich elementów.Ograniczony rozmiar:Niektóre implementacje kolejek mają stały rozmiar lub pojemność, co prowadzi do przepełnienia lub wyjątków w przypadku przekroczenia maksymalnego rozmiaru.Nieefektywne wyszukiwanie:Wyszukiwanie elementu w kolejce wymaga usunięcia z kolejki do momentu znalezienia dopasowania, co skutkuje wyszukiwaniem liniowym o potencjalnie dużej złożoności czasowej.

Realizacja:

Nazwa pliku: Przykład kolejki.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); } } } 

Wyjście:

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

6) Mapa skrótów:

HashMap to struktura danych w Javie, która umożliwia przechowywanie i pobieranie par klucz-wartość. Jest częścią Java Collections Framework i jest zaimplementowany w oparciu o strukturę danych tabeli mieszającej.

Funkcje:

    put(klucz, wartość):Wstawia określoną parę klucz-wartość do HashMap.Weź klucz):Pobiera wartość skojarzoną z określonym kluczem.zawieraKlucz (klucz):Sprawdza, czy HashMap zawiera określony klucz.zawieraWartość(wartość):Sprawdza, czy HashMap zawiera określoną wartość.usuń (klucz):Usuwa parę klucz-wartość skojarzoną z określonym kluczem z HashMap.rozmiar():Zwraca liczbę par klucz-wartość w HashMap.jest pusty():Sprawdza, czy HashMap jest pusty.zestaw kluczy():Zwraca zestaw zawierający wszystkie klucze w HashMap.wartości():Zwraca kolekcję zawierającą wszystkie wartości w HashMap.jasne():Usuwa wszystkie pary klucz-wartość z HashMap.

Zalety:

    Efektywne pobieranie:HashMap zapewnia szybkie pobieranie wartości w oparciu o klucze o stałej złożoności czasowej O(1).Elastyczne parowanie klucz-wartość:HashMap dopuszcza dowolny obiekt inny niż null jako klucz, umożliwiając niestandardowe zdefiniowane klucze do przechowywania i pobierania danych.Rozmiar dynamiczny:HashMap może dynamicznie zwiększać się lub zmniejszać, aby obsługiwać różne ilości danych.Zgodność z platformą Java Collections Framework:HashMap implementuje interfejs Map, umożliwiając bezproblemową integrację z innymi klasami Collection.

Niedogodności:

    Brak kolejności:HashMap nie zachowuje kolejności elementów. Użyj LinkedHashMap lub TreeMap, aby spełnić określone wymagania dotyczące zamówień.Zwiększone obciążenie pamięci:HashMap wymaga dodatkowej pamięci na kody mieszające i strukturę wewnętrzną w porównaniu do prostszych struktur danych.Wolniejsza iteracja:Iteracja po HashMap może być wolniejsza w porównaniu z tablicami lub listami z powodu przechodzenia przez podstawową tabelę mieszającą.

Realizacja:

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

Wyjście:

 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) Zestaw skrótów:

HashSet to struktura danych w Javie, która implementuje interfejs Set i przechowuje elementy w tabeli mieszającej.

Cechy:

    Przechowuje unikalne elementy:HashSet nie pozwala na duplikaty elementów. Każdy element w HashSet jest unikalny.Używa wyszukiwania opartego na skrótach:HashSet wykorzystuje wartość skrótu każdego elementu do określenia jego lokalizacji przechowywania, zapewniając wydajne pobieranie elementów.Kolekcja nieuporządkowana:Elementy w HashSet nie są przechowywane w określonej kolejności. Kolejność elementów może zmieniać się z biegiem czasu.

Zalety:

    Szybkie wyszukiwanie elementów:HashSet zapewnia szybkie operacje wyszukiwania, dzięki czemu można skutecznie sprawdzić, czy element istnieje w zestawie.Brak duplikatów elementów:HashSet automatycznie obsługuje zduplikowane elementy i zapewnia, że ​​każdy element jest unikalny.Integracja z frameworkiem Java Collections:HashSet implementuje interfejs Set, dzięki czemu jest kompatybilny z innymi klasami kolekcji w Java Collections Framework.

Niedogodności:

zmień nazwę katalogu Linux
    Brak gwarantowanego zamówienia:HashSet nie utrzymuje kolejności elementów. Jeśli kolejność elementów jest ważna, HashSet nie jest odpowiedni.Bez indeksowania:HashSet nie zapewnia bezpośredniego indeksowania ani pozycyjnego dostępu do elementów. Aby uzyskać dostęp do elementów, musisz iterować po zestawie.Większe obciążenie pamięci:HashSet wymaga dodatkowej pamięci do przechowywania wartości skrótu i ​​utrzymywania struktury tabeli skrótów, co skutkuje większym zużyciem pamięci w porównaniu z niektórymi innymi strukturami danych.

Realizacja:

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

Wyjście:

 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) Zestaw drzew:

TreeSet to implementacja interfejsu SortedSet w języku Java, która wykorzystuje samobalansujące drzewo wyszukiwania binarnego zwane drzewem czerwono-czarnym do przechowywania elementów w posortowanej kolejności.

Zalety:

    Posortowana kolejność:TreeSet automatycznie utrzymuje elementy w posortowanej kolejności w oparciu o ich naturalną kolejność lub niestandardowy komparator. Pozwala na sprawne wyszukiwanie i pobieranie elementów w kolejności rosnącej lub malejącej.Brak zduplikowanych elementów:TreeSet nie pozwala na powielanie elementów. Zapewnia to, że każdy element w zestawie jest unikalny, co może być przydatne w scenariuszach, w których należy unikać duplikatów wartości.Wydajne operacje:TreeSet zapewnia wydajne operacje, takie jak wstawianie, usuwanie i wyszukiwanie. Operacje te mają złożoność czasową O(log n), gdzie n jest liczbą elementów w zbiorze.Operacje na zestawach żeglownych:TreeSet udostępnia dodatkowe metody nawigacyjne, takie jak wyższa(), niższa(), sufit() i podłoga(), które pozwalają znaleźć elementy większe, mniejsze lub równe danej wartości.

Niedogodności:

    Nad głową:TreeSet wymaga dodatkowej pamięci do przechowywania wewnętrznej struktury danych, co może prowadzić do większego obciążenia pamięci w porównaniu z innymi implementacjami zestawów.Wolniejsze zakładanie i wyjmowanie:Operacje wstawiania i usuwania w TreeSet obejmują zachowanie posortowanej kolejności elementów, co może wymagać restrukturyzacji drzewa. Może sprawić, że te operacje będą nieco wolniejsze w porównaniu do HashSet lub LinkedHashSet.Ograniczone dostosowywanie:TreeSet jest przeznaczony przede wszystkim do naturalnego porządkowania lub pojedynczego niestandardowego komparatora. Może wymagać większej elastyczności w przypadku wielu kryteriów sortowania lub złożonej logiki sortowania.

Funkcje:

    dodaj(element):Dodaje element do TreeSet, zachowując porządek posortowania.usuń(element):Usuwa określony element z TreeSet.zawiera(element):Sprawdza, czy TreeSet zawiera określony element.rozmiar():Zwraca liczbę elementów w TreeSet.Pierwszy():Zwraca pierwszy (najniższy) element w TreeSet.ostatni():Zwraca ostatni (najwyższy) element w TreeSet.wyższy(element):Zwraca najmniejszy element w TreeSet, który jest ściśle większy niż podany element.niższy(element):Zwraca największy element w TreeSet, który jest ściśle mniejszy niż podany element.

Realizacja:

Nazwa pliku: 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); } } } 

Wyjście:

co to jest hibernacja
 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) Mapa Drzewa:

TreeMap to klasa w języku Java, która implementuje interfejs Map i zapewnia posortowane mapowanie klucz-wartość w oparciu o naturalną kolejność kluczy lub niestandardowy komparator.

Zalety:

    Sortowanie kolejności:TreeMap utrzymuje klucze w posortowanej kolejności, co pozwala na wydajne wyszukiwanie, odzyskiwanie i operacje oparte na zakresach.Mapowanie klucz-wartość:TreeMap przechowuje pary klucz-wartość, umożliwiając efektywne wyszukiwanie i pobieranie wartości w oparciu o powiązane klucze.Implementacja drzewa czerwono-czarnego:TreeMap wykorzystuje wewnętrznie zrównoważone drzewo wyszukiwania binarnego (czerwono-czarne drzewo), zapewniając wydajną wydajność nawet w przypadku dużych zbiorów danych.Obsługa niestandardowych komparatorów:TreeMap umożliwia użycie niestandardowych komparatorów w celu zdefiniowania kolejności sortowania kluczy, zapewniając elastyczność w zakresie kryteriów sortowania.

Niedogodności:

    Narzut pamięci:TreeMap wymaga dodatkowej pamięci do przechowywania wewnętrznej struktury drzewa i powiązanych obiektów, co skutkuje większym zużyciem pamięci w porównaniu z prostszymi strukturami danych, takimi jak HashMap.Wolniejsze wstawianie i usuwanie:Operacje wstawiania i usuwania w TreeMap mają złożoność czasową O(log n) ze względu na potrzebę restrukturyzacji drzewa, co czyni je wolniejszymi w porównaniu do HashMap lub LinkedHashMap.Ograniczona wydajność dla nieposortowanych danych:TreeMap działa wydajnie w przypadku posortowanych danych, ale jego wydajność może ulec pogorszeniu w przypadku nieposortowanych danych lub częstych modyfikacji, ponieważ wymaga utrzymania kolejności posortowania.

Funkcje:

    put(klucz, wartość):Wstawia parę klucz-wartość do TreeMap.Weź klucz):Pobiera wartość skojarzoną z określonym kluczem.zawieraKlucz (klucz):Sprawdza, czy TreeMap zawiera określony klucz.usuń (klucz):Usuwa parę klucz-wartość skojarzoną z określonym kluczem.rozmiar():Zwraca liczbę par klucz-wartość w TreeMap.zestaw kluczy():Zwraca zestaw wszystkich kluczy w TreeMap.wartości():Zwraca kolekcję wszystkich wartości w TreeMap.zestaw wpisów():Zwraca zestaw par klucz-wartość w TreeMap.

Realizacja:

Nazwa pliku: 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); } } } 

Wyjście:

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

Wykresy to struktura danych reprezentująca zbiór połączonych ze sobą węzłów lub wierzchołków. Składają się z wierzchołków i krawędzi, przy czym wierzchołki reprezentują elementy, a krawędzie reprezentują relacje między tymi elementami.

Zalety:

    Wszechstronność:Wykresy mogą przedstawiać szeroką gamę scenariuszy ze świata rzeczywistego, dzięki czemu nadają się do różnych zastosowań, takich jak sieci społecznościowe, systemy transportowe i sieci komputerowe.Reprezentacja związku:Wykresy zapewniają naturalny sposób przedstawiania relacji i powiązań między jednostkami, umożliwiając skuteczną analizę i przechodzenie przez te relacje.Efektywne wyszukiwanie i przemierzanie:Algorytmy graficzne, takie jak przeszukiwanie wszerz (BFS) i przeszukiwanie w głąb (DFS), umożliwiają wydajne przechodzenie i przeszukiwanie wierzchołków i krawędzi wykresu.Modelowanie złożonych relacji:Wykresy mogą modelować złożone relacje, w tym struktury hierarchiczne, zależności cykliczne i wiele połączeń między jednostkami.

Niedogodności:

    Złożoność przestrzeni:Wykresy, zwłaszcza wykresy o dużej skali, z wieloma wierzchołkami i krawędziami, mogą zajmować znaczną ilość pamięci.Złożoność operacji:Niektóre operacje na grafach, takie jak znajdowanie najkrótszej ścieżki lub wykrywanie cykli, mogą wymagać dużej złożoności czasowej, szczególnie w przypadku gęstych grafów.Trudność w utrzymaniu:Modyfikowanie lub aktualizowanie wykresu może być złożone, ponieważ zmiany w strukturze wykresu mogą mieć wpływ na jego łączność i istniejące algorytmy.

Realizacja:

Nazwa pliku: WykresPrzykład.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) Drzewo:

Drzewo jest szeroko stosowaną strukturą danych w informatyce, która reprezentuje strukturę hierarchiczną. Składa się z węzłów połączonych krawędziami, przy czym każdy węzeł może mieć zero lub więcej węzłów podrzędnych.

Zalety:

    Struktura hierarchiczna:Drzewa zapewniają naturalny sposób reprezentowania relacji hierarchicznych, takich jak systemy plików, schematy organizacyjne lub dokumenty HTML/XML.Efektywne wyszukiwanie:Drzewa wyszukiwania binarnego umożliwiają efektywne wyszukiwanie ze złożonością czasową O(log n), dzięki czemu nadają się do przechowywania i wyszukiwania posortowanych danych.Szybkie wstawianie i usuwanie:Drzewiaste struktury danych oferują wydajne operacje wstawiania i usuwania, zwłaszcza gdy są zrównoważone, takie jak drzewa AVL lub drzewa czerwono-czarne.Zamówiona iteracja:Przechodzenie w kolejności przez drzewo wyszukiwania binarnego daje elementy w posortowanej kolejności, co jest pomocne przy zadaniach takich jak drukowanie elementów w posortowanej kolejności lub znajdowanie następnego/poprzedniego elementu.

Niedogodności:

    Wysokie obciążenie pamięci:Drzewa wymagają dodatkowej pamięci do przechowywania odniesień do węzłów lub wskaźników, co może skutkować większym zużyciem pamięci w porównaniu z liniowymi strukturami danych, takimi jak tablice lub listy.Złożone wdrożenie:Implementowanie i utrzymywanie drzewiastej struktury danych może być bardziej złożone w porównaniu z innymi strukturami danych, takimi jak tablice lub listy, szczególnie w przypadku zrównoważonych wariantów drzew.Ograniczone operacje:Niektóre warianty drzew, np. drzewa wyszukiwania binarnego, nie obsługują wydajnych operacji, takich jak znajdowanie k-tego najmniejszego elementu lub ustalanie rangi elementu.

Funkcje:

    Wprowadzenie:Dodaj nowy węzeł do drzewa.Usunięcie:Usuń węzeł z drzewa.Szukaj:Znajdź konkretny węzeł lub element w drzewie.Przejście:Przemierzaj drzewo w różnych kolejnościach, na przykład w kolejności, w przedsprzedaży lub po zamówieniu.Wysokość/Głębokość:Oblicz wysokość lub głębokość drzewa.Balansować:Upewnij się, że drzewo pozostaje zrównoważone, aby zapewnić wydajną pracę.

Realizacja:

Nazwa pliku: Przykład drzewa.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)>