logo

Java のデータ構造

コンピューター プログラム内でデータを配置、保存、処理できるさまざまな方法は、Java ではデータ構造と呼ばれます。これらの構造は、データを効果的に処理および管理するための系統的な方法を提供し、挿入、削除、取得、トラバースなどの便利な操作を可能にします。

この記事では Java のデータ構造に関連するすべてを説明しており、初心者が簡単かつ効果的に理解するのに役立ちます。

  • Javaとは何ですか?
  • Javaのデータ構造とは何ですか?
  • Java のデータ構造の種類
  • Java のデータ構造の利点
  • データ構造の分類
  • Java のデータ構造に関するよくある質問

Javaとは何ですか?

Java は、その膨大な標準ライブラリと自由なプラットフォームで知られる人気のオブジェクト指向プログラミング言語です。さまざまなプラットフォームで再コンパイルせずに実行できるプログラムを作成するための堅牢なアーキテクチャを提供します。 Java 用のよく知られたライブラリには、多数のデータ型を効率的に処理できるようにするレコード システムの選択肢があります。

Javaのデータ構造とは何ですか?

データを編成してコンピューター プログラムのメモリに保存する方法は、Java レコード構造に密接に依存しています。 Java のよく知られたライブラリには、重要なタイプの組み込み統計構造が含まれています。プログラマがデータを保存および整理するための短くて簡単な方法を可能にするレコード システムには、接続リスト、スタック、キュー、配列などがあります。データへのアクセス、変更、管理のためのさまざまなメカニズムが提供されているため、開発者は挿入、削除、検索、並べ替えなどの操作を迅速に実行できます。 Java プログラマは、これらのデータ構造を使用することでメモリの使用量を削減し、プログラムの全体的な効率を大幅に高めることができます。

Java のデータ構造の種類

Java のデータ構造のリストは以下のとおりです。

  1. 配列
  2. 配列リスト
  3. リンクリスト
  4. スタック
  5. ハッシュマップ
  6. ハッシュセット
  7. ツリーセット
  8. ツリーマップ
  9. グラフ

以下の図は、Java のデータ構造のタイプを非常に明確に説明しています。

Java のデータ構造

データ構造のタイプをさらに分類すると、次のようになります。

データ構造には 2 つのタイプがあります: -

  1. プリミティブデータ構造
  2. 非プリミティブデータ構造

1) プリミティブデータ構造: プリミティブ データ型とも呼ばれるこれらは、Java の基本的な組み込みデータ型です。それらには次のものが含まれます。

    バイト:-128 から 127 までの整数を格納します。短い:-32,768 から 32,767 までの整数を格納します。整数:-2,147,483,648 から 2,147,483,647 までの整数を格納します。浮く:浮動小数点数を単精度で格納します。文字:個々の文字を格納します。ブール値:true または false の値を保存します。長さ:大きな整数を格納します。ダブル:浮動小数点数を倍精度で格納します。

2) 非プリミティブ データ構造: 非プリミティブ レコード構造はより複雑で、プリミティブな情報の種類で構成されます。さらに、次の 2 種類に分類できます。

    線形データ構造:線形データ構造では、要素は線形または連続的に配置されます。例としては次のものが挙げられます。
      配列:所定の配置に従って配列内に配置された、同じ型の要素のグループ。スタック:最上位の項目のみを追加または削除できる後入れ先出し (LIFO) 構造。尾:先入れ先出し (FIFO) 構造はキューで使用され、項目は戻された側に挿入され、項目は先頭側から取り出されます。リンクされたリスト:関連リストはノードと呼ばれるガジェットのコレクションで構成され、各ガジェットにはその後ろのノードへの参照とその内部の統計情報が含まれます。
    非線形データ構造:非線形データ構造では、要素は非連続的に配置されます。例としては次のものが挙げられます。
      木:ツリーはノードベースの階層構造の一種で、最上位にルート ノードがあり、そこから子ノードが分岐しています。例には、赤黒ツリー、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) 配列リスト:

Java の ArrayList は、要素の保存と操作を可能にする動的データ構造です。これは Java Collections Framework の一部であり、内部的に配列を使用して実装されます。

利点:

    ダイナミックサイズ:配列とは異なり、ArrayList は要素が追加または削除されるとサイズが動的に拡大または縮小できます。手動でサイズを変更する必要がなくなり、さまざまな量のデータを簡単に処理できるようになります。簡単な要素操作:ArrayList は、リスト内の任意の位置に要素を追加、削除、および変更するメソッドを提供します。その柔軟性により、挿入、削除、更新などの一般的な操作が簡素化され、要素の操作がより効率的になります。ランダムアクセス:ArrayList は、インデックスを使用した要素へのランダム アクセスをサポートし、リスト内の特定の位置にある要素を迅速に取得および変更できるようにします。これにより、要素への効率的なアクセスが容易になり、全体的なパフォーマンスが向上します。Java コレクション フレームワークとの互換性:ArrayList は List インターフェイスを実装し、Java Collections Framework の他の Collection クラスと互換性を持たせます。その互換性により、フレームワークが提供するさまざまなアルゴリズムや操作とのシームレスな統合が可能になります。

短所:

    メモリオーバーヘッドが大きい:ArrayList は内部構造を維持するために追加のメモリを必要とするため、配列に比べてメモリのオーバーヘッドが高くなります。要素の大規模なコレクションを扱う場合、これが懸念される場合があります。挿入と削除が遅くなる:ArrayList の途中で要素を挿入または削除するには要素を移動する必要があり、リストが大きい場合は時間がかかることがあります。頻繁な挿入または削除操作が予想されるシナリオでは、LinkedList などの他のデータ構造の方がパフォーマンスが向上する可能性があります。検索のパフォーマンスが制限されている:ソートされていない ArrayList 内の要素を検索するには、一致するものが見つかるまで要素を反復処理する必要があります。これは線形検索アプローチであるため、HashSet や TreeMap などの検索用に最適化されたデータ構造と比較して検索パフォーマンスが遅くなります。プリミティブ型はサポートされていません:ArrayList はオブジェクトのみを格納でき、int や char などのプリミティブ データ型を直接サポートしません。プリミティブ型を格納するには、Integer や Character などのラッパー クラスを使用する必要があり、オートボックス化およびボックス化解除のオーバーヘッドが発生する可能性があります。

機能:

文字列の連結
    ArrayList の作成:ArrayList クラスを使用して ArrayList を宣言および初期化し、山括弧内に要素の型を指定します。要素の追加:add メソッドを使用して、ArrayList の末尾に要素を追加します。要素へのアクセス:get テクニックを使用して、選択したインデックスの詳細の価格を取得します。要素の変更:セットアプローチを使用する場合は、特定のインデックスで詳細コストを更新します。サイズを探す:ディメンション メソッドを使用して、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 にリンクし、リストが終了したことを示します。

配列とは異なり、リンク リストは連続したメモリ割り当てを必要としません。リンク リスト内の各ノードは独立して割り当てることができるため、動的なメモリ割り当てと効率的な挿入および削除操作が可能になります。

利点:

    ダイナミックサイズ:LinkedList は動的に拡大または縮小できるため、さまざまなデータ サイズや未知のデータ サイズに適しています。効率的な挿入と削除:LinkedList 内の要素の挿入または削除は、要素を移動する必要がないため効率的です。連続メモリ要件なし:LinkedList は連続したメモリ割り当てを必要としないため、柔軟性が高く、予測できないメモリ状況にも適しています。簡単な変更:LinkedList では、参照ポインタを変更することで要素を簡単に変更できるため、効率的な操作が可能になります。

短所:

    ランダムアクセスが遅い:LinkedList は、インデックスによって要素にアクセスするためにリストを走査する必要があるため、ランダム アクセスが遅くなります。メモリオーバーヘッドの増加:LinkedList は参照とノード用に追加のメモリを必要とするため、配列と比較してメモリのオーバーヘッドが増加します。非効率的な検索:LinkedList の検索操作は遅くなり、特定の要素を見つけるには連続した反復が必要になります。

機能:

    リンクリストの作成:LinkedList クラスを使用して LinkedList を宣言し、初期化します。要素の追加:add メソッドを使用して、LinkedList の末尾に要素を追加します。要素へのアクセス:get メソッドを使用して、特定のインデックスにある要素の値を取得します。要素の変更:set メソッドを使用して、特定のインデックスにある要素の値を更新します。要素の削除:特定のインデックスにある要素を削除するには、remove メソッドを使用するか、オブジェクト参照を指定します。

実装:

ファイル名: LinkedList1.java

乱数Cコード
 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) スタック:

Last-In-First-Out (LIFO) 原則により、最後に挿入された要素が最初に削除される要素でもあることが決まります。スタックは、この規則に従った線形データ構造です。コマンド「push」および「pop」を使用して要素をスタックに追加し、それに応じてスタックから最上位の要素を削除します。さらに、「ピーク」手法を使用すると、削除せずに最上位の要素にアクセスできるようになります。

スタックの特徴:

    LIFO の動作:スタックにプッシュされた最後の要素が最初にポップアウトされるため、挿入と削除の順序が重要なアプリケーションに適しています。アクセス制限:通常、スタックは要素へのアクセスを制限します。アクセスできるのは最上位の要素のみであり、他の要素にアクセスするには、その上の要素をポップする必要があります。ダイナミックサイズ:スタックは配列またはリンク リストを使用して実装でき、動的なサイズが可能です。実行時に必要に応じて拡大または縮小できます。

利点:

    シンプルさ:スタックは理解しやすく、実装も簡単です。効率:挿入操作と削除操作の時間計算量は O(1) です。関数呼び出しの管理:スタックは関数呼び出しと変数ストレージを効率的に管理します。元に戻す/やり直し機能:スタックを使用すると、アプリケーションで操作を元に戻したりやり直したりできるようになります。

短所:

    アクセス制限:要素へのアクセスはスタックの最上位に制限されます。サイズ制限:実装によっては、スタックにサイズ制限がある場合があります。すべてのシナリオに適しているわけではありません。スタックは LIFO の動作に固有のものであり、他の場合には適切ではない可能性があります。

実装:

ファイル名: スタック例.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) キュー:

キューは、先入れ先出し (FIFO) 原則に従う Java の線形データ構造です。これは、要素が後方に挿入され、前方から削除される要素のコレクションを表します。

特徴:

    エンキュー:キューの後ろに要素を追加します。デキュー:キューの先頭から要素を削除します。ピーク:キューの先頭にある要素を削除せずに取得します。サイズ:キュー内の要素の数を決定します。空のチェック:キューが空かどうかを確認しています。

利点:

    FIFO の動作:要素は挿入順に処理され、元のシーケンスが確実に保持されます。効率的な挿入と取り外し:キューへの要素の追加およびキューからの要素の削除は高速であり、一定の時間計算量は O(1) です。同期:Java は同期キューの実装を提供し、同時プログラミングを安全に実行できるようにします。標準化されたインターフェース:Java の Queue インターフェイスは共通のメソッド セットを提供し、異なるキュー実装間で簡単に互換性を持たせることができます。

短所:

    ランダムアクセスなし:キューは、中間の要素への直接アクセスをサポートしていません。特定の位置にアクセスするには、先行する要素をデキューする必要があります。限定サイズ:一部のキュー実装はサイズまたは容量が固定されているため、最大サイズを超えるとオーバーフローまたは例外が発生します。非効率的な検索:キュー内の要素を検索するには、一致するものが見つかるまでデキューする必要があるため、線形検索となり、時間の複雑さが高くなる可能性があります。

実装:

ファイル名: キュー例.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 は、キーと値のペアを格納および取得する方法を提供する Java のデータ構造です。これは Java Collections Framework の一部であり、ハッシュ テーブル データ構造に基づいて実装されます。

機能:

    put(キー, 値):指定されたキーと値のペアを HashMap に挿入します。取得(キー):指定されたキーに関連付けられた値を取得します。containsKey(キー):HashMap に指定されたキーが含まれているかどうかを確認します。containsValue(値):HashMap に指定された値が含まれているかどうかを確認します。削除(キー):指定されたキーに関連付けられたキーと値のペアを HashMap から削除します。サイズ():HashMap 内のキーと値のペアの数を返します。isEmpty():HashMap が空かどうかを確認します。keySet():HashMap 内のすべてのキーを含む Set を返します。値():HashMap 内のすべての値を含む Collection を返します。クリア():HashMap からすべてのキーと値のペアを削除します。

利点:

    効率的な検索:HashMap は、定数時間計算量 O(1) のキーに基づいて値を高速に取得します。柔軟なキーと値のペアリング:HashMap では、null 以外のオブジェクトをキーとして使用できるため、データの保存と取得にカスタム定義のキーを使用できます。ダイナミックサイズ:HashMap は、さまざまな量のデータを処理するために、サイズを動的に拡大または縮小できます。Java コレクション フレームワークとの互換性: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 は、Set インターフェイスを実装し、要素をハッシュ テーブルに格納する Java のデータ構造です。

特徴:

    固有の要素を保存します。HashSet では要素の重複は許可されません。 HashSet 内の各要素は一意です。ハッシュベースの検索を使用します。HashSet は、各要素のハッシュ値を使用してその格納場所を決定し、効率的な要素の取得を実現します。順序付けされていないコレクション:HashSet 内の要素は、特定の順序で保存されません。要素の順序は時間の経過とともに変更される場合があります。

利点:

    高速要素検索:HashSet は高速な検索操作を提供するため、セット内に要素が存在するかどうかを効率的に確認できます。重複した要素はありません:HashSet は重複した要素を自動的に処理し、各要素が一意であることを保証します。Java コレクション フレームワークとの統合:HashSet は Set インターフェイスを実装し、Java Collections Framework の他のコレクション クラスとの互換性を確保します。

短所:

数値を文字列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 は、Java の SortedSet インターフェイスの実装であり、赤黒ツリーと呼ばれる自己平衡型二分探索ツリーを使用して要素をソート順に格納します。

利点:

    並べ替えられた順序:TreeSet は、要素を自然な順序またはカスタム コンパレータに基づいて並べ替えられた順序で自動的に維持します。これにより、要素を昇順または降順で効率的に検索および取得できます。重複した要素はありません:TreeSet では要素の重複は許可されません。これにより、セット内の各要素が一意であることが保証され、値の重複を避ける必要があるシナリオで役立ちます。効率的な運用:TreeSet は、挿入、削除、検索などの効率的な操作を提供します。これらの演算の時間計算量は O(log n) です。ここで、n はセット内の要素の数です。ナビゲート可能な集合演算:TreeSet には、higher()、 lower()、ceiling()、floor() などの追加のナビゲーション メソッドが用意されており、これらを使用すると、指定された値より大きい、小さい、または等しい要素を検索できます。

短所:

    オーバーヘッド:TreeSet は内部データ構造を保存するために追加のメモリを必要とするため、他のセットの実装に比べてメモリのオーバーヘッドが高くなる可能性があります。挿入と取り外しが遅くなる:TreeSet での挿入および削除操作には、要素の並べ替え順序の維持が含まれるため、ツリーの再構築が必要になる場合があります。これらの操作は、HashSet または LinkedHashSet と比較してわずかに遅くなる可能性があります。限定的なカスタマイズ:TreeSet は主に、自然な順序付けまたは単一のカスタム コンパレータ用に設計されています。複数の並べ替え基準や複雑な並べ替えロジックに対しては、より柔軟性が必要な場合があります。

機能:

    追加(要素):ソートされた順序を維持しながら、要素を TreeSet に追加します。削除(要素):指定された要素を TreeSet から削除します。含まれる(要素):TreeSet に指定された要素が含まれているかどうかを確認します。サイズ():TreeSet 内の要素の数を返します。初め():TreeSet 内の最初 (最下位) の要素を返します。最後():TreeSet 内の最後の (最上位の) 要素を返します。上位(要素):TreeSet 内の指定された要素より厳密に大きい最小要素を返します。下位(要素):指定された要素より厳密に小さい、TreeSet 内の最大の要素を返します。

実装:

ファイル名: 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 は、Map インターフェイスを実装し、キーの自然な順序またはカスタム コンパレータに基づいて並べ替えられたキーと値のマッピングを提供する Java のクラスです。

利点:

    並べ替えられた順序:TreeMap はキーをソートされた順序で維持するため、効率的な検索、取得、および範囲ベースの操作が可能になります。キーと値のマッピング:TreeMap はキーと値のペアを保存し、関連付けられたキーに基づいて値を効率的に検索および取得できるようにします。赤黒ツリーの実装:TreeMap は内部でバランスの取れた二分探索ツリー (赤黒ツリー) を使用し、大規模なデータセットでも効率的なパフォーマンスを保証します。カスタム コンパレータのサポート:TreeMap では、カスタム コンパレーターを使用してキーの並べ替え順序を定義できるため、並べ替え基準に柔軟性が提供されます。

短所:

    メモリのオーバーヘッド:TreeMap は内部ツリー構造と関連オブジェクトを保存するために追加のメモリを必要とするため、HashMap のような単純なデータ構造と比較してメモリ使用量が多くなります。挿入と削除が遅くなる:TreeMap での挿入および削除操作は、ツリーの再構築が必要なため O(log n) の時間計算量があり、HashMap や LinkedHashMap と比べて遅くなります。未ソートデータのパフォーマンスの制限:TreeMap は、並べ替えられたデータに対しては効率的に実行されますが、並べ替えられていないデータや頻繁な変更を処理する場合は、並べ替えられた順序を維持する必要があるため、パフォーマンスが低下する可能性があります。

機能:

    put(キー, 値):キーと値のペアをツリーマップに挿入します。取得(キー):指定されたキーに関連付けられた値を取得します。containsKey(キー):TreeMap に特定のキーが含まれているかどうかを確認します。削除(キー):指定されたキーに関連付けられたキーと値のペアを削除します。サイズ():TreeMap 内のキーと値のペアの数を返します。keySet():TreeMap 内のすべてのキーのセットを返します。値():TreeMap 内のすべての値のコレクションを返します。エントリセット():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) などのグラフ アルゴリズムにより、グラフの頂点とエッジの効率的なトラバースと検索が可能になります。複雑な関係のモデル化:グラフは、階層構造、循環依存関係、エンティティ間の複数の接続などの複雑な関係をモデル化できます。

短所:

    空間の複雑さ:グラフ、特に多くの頂点とエッジを持つ大規模なグラフでは、大量のメモリが消費される可能性があります。オペレーションの複雑さ:最短パスの検索やサイクルの検出など、特定のグラフ操作は、特に密なグラフでは時間の複雑さが高くなる可能性があります。メンテナンスの難しさ:グラフの構造の変更は接続性や既存のアルゴリズムに影響を与える可能性があるため、グラフの変更または更新は複雑になる場合があります。

実装:

ファイル名: グラフ例.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) ツリー:

ツリーは、階層構造を表すコンピューター サイエンスで広く使用されているデータ構造です。これはエッジで接続されたノードで構成され、各ノードは 0 個以上の子ノードを持つことができます。

私のモニターのサイズ

利点:

    階層構造:ツリーは、ファイル システム、組織図、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)>