データ構造の基礎（java）

まず、データ構造の基本概念は次のとおり
     です。1.データ（データ）
            データは、マシンに入力して処理できる数値、文字、およびさまざまな記号のセットです。
     2.データ要素（データ要素）
            データ要素は、データの基本単位であり、データセットの個人です。
     3.データオブジェクト（データオブジェクト）
            データオブジェクトは、データのサブセットである同じ性質の要素のコレクションです。
     4.データ構造
            データ構造とは、相互に1つ以上の特定の関係を持つデータ要素のコレクションを指します。
     5.データ型（データ型）
            データ型は、同じ性質のセットと、この値のセットを定義するデータ操作のセットの総称です。
     6.アルゴリズム：パフォーマンス評価
            1.時間計算量：大きな「O」表記を使用：例：
              T（n）= O（1）は定数型、
                        O（n）は線形型、
                        O（n ^ 2）は二乗を意味しますタイプ;
                        O（2 ^ n）は指数型を意味します;
                        O（log n）対数タイプ;
                        O（n log n）2次元タイプ;
            2.スペースの複雑さ：アルゴリズムの占有スペースとは、アルゴリズムが実際に占有している補助スペースの合計を指します。
               時間と空間のバランスをとることは難しく、実際のニーズや状況に応じて、一方を他方と交換する必要がある場合があります。

2.次に、データ構造を正式に入力します
   。1.線形テーブル：同じタイプのn個のデータ要素の有限セット。
                  （1）機能：（1）ID、（2）Infinity、（3）Order
                  （2）Javaでの線形テーブルの実装：

リストは線形リストを表します：順序付けられたコレクション（シーケンスとも呼ばれます）。このインターフェイスのユーザーは、リスト内の各要素の挿入位置を正確に制御できます。ユーザーは、整数インデックス（リスト内の位置）に基づいて要素にアクセスし、リスト内の要素を検索できます。：

メソッドの概要

boolean add(E e)
指定した要素をリストの最後に追加します（オプションの操作）。

void add(int index, E element)
リスト内の指定された位置に指定された要素を挿入します（オプションの操作）。

boolean addAll(Collection<? extends E> c)
指定されたコレクションのすべての要素を、指定されたコレクションのイテレーターによって返される順序で、このリストの最後に追加します（オプションの操作）。

boolean addAll(int index, Collection<? extends E> c)
指定されたコレクションのすべての要素をリストの指定された位置に挿入します（オプションの操作）。

void clear()
リストからすべての要素を削除します（オプションの操作）。

boolean contains(Object o)
リストに指定された要素が含まれている場合はtrueを返します。

boolean containsAll(Collection<?> c)
リストに指定されたコレクションのすべての要素が含まれている場合はtrueを返します。

boolean equals(Object o)
指定されたオブジェクトをリストと比較して等しいかどうかを確認します。

E get(int index)
リスト内の指定された位置にある要素を返します。

int hashCode()
リストのハッシュコード値を返します。

int indexOf(Object o)
このリストで指定された要素が最初に出現するインデックスを返します。このリストに要素が含まれていない場合は-1を返します。

boolean isEmpty()
リストに要素が含まれていない場合はtrueを返します。

Iterator<E> iterator()
リストの要素を適切な順序で反復するイテレータを返します。

int lastIndexOf(Object o)
このリストで指定された要素が最後に出現するインデックスを返します。リストにこの要素が含まれていない場合は-1を返します。

ListIterator<E> listIterator()
このリストの要素に対するリストイテレータを（適切な順序で）返します。

ListIterator<E> listIterator(int index)
リスト内の指定された位置から開始して、リスト内の要素のリストイテレータを（適切な順序で）返します。

E remove(int index)
リスト内の指定された位置にある要素を削除します（オプションの操作）。

boolean remove(Object o)
指定された要素が存在する場合は、このリストから最初に出現する要素を削除します（オプションの操作）。

boolean removeAll(Collection<?> c)
指定されたコレクションに含まれるすべての要素をリストから削除します（オプションの操作）。

boolean retainAll(Collection<?> c)
指定されたコレクションに含まれる要素のみをリストに保持します（オプションの操作）。

E set(int index, E element)
リスト内の指定された位置にある要素を指定された要素に置き換えます（オプションの操作）。

int size()
リスト内の要素の数を返します。

List<E> subList(int fromIndex, int toIndex)
リストで指定されたfromIndex（包括的）とtoIndex（排他的）の間の部分ビューを返します。

Object[] toArray()
リスト内のすべての要素を適切な順序（最初の要素から最後の要素まで）で含む配列を返します。

<T> T[]

toArray(T[] a)
リスト内のすべての要素を適切な順序（最初の要素から最後の要素まで）で含む配列を返します。返される配列の実行時の型は、指定された配列の実行時の型です。

ArrayList：シーケンシャルリスト、線形リストのシーケンシャルストレージ。最下層は配列を使用して実装されます。機能的にも配列に似ています。

（1）継承関係：

java.lang.Object 
  java.util.AbstractCollection <E>
       java.util.AbstractList <E>
           java.util.ArrayList <E>

（2）。クラス宣言：

public class ArrayList<E>

extends AbstractList<E>

implements List<E>, RandomAccess, Cloneable, Serializable

(3).实例化对象：

//<Integer> 表示该 ArrayList 的元素类型是 Integer 型
//(java中的包装类型，上一篇文章中有所有基本类型的包装类)
        
List<Integer> arrayList = new ArrayList<>();

arrayList 对象可以使用List的所有功能。

构造方法摘要
`ArrayList()` 构造一个初始容量为 10 的空列表。
`ArrayList(Collection<? extends E> c)` 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
`ArrayList(int initialCapacity)` 构造一个具有指定初始容量的空列表。

可以看到 ArrayList 实现了 List<E>接口。所以 List接口的所有方法ArrayList也同样可以使用。绝大多数情况下使用ArrayList就足够了，因为相比较LinkedList而言，ArrayList省时省力。除非是特定情况下使用 LinkedList。

LinkedList ：链表，线性表的链式存储。

(1).继承关系：

java.lang.Object
  java.util.AbstractCollection<E>
      java.util.AbstractList<E>
          java.util.AbstractSequentialList<E>
              java.util.LinkedList<E>

(2).类的声明：

public class LinkedList<E>

extends AbstractSequentialList<E>

implements List<E>, Deque<E>, Cloneable, Serializable

(3).实例化对象：LinkedList对象可以完成链表的所有操作。

        //linkedList 对象可以可以完成链表的所有操作。
        List<Integer> linkedList = new LinkedList<>();

构造方法摘要
`LinkedList()` 构造一个空列表。
`LinkedList(Collection<? extends E> c)` 构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。

LinkedList不仅实现了 List 接口还有Deque<E>双端队列接口。可以进行一系列关于队列的操作。

2、Queue队列接口：

什么是队列？队列是一种限定性线性表，他只允许在表的一端插入元素，另一端删除元素，所以队列有先进先出(First In First Out,FIFO)的特性。与我们日常生活中的排队是一样的道理。而双端队列则是允许在两端进行元素的插入和移除。

Queue方法摘要
`boolean`	`add(E e)` 将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 true，如果当前没有可用的空间，则抛出 IllegalStateException。
`E`	`element()` 获取，但是不移除此队列的头。
`boolean`	`offer(E e)` 将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于 `add(E)`，后者可能无法插入元素，而只是抛出一个异常。
`E`	`peek()` 获取但不移除此队列的头；如果此队列为空，则返回 null。
`E`	`poll()` 获取并移除此队列的头，如果此队列为空，则返回 null。
`E`	`remove()` 获取并移除此队列的头。

Deque方法摘要
`boolean`	`add(E e)` 将指定元素插入此双端队列所表示的队列（换句话说，此双端队列的尾部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用空间，则抛出 IllegalStateException。
`void`	`addFirst(E e)` 将指定元素插入此双端队列的开头（如果可以直接这样做而不违反容量限制）。
`void`	`addLast(E e)` 将指定元素插入此双端队列的末尾（如果可以直接这样做而不违反容量限制）。
`boolean`	`contains(Object o)` 如果此双端队列包含指定元素，则返回 true。
`Iterator<E>`	`descendingIterator()` 返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
`E`	`element()` 获取，但不移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）。
`E`	`getFirst()` 获取，但不移除此双端队列的第一个元素。
`E`	`getLast()` 获取，但不移除此双端队列的最后一个元素。
`Iterator<E>`	`iterator()` 返回以恰当顺序在此双端队列的元素上进行迭代的迭代器。
`boolean`	`offer(E e)` 将指定元素插入此双端队列所表示的队列（换句话说，此双端队列的尾部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用的空间，则返回 false。
`boolean`	`offerFirst(E e)` 在不违反容量限制的情况下，将指定的元素插入此双端队列的开头。
`boolean`	`offerLast(E e)` 在不违反容量限制的情况下，将指定的元素插入此双端队列的末尾。
`E`	`peek()` 获取，但不移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回 null。
`E`	`peekFirst()` 获取，但不移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。
`E`	`peekLast()` 获取，但不移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。
`E`	`poll()` 获取并移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回 null。
`E`	`pollFirst()` 获取并移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。
`E`	`pollLast()` 获取并移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。
`E`	`pop()` 从此双端队列所表示的堆栈中弹出一个元素。
`void`	`push(E e)` 将一个元素推入此双端队列所表示的堆栈（换句话说，此双端队列的头部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用空间，则抛出 IllegalStateException。
`E`	`remove()` 获取并移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）。
`boolean`	`remove(Object o)` 从此双端队列中移除第一次出现的指定元素。
`E`	`removeFirst()` 获取并移除此双端队列第一个元素。
`boolean`	`removeFirstOccurrence(Object o)` 从此双端队列移除第一次出现的指定元素。
`E`	`removeLast()` 获取并移除此双端队列的最后一个元素。
`boolean`	`removeLastOccurrence(Object o)` 从此双端队列移除最后一次出现的指定元素。
`int`	`size()` 返回此双端队列的元素数。

上面提到 LinkedList 实现了Deque接口，那么通过一下代码实例化的Deque对象就可以完成Deque接口的所有操作:

        //queue对象是一个简单的队列,具体有如下操作:add(E e), element(), offer(E e), peek(), poll(), remove() 
        Queue<Integer> queue = new LinkedList<>();
        //deque对象时一个双端队列,对应可以完成双端队列的操作。
        Deque<Integer> deque = new LinkedList<>();

Queue 和 Deque的一些方法是等效的：

Queue 方法	等效 Deque 方法
`add(e)`	`addLast(e)`
`offer(e)`	`offerLast(e)`
`remove()`	`removeFirst()`
`poll()`	`pollFirst()`
`element()`	`getFirst()`
`peek()`	`peekFirst()`

3、Queue是线性结构的一种具体应用，线性结构还有另一种具体的应用，那就是栈（Stack）

栈作为一种限定性线性表，是将线性比表的插入和删除操作限制为仅在表的一段进行，通常将表中允许操作的一段成为栈顶(Top)，另一端称为栈底（Bottom）

方法摘要
`boolean`	`empty()` 测试堆栈是否为空。
`E`	`peek()` 查看堆栈顶部的对象，但不从堆栈中移除它。
`E`	`pop()` 移除堆栈顶部的对象，并作为此函数的值返回该对象。
`E`	`push(E item)` 把项压入堆栈顶部。
`int`	`search(Object o)` 返回对象在堆栈中的位置，以 1 为基数。

(1).继承关系：

java.lang.Object
  java.util.AbstractCollection<E>
      java.util.AbstractList<E>
          java.util.Vector<E>
              java.util.Stack<E>

(2).类的声明：

                 public class Stack<E>

extends Vector<E>

Stack 类表示后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展，允许将向量视为堆栈。它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法。

(3).实例化对象：

Stack<Integer> stack = new Stack<>();

总结：以上是对java数据结构的一个入门介绍，对于 ArrayList 和 LinkedList 一定要学会使用它的各种操作，以及能够完成自己的 List。对于Queue 和 Stack 首先要理解其含义，并且能够使用线性表来实现自己的队列和栈。对于java给定的队列和栈也要学会使用它的各项操作。

おすすめ