logo

Структури даних в Java

Численні способи впорядкування, збереження та обробки даних у комп’ютерній програмі називають структурами даних у Java. Ці структури пропонують методичний метод ефективної обробки та керування даними, уможливлюючи такі корисні операції, як вставка, видалення, пошук і обхід.

У цій статті буде розглянуто все, що стосується структур даних у Java, і це допоможе початківцям легко та ефективно зрозуміти.

  • Що таке Java?
  • Що таке структури даних у Java?
  • Типи структур даних у Java
  • Переваги структур даних у Java
  • Класифікація структур даних
  • Поширені запитання про структури даних у Java

Що таке Java?

Java — популярна об’єктно-орієнтована мова програмування, відома своєю великою стандартною бібліотекою та свободою платформи. Він пропонує надійну архітектуру для створення програм, що працюють без перекомпіляції на різних платформах. Добре відома бібліотека для Java має вибір систем записів, які роблять її життєздатною для ефективної роботи з численними типами даних.

Що таке структури даних у Java?

Спосіб організації та зберігання даних у пам’яті комп’ютерної програми тісно залежить від структур записів Java. Добре відома бібліотека Java містить значний тип вбудованих структур статистики. Кілька систем записів, які дозволяють програмістам короткими та простими способами зберігати та впорядковувати дані, включають пов’язані списки, стеки, черги та масиви. Розробники можуть швидко виконувати такі операції, як вставка, видалення, пошук і сортування, оскільки вони надають низку механізмів для отримання доступу до даних, їх зміни та керування ними. Програмісти на Java можуть зменшити використання пам’яті та значно підвищити загальну ефективність своїх програм, використовуючи ці структури даних.

Типи структур даних у Java

Нижче наведено список структур даних у Java

  1. Масиви
  2. ArrayList
  3. LinkedList
  4. Стек
  5. Черга
  6. HashMap
  7. HashSet
  8. TreeSet
  9. TreeMap
  10. Графік
  11. дерево

Наведена нижче схема чітко пояснює типи структур даних у Java.

Структури даних у Java

Подальша класифікація типів структур даних:

Існує два типи структур даних: -

  1. Примітивні структури даних
  2. Непримітивні структури даних

1) Примітивні структури даних: Також відомі як примітивні типи даних, це базові вбудовані типи даних у Java. Вони включають:

    Байт:Зберігає цілі числа від -128 до 127.короткий:Зберігає цілі числа від -32 768 до 32 767.int:Зберігає цілі числа від -2 147 483 648 до 2 147 483 647.float:Зберігає числа з плаваючою комою з одинарною точністю.char:Зберігає окремі символи.логічний:Зберігає значення true або false.довго:Зберігає великі цілі числа.Двомісний:Зберігає числа з плаваючим множником із подвійною точністю.

2) Непримітивні структури даних: Непримітивні структури записів є більш складними та складаються з примітивних видів інформації. Крім того, їх можна розділити на два типи:

    Лінійні структури даних:У лінійних структурах даних елементи розташовані лінійно або послідовно. Приклади:
      Масиви:Група однакових типізованих елементів, розміщених у масиві відповідно до попередньо визначеного розташування.Стеки:Структура «Останній прийшов першим вийшов» (LIFO), у якій можна додавати або видаляти лише найвищі елементи.Хвости:Структури FIFO (First In-First Out) використовуються в чергах, де елементи вставляються на повернені та виймаються на передній частині.Зв'язаний список:Пов’язаний список містить колекцію гаджетів, які називаються вузлами, кожен з яких має посилання на вузол після нього та статистику всередині нього.
    Нелінійні структури даних:У нелінійних структурах даних елементи розташовані непослідовним чином. Приклади:
      Дерева:Дерева — це тип ієрархічної структури на основі вузлів, з кореневим вузлом у верхній частині та дочірніми вузлами, що розгалужуються від нього. Приклади включають червоно-чорні дерева, дерева AVL, бінарні дерева пошуку та двійкові дерева.Графіки:Набір вузлів, з’єднаних за допомогою ребер, де вузли можуть мати будь-яку кількість з’єднань. Графіки використовуються для символізації складних зв’язків між елементами.Купа:Спеціалізована деревоподібна структура, у якій кожен визначений вузол має значення більше або менше, ніж його дочірні вузли, залежно від того, чи є він максимальною чи мінімальною купою.Хеш:Структури даних, які використовують хеш-функцію для зіставлення ключів зі значеннями. Приклади складаються з хеш-наборів і хеш-карт, які забезпечують зелений пошук і зберігання статистики на основі точних ключів.
Структури даних в Java

Переваги структур даних у Java

    Ефективна організація даних:Структури даних забезпечують організовані способи зберігання та керування даними, забезпечуючи ефективний доступ, маніпуляції та операції пошуку. Вони оптимізують використання пам’яті та сприяють швидшому виконанню алгоритмів.Краща продуктивність:Розробники можуть покращити продуктивність з точки зору швидкості та використання пам’яті, вибравши відповідну структуру даних для певної діяльності. Продуктивність оптимізовано, оскільки конкретні структури даних створені для виконання певних дій, таких як пошук, сортування або вставлення інформації.Повторне використання коду:Java пропонує широкий спектр вбудованих структур даних, якими легко користуватися програміст. Ці багаторазові структури даних економлять час і зусилля, усуваючи необхідність створювати складні алгоритми з нуля.Простота коду:Структури даних спрощують кодування реалізації складних процесів. Вони пропонують високорівневі абстракції та інкапсулюють особливості керування даними, що покращує читабельність коду, зручність його обслуговування та чіткість.Гнучкість і адаптивність:Структури даних забезпечують гнучкість обробки різних типів і розмірів даних. Вони можуть динамічно налаштовуватися відповідно до мінливих вимог до даних і забезпечувати механізми для ефективного маніпулювання даними.Стандартизовано та перевірено:Стандартна бібліотека для Java містить вбудовані структури даних, які пройшли значне тестування та оптимізацію, що гарантує їх надійність і продуктивність. Використання цих загальних структур даних знижує ймовірність помилок і створює міцну основу для розробки програм.Масштабованість:Структури даних забезпечують параметри масштабованості, що дозволяє програмам ефективно обробляти великі обсяги даних. Вони можуть динамічно збільшуватися або зменшуватися залежно від розміру даних, забезпечуючи оптимальну продуктивність навіть із зростаючими вимогами до даних.Розробка алгоритму:Структури даних мають вирішальне значення для розробки та аналізу алгоритмів. Вони забезпечують базову структуру та операції, необхідні для реалізації різних алгоритмів і вирішення складних проблем.

1) Масиви:

Масив — це базова і часто використовувана структура даних у контексті структур даних Java. Він пропонує спосіб зберігання колекції фіксованого розміру компонентів однакового типу. Оскільки вони забезпечують швидкий і легкий доступ до елементів залежно від їх індексу, масиви є важливим інструментом для керування та організації даних.

Переваги:

    Організація даних:Масиви забезпечують структурований спосіб зберігання та організації елементів, покращуючи керування даними.Довільний доступ:До елементів можна отримати прямий доступ за допомогою їх індексу, що забезпечує ефективний пошук і модифікацію.Фіксований розмір:Масиви мають заздалегідь визначений розмір, що забезпечує ефективний розподіл пам’яті.Однорідні елементи:Масиви зберігають елементи одного типу, забезпечуючи узгодженість даних і спрощуючи операції.Ітерація:Масиви підтримують легку ітерацію елементів, полегшуючи обхід і обробку.Сортування та пошук:Масиви добре поєднуються з алгоритмами сортування та пошуку, пропонуючи ефективні операції.Ефективність пам'яті:Масиви оптимізують використання пам’яті, зберігаючи елементи в безперервних областях.Сумісність:Масиви широко підтримуються в Java, що робить їх сумісними з різними фреймворками та інструментами.

Недоліки:

    Фіксований розмір:Розмір масивів не можна динамічно змінювати, тому для зміни розміру потрібне повторне створення.Втрата пам'яті:Невикористані елементи у великих масивах можуть призвести до втрати пам’яті.Накладні витрати на вставку та видалення:Вставлення або видалення елементів у середині масиву вимагає зсуву наступних елементів, що призводить до неефективності.Відсутність гнучкості:Масиви мають жорсткі типи даних і не можуть вмістити різні типи даних без додаткових масивів або структур даних.

Функції:

    Створення масиву:Оголошення та ініціалізація масиву певного розміру за допомогою типу масиву та ключового слова new.Доступ до елементів:Використовуйте індекс для доступу до окремих елементів у масиві.Модифікуючі елементи:Оновіть значення елемента, присвоївши нове значення певному індексу в масиві.Пошук довжини:Використовуйте атрибут length, щоб визначити довжину масиву.Ітерація по масиву:Використовуйте цикли для проходження кожного елемента в масиві та виконання

Реалізація:

Ім'я файлу: 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 у Java — це динамічна структура даних, яка дозволяє зберігати та маніпулювати елементами. Він є частиною Java Collections Framework і реалізований за допомогою внутрішнього масиву.

Переваги:

    Динамічний розмір:На відміну від масивів, ArrayLists може динамічно збільшуватися або зменшуватися в міру додавання або видалення елементів. Це усуває потребу в ручному зміненні розміру та дозволяє зручно працювати з різними обсягами даних.Легке маніпулювання елементами:ArrayLists пропонують методи додавання, видалення та зміни елементів у будь-якій позиції в списку. Його гнучкість спрощує звичайні операції, такі як вставка, видалення та оновлення, роблячи маніпуляції елементами більш ефективними.Довільний доступ:ArrayLists підтримують довільний доступ до елементів за допомогою їх індексу, що дозволяє швидко отримувати та змінювати елементи в певних позиціях у списку. Це полегшує ефективний доступ до елементів і підвищує загальну продуктивність.Сумісність із Java Collection Framework:ArrayLists реалізують інтерфейс List, що робить їх сумісними з іншими класами Collection у Java Collections Framework. Його сумісність забезпечує повну інтеграцію з різними алгоритмами та операціями, які надає фреймворк.

Недоліки:

    Вищі витрати на пам'ять:ArrayLists потребують додаткової пам’яті для підтримки своєї внутрішньої структури, що призводить до більших витрат пам’яті порівняно з масивами. Це може викликати занепокоєння при роботі з великими колекціями елементів.Повільніше вставлення та видалення:Вставлення або видалення елементів у середині ArrayList вимагає переміщення елементів, що може зайняти багато часу для великих списків. У сценаріях, коли очікуються часті операції вставки або видалення, інші структури даних, такі як LinkedList, можуть запропонувати кращу продуктивність.Обмежена продуктивність для пошуку:Пошук елемента в несортованому ArrayList вимагає повторення елементів, доки не буде знайдено збіг. Це лінійний підхід пошуку, який призводить до повільнішої продуктивності пошуку порівняно зі структурами даних, оптимізованими для пошуку, такими як HashSet або TreeMap.Немає підтримки примітивних типів:ArrayLists можуть лише зберігати об’єкти і не підтримують безпосередньо примітивні типи даних, такі як int або char. Щоб зберігати примітивні типи, необхідно використовувати класи-огортки, такі як Integer або Character, що може призвести до потенційних витрат на автоматичне упаковування та розпакування.

Функції:

умовний оператор в java
    Створення ArrayList:Оголошіть та ініціалізуйте ArrayList за допомогою класу ArrayList і вкажіть тип елемента в кутових дужках.Додавання елементів:Використовуйте метод add, щоб додати елементи в кінець ArrayList.Доступ до елементів:Використовуйте техніку отримання, щоб отримати ціну деталі за вибраним індексом.Модифікуючі елементи:Оновіть вартість деталізації за конкретним індексом для використання встановленого підходу.Розмір пошуку:Використовуйте метод dimensions, щоб отримати найсучаснішу кількість факторів у ArrayList.Видалення елементів:Використовуйте підхід видалення, щоб видалити деталь за певним індексом або за допомогою посилання на об’єкт.Ітерація ArrayList:Використовуйте цикли для повторення кожного елемента в ArrayList і виконання операцій над ними.

Реалізація:

Ім'я файлу: 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); } } } 

Вихід:

 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) Зв'язаний список:

Зв’язаний список — це лінійна структура даних, у якій елементи зберігаються в окремих об’єктах, які називаються вузлами. Посилання на наступний вузол у послідовності міститься в кожному елементі даних вузла. Останній вузол списку посилається на null, що вказує на завершення списку.

На відміну від масивів, зв’язані списки не потребують безперервного розподілу пам’яті. Кожен вузол у зв’язаному списку можна виділяти незалежно, що забезпечує динамічний розподіл пам’яті та ефективні операції вставки та видалення.

візуалізатор java

Переваги:

    Динамічний розмір:LinkedList може динамічно збільшуватися або зменшуватися, що робить його придатним для даних різного або невідомого розміру.Ефективне вставлення та видалення:Вставлення або видалення елементів у LinkedList є ефективним, оскільки не вимагає переміщення елементів.Немає вимоги до безперервної пам'яті:LinkedList не потребує безперервного розподілу пам’яті, що робить його гнучким і придатним для непередбачуваних ситуацій пам’яті.Легка модифікація:LinkedList дозволяє легко модифікувати елементи шляхом зміни покажчиків посилань, що забезпечує ефективне маніпулювання.

Недоліки:

    Повільніший довільний доступ:LinkedList має повільніший довільний доступ, оскільки для доступу до елементів за індексом потрібно обходити список.Збільшення витрат пам'яті:LinkedList вимагає додаткової пам’яті для посилань і вузлів, що збільшує витрати пам’яті порівняно з масивами.Неефективний пошук:LinkedList має повільніші операції пошуку, вимагаючи послідовних ітерацій для пошуку певних елементів.

Функції:

    Створення LinkedList:Оголошуйте та ініціалізуйте LinkedList за допомогою класу LinkedList.Додавання елементів:Використовуйте метод add, щоб додати елементи в кінець LinkedList.Доступ до елементів:Використовуйте метод get, щоб отримати значення елемента за певним індексом.Модифікуючі елементи:Оновіть значення елемента за певним індексом за допомогою методу set.Видалення елементів:Використовуйте метод видалення, щоб видалити елемент за певним індексом або за допомогою посилання на об’єкт.

Реалізація:

Ім'я файлу: 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); } } 

Вихід:

 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) Стек:

Принцип «Останній прийшов першим вийшов» (LIFO) передбачає, що елемент, який був вставлений останнім, також є елементом, який видаляється першим. Стек — це лінійна структура даних, яка відповідає цьому правилу. Він використовує команди 'push' і 'pop' для додавання елементів у стек і, відповідно, видалення верхнього елемента зі стеку. Техніка «peek» додатково дає доступ до верхнього елемента без його видалення.

Особливості стека:

    Поведінка LIFO:Останній елемент, вставлений у стек, є першим, що висувається, що робить його придатним для програм, де важливий порядок вставлення та видалення.Обмежений доступ:Стеки зазвичай забезпечують обмежений доступ до елементів. Ви можете отримати доступ лише до самого верхнього елемента, а щоб дістатися до інших елементів, потрібно підняти елементи над ними.Динамічний розмір:Стеки можна реалізувати за допомогою масивів або пов’язаних списків, що забезпечує динамічний розмір. Вони можуть зростати або зменшуватися за потреби під час роботи.

Переваги:

    Простота:Стеки прості для розуміння та впровадження.Ефективність:Операції вставки та видалення мають часову складність O(1).Керування викликами функцій:Стеки ефективно керують викликами функцій і зберіганням змінних.Функція скасування/повторення:Стеки дозволяють виконувати операції скасування та повторення в програмах.

Недоліки:

    Обмежений доступ:Доступ до елементів обмежено верхньою частиною стека.Обмеження розміру:Стеки можуть мати обмеження розміру залежно від реалізації.Не підходить для всіх сценаріїв:Стеки є специфічними для поведінки LIFO і можуть не підходити в інших випадках.

Реалізація:

Ім'я файлу: 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); } } } 

Вихід:

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

5) Черга:

Черга — це лінійна структура даних у Java, яка дотримується принципу FIFO (First-In-First-Out). Він являє собою набір елементів, де елементи вставлені ззаду та видалені спереду.

особливості:

    Поставити в чергу:Додавання елемента в кінець черги.Виключити з черги:Видалення елемента з початку черги.Подивіться:Отримати елемент на початку черги, не видаляючи його.розмір:Визначення кількості елементів у черзі.Порожній чек:Перевірка порожньої черги.

Переваги:

    Поведінка FIFO:Елементи обробляються в порядку їх вставки, забезпечуючи збереження вихідної послідовності.Ефективне введення та видалення:Додавання та видалення елементів із черги відбувається швидко та має постійну часову складність O(1).Синхронізація:Java забезпечує реалізацію синхронізованої черги, що робить їх безпечними для паралельного програмування.Стандартизований інтерфейс:Інтерфейс черги в Java пропонує загальний набір методів, що дозволяє легко взаємозамінювати різні реалізації черги.

Недоліки:

    Без довільного доступу:Черги не підтримують прямий доступ до елементів посередині. Щоб отримати доступ до певних позицій, потрібно видалити попередні елементи з черги.Обмежений розмір:Деякі реалізації черги мають фіксований розмір або ємність, що призводить до переповнення або винятків у разі перевищення максимального розміру.Неефективний пошук:Пошук елемента в черзі вимагає вилучення з черги, доки не буде знайдено збіг, що призводить до лінійного пошуку з потенційно високою часовою складністю.

Реалізація:

Ім'я файлу: 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); } } } 

Вихід:

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

6) HashMap:

HashMap — це структура даних у Java, яка забезпечує спосіб зберігання та отримання пар ключ-значення. Він є частиною Java Collections Framework і реалізований на основі структури даних хеш-таблиці.

Функції:

    put(ключ, значення):Вставляє вказану пару ключ-значення в HashMap.отримати (ключ):Отримує значення, пов’язане з указаним ключем.міститьКлюч(ключ):Перевіряє, чи HashMap містить вказаний ключ.містить значення (значення):Перевіряє, чи HashMap містить вказане значення.видалити (ключ):Видаляє пару ключ-значення, пов’язану з указаним ключем, із HashMap.розмір():Повертає кількість пар ключ-значення в HashMap.пусто():Перевіряє, чи HashMap порожній.keySet():Повертає набір, що містить усі ключі в HashMap.значення():Повертає колекцію, що містить усі значення в HashMap.очистити():Видаляє всі пари ключ-значення з HashMap.

Переваги:

    Ефективне пошук:HashMap забезпечує швидкий пошук значень на основі ключів зі складністю постійного часу O(1).Гнучке поєднання ключ-значення:HashMap дозволяє будь-який ненульовий об’єкт як ключ, що дозволяє використовувати користувацькі ключі для зберігання та отримання даних.Динамічний розмір:HashMap може динамічно збільшувати або зменшувати розмір для обробки різних обсягів даних.Сумісність із Java Collections Framework:HashMap реалізує інтерфейс Map, що забезпечує плавну інтеграцію з іншими класами Collection.

Недоліки:

    Відсутність замовлення:HashMap не зберігає порядок елементів. Використовуйте LinkedHashMap або TreeMap для конкретних вимог до замовлення.Збільшення витрат пам'яті:HashMap вимагає додаткової пам’яті для хеш-кодів і внутрішньої структури порівняно з простішими структурами даних.Повільніша ітерація:Ітерація по HashMap може бути повільнішою порівняно з масивами або списками через проходження основної хеш-таблиці.

Реалізація:

Ім'я файлу: 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()); } } 

Вихід:

 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 — це структура даних у Java, яка реалізує інтерфейс Set і зберігає елементи в хеш-таблиці.

особливості:

    Зберігає унікальні елементи:HashSet не допускає повторюваних елементів. Кожен елемент у HashSet унікальний.Використовує пошук на основі хешу:HashSet використовує хеш-значення кожного елемента для визначення місця його зберігання, забезпечуючи ефективне отримання елементів.Невпорядкована колекція:Елементи в HashSet не зберігаються в певному порядку. Порядок елементів може змінюватися з часом.

Переваги:

    Швидкий пошук елементів:HashSet забезпечує швидкі операції пошуку, що дозволяє ефективно перевіряти, чи існує елемент у наборі.Немає повторюваних елементів:HashSet автоматично обробляє повторювані елементи та гарантує, що кожен елемент є унікальним.Інтеграція з Java Collections Framework:HashSet реалізує інтерфейс Set, що робить його сумісним з іншими класами колекцій у Java Collections Framework.

Недоліки:

awt java
    Немає гарантованого замовлення:HashSet не підтримує порядок елементів. Якщо порядок елементів важливий, HashSet не підходить.Без індексації:HashSet не забезпечує прямого індексування або позиційного доступу до елементів. Щоб отримати доступ до елементів, потрібно виконати ітерацію по набору.Вищі витрати пам'яті:HashSet вимагає додаткової пам’яті для зберігання хеш-значень і підтримки структури хеш-таблиці, що призводить до більшого використання пам’яті порівняно з деякими іншими структурами даних.

Реалізація:

Ім'я файлу: 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()); } } 

Вихід:

 HashSet:[Apple, Grapes, Mango, Orange, Banana] Contains &apos;Apple&apos;:true Updated HashSet:[Apple, Grapes, Mango, Orange] Size of HashSet:4 Is HashSet empty?true 

8) TreeSet:

TreeSet — це реалізація інтерфейсу SortedSet у Java, яка використовує самобалансуюче бінарне дерево пошуку, яке називається червоно-чорним деревом, для зберігання елементів у відсортованому порядку.

Переваги:

    Порядок сортування:TreeSet автоматично підтримує елементи в порядку сортування на основі їхнього природного порядку або спеціального компаратора. Це дозволяє здійснювати ефективний пошук і отримання елементів у порядку зростання або спадання.Немає повторюваних елементів:TreeSet не допускає повторюваних елементів. Це гарантує, що кожен елемент у наборі є унікальним, що може бути корисним у сценаріях, де слід уникати повторюваних значень.Ефективні операції:TreeSet забезпечує ефективні операції, такі як вставка, видалення та пошук. Ці операції мають часову складність O(log n), де n — кількість елементів у наборі.Операції з навігацією:TreeSet надає додаткові навігаційні методи, такі як above(), lower(), strop() і floor(), які дозволяють знаходити елементи, які більші, менші або дорівнюють заданому значенню.

Недоліки:

    Накладні витрати:TreeSet потребує додаткової пам’яті для зберігання внутрішньої структури даних, що може призвести до більших витрат пам’яті порівняно з іншими реалізаціями наборів.Повільніше введення та видалення:Операції вставлення та видалення в TreeSet включають підтримку впорядкованого порядку елементів, що може вимагати реструктуризації дерева. Це може зробити ці операції трохи повільнішими порівняно з HashSet або LinkedHashSet.Обмежене налаштування:TreeSet в основному розроблено для природного впорядкування або окремого компаратора. Може знадобитися більше гнучкості для кількох критеріїв сортування або складної логіки сортування.

Функції:

    додати (елемент):Додає елемент до TreeSet, зберігаючи відсортований порядок.видалити (елемент):Вилучає вказаний елемент із TreeSet.містить (елемент):Перевіряє, чи TreeSet містить вказаний елемент.розмір():Повертає кількість елементів у TreeSet.перший():Повертає перший (найнижчий) елемент у TreeSet.останній():Повертає останній (найвищий) елемент у TreeSet.вищий (елемент):Повертає найменший елемент у TreeSet, який строго перевищує даний елемент.нижчий (елемент):Повертає найбільший елемент у TreeSet, який є строго меншим за вказаний елемент.

Реалізація:

mysql вставити в

Ім'я файлу: 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); } } } 

Вихід:

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

9) TreeMap:

TreeMap — це клас у Java, який реалізує інтерфейс Map і забезпечує відсортоване відображення ключ-значення на основі природного порядку ключів або спеціального компаратора.

Переваги:

    Відсортований порядок:TreeMap зберігає ключі в порядку сортування, що забезпечує ефективний пошук, пошук і операції на основі діапазону.Відображення ключ-значення:TreeMap зберігає пари ключ-значення, забезпечуючи ефективний пошук і отримання значень на основі пов’язаних ключів.Реалізація червоно-чорного дерева:TreeMap використовує всередині збалансоване бінарне дерево пошуку (червоно-чорне дерево), що забезпечує ефективну роботу навіть для великих наборів даних.Підтримка спеціальних компараторів:TreeMap дозволяє використовувати спеціальні компаратори для визначення порядку сортування ключів, забезпечуючи гнучкість критеріїв сортування.

Недоліки:

    Накладні витрати на пам'ять:TreeMap вимагає додаткової пам’яті для зберігання внутрішньої деревовидної структури та пов’язаних об’єктів, що призводить до більшого використання пам’яті порівняно з простішими структурами даних, такими як HashMap.Повільніше вставлення та видалення:Операції вставки та видалення в TreeMap мають часову складність O(log n) через необхідність реструктуризації дерева, що робить їх повільнішими порівняно з HashMap або LinkedHashMap.Обмежена продуктивність для несортованих даних:TreeMap працює ефективно для відсортованих даних, але його продуктивність може погіршитися під час роботи з несортованими даними або частими змінами, оскільки для цього потрібно підтримувати відсортований порядок.

Функції:

    put(ключ, значення):Вставляє пару ключ-значення в TreeMap.отримати (ключ):Отримує значення, пов’язане з указаним ключем.міститьКлюч(ключ):Перевіряє, чи TreeMap містить певний ключ.видалити (ключ):Видаляє пару ключ-значення, пов’язану з указаним ключем.розмір():Повертає кількість пар ключ-значення в TreeMap.keySet():Повертає набір усіх ключів у TreeMap.значення():Повертає колекцію всіх значень у TreeMap.entrySet():Повертає набір пар ключ-значення в TreeMap.

Реалізація:

Ім'я файлу: 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); } } } 

Вихід:

 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) Графік:

Графи — це структура даних, яка представляє набір взаємопов’язаних вузлів або вершин. Вони складаються з вершин і ребер, де вершини представляють сутності, а ребра представляють зв’язки між цими сутностями.

Переваги:

    Універсальність:Графіки можуть представляти широкий спектр реальних сценаріїв, що робить їх придатними для різних програм, таких як соціальні мережі, транспортні системи та комп’ютерні мережі.Представлення стосунків:Графіки забезпечують природний спосіб представлення зв’язків і зв’язків між об’єктами, дозволяючи ефективно аналізувати та проходити ці зв’язки.Ефективний пошук і обхід:Алгоритми графа, як-от пошук у ширину (BFS) і пошук у глибину (DFS), забезпечують ефективний обхід і пошук вершин і ребер графа.Моделювання складних відносин:Графи можуть моделювати складні зв’язки, включаючи ієрархічні структури, циклічні залежності та численні зв’язки між сутностями.

Недоліки:

    Космічна складність:Графи можуть споживати значну кількість пам’яті, особливо великомасштабні графи з багатьма вершинами та ребрами.Складність операцій:Певні операції на графі, такі як пошук найкоротшого шляху або виявлення циклів, можуть мати високу складність у часі, особливо в щільних графах.Складність в обслуговуванні:Змінення або оновлення графіка може бути складним, оскільки зміни в структурі графа можуть вплинути на його підключення та існуючі алгоритми.

Реалізація:

Ім'я файлу: 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) Дерево:

Дерево — широко використовувана структура даних в інформатиці, яка представляє ієрархічну структуру. Він складається з вузлів, з’єднаних ребрами, де кожен вузол може мати нуль або більше дочірніх вузлів.

Переваги:

    Ієрархічна структура:Дерева забезпечують природний спосіб представлення ієрархічних зв’язків, таких як файлові системи, організаційні діаграми або документи HTML/XML.Ефективний пошук:Двійкові дерева пошуку забезпечують ефективний пошук із складністю часу O(log n), що робить їх придатними для зберігання та отримання відсортованих даних.Швидке вставлення та видалення:Деревоподібні структури даних пропонують ефективні операції вставки та видалення, особливо коли вони збалансовані, наприклад дерева AVL або червоно-чорні дерева.Упорядкована ітерація:Порядковий обхід бінарного дерева пошуку дає елементи у відсортованому порядку, що корисно для таких завдань, як друк елементів у відсортованому порядку або пошук наступного/попереднього елемента.

Недоліки:

    Високі витрати пам'яті:Деревам потрібна додаткова пам’ять для зберігання посилань на вузли або покажчиків, що може призвести до більшого використання пам’яті порівняно з лінійними структурами даних, такими як масиви чи списки.Комплексна реалізація:Реалізація та підтримка структури даних дерева може бути складнішою порівняно з іншими структурами даних, такими як масиви або списки, особливо для збалансованих варіантів дерева.Обмежені операції:Деякі варіанти дерев, наприклад двійкові дерева пошуку, не підтримують ефективні операції, такі як пошук k-го найменшого елемента або визначення рангу елемента.

Функції:

    Вставка:Додати новий вузол до дерева.Видалення:Видалити вузол з дерева.пошук:Знайти певний вузол або елемент у дереві.Обхід:Переходьте по дереву в різних порядках, наприклад, за порядком, перед замовленням або після замовлення.Висота/Глибина:Обчисліть висоту або глибину дерева.Баланс:Переконайтеся, що дерево залишається збалансованим, щоб підтримувати ефективну роботу.

Реалізація:

Ім'я файлу: 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)>