Fundamentos de la estructura de datos (java)

Language 2022-04-22 15:04:41 views: null

Primero, el concepto básico de la estructura de datos:
     1. Datos (Data)
            Los datos son un conjunto de valores numéricos, caracteres y varios símbolos que pueden ingresarse en la máquina y procesarse.
     2. Elemento de datos (Data Element) El
            elemento de datos es la unidad básica de datos y el individuo del conjunto de datos.
     3. Objeto de datos (Data Object)
            Un objeto de datos es una colección de elementos de la misma naturaleza, que es un subconjunto de datos.
     4. Estructura de
            datos Una estructura de datos se refiere a una colección de elementos de datos que tienen una o más relaciones específicas entre sí.
     5. Tipo de datos (Data Type)
            Un tipo de datos es un término general para un conjunto de la misma naturaleza y un conjunto de operaciones de datos que definen este conjunto de valores.
     6. Algoritmo: evaluación del desempeño
            1. Complejidad del tiempo: use la notación "O" grande: por ejemplo:
              T(n) = O(1) significa tipo constante,
                        O(n) significa tipo lineal,
                        O(n^2) significa Cuadrado tipo;
                        O(2^n) significa tipo exponencial;
                        O(log n) tipo logarítmico;
                        O(n log n) tipo bidimensional;
            2. Complejidad del espacio: El espacio ocupado de un algoritmo se refiere a la suma del espacio auxiliar realmente ocupado por el algoritmo.
               Es difícil equilibrar el tiempo y el espacio, a veces es necesario cambiar uno por otro según las necesidades y condiciones reales.

2. A continuación, ingrese formalmente la estructura de datos:
    1. Tabla lineal: un conjunto finito de n elementos de datos del mismo tipo.
                  (1) Características: (1) Identidad, (2) Infinito, (3) Orden
                  (2) Implementación de tabla lineal en java:

List representa una lista lineal: una colección ordenada (también llamada secuencia ). Los usuarios de esta interfaz tienen un control preciso sobre la posición de inserción de cada elemento en la lista. Los usuarios pueden acceder a los elementos en función de su índice entero (posición en la lista) y buscar elementos en la lista. :

        

Resumen del método
 boolean add(E e)
          Agrega el elemento especificado al final de la lista (operación opcional).
 void add(int index, E element)
          Inserta el elemento especificado en la posición especificada en la lista (operación opcional).
 boolean addAll(Collection<? extends E> c)
          Agrega todos los elementos de la colección especificada al final de esta lista, en el orden en que los devuelve el iterador de la colección especificada (operación opcional).
 boolean addAll(int index, Collection<? extends E> c)
          Inserta todos los elementos de la colección especificada en la posición especificada en la lista (operación opcional).
 void clear()
          Eliminar todos los elementos de la lista (operación opcional).
 boolean contains(Object o)
          Devuelve verdadero si la lista contiene el elemento especificado.
 boolean containsAll(Collection<?> c)
          Devuelve verdadero si la lista contiene todos los elementos de la colección especificada.
 boolean equals(Object o)
          Compara el objeto especificado con una lista de igualdad.
 E get(int index)
          Devuelve el elemento en la posición especificada en la lista.
 int hashCode()
          Devuelve el valor del código hash de la lista.
 int indexOf(Object o)
          Devuelve el índice de la primera aparición del elemento especificado en esta lista, o -1 si esta lista no contiene el elemento.
 boolean isEmpty()
          Devuelve verdadero si la lista no contiene elementos.
 Iterator<E> iterator()
          Devuelve un iterador que recorre los elementos de la lista en el orden correcto.
 int lastIndexOf(Object o)
          Devuelve el índice de la última aparición del elemento especificado en esta lista, o -1 si la lista no contiene este elemento.
 ListIterator<E> listIterator()
          Devuelve un iterador de lista sobre los elementos de esta lista (en el orden apropiado).
 ListIterator<E> listIterator(int index)
          Devuelve un iterador de lista (en el orden correcto) de los elementos de la lista, comenzando en la posición especificada en la lista.
 E remove(int index)
          Elimina el elemento en la posición especificada en la lista (operación opcional).
 boolean remove(Object o)
          Elimina la primera aparición del elemento especificado, si está presente, de esta lista (operación opcional).
 boolean removeAll(Collection<?> c)
          Elimina todos sus elementos contenidos en la colección especificada de la lista (operación opcional).
 boolean retainAll(Collection<?> c)
          Mantener solo los elementos contenidos en la colección especificada en la lista (operación opcional).
 E set(int index, E element)
          Reemplaza el elemento en la posición especificada en la lista con el elemento especificado (operación opcional).
 int size()
          Devuelve el número de elementos de la lista.
 List<E> subList(int fromIndex, int toIndex)
          Devuelve una vista parcial entre fromIndex (inclusivo) y toIndex (exclusivo) especificados en la lista.
 Object[] toArray()
          Devuelve una matriz que contiene todos los elementos de la lista en el orden correcto (desde el primer elemento hasta el último elemento).
<T> T[]
toArray(T[] a)
          Devuelve una matriz que contiene todos los elementos de la lista en el orden correcto (desde el primer elemento hasta el último); el tipo de tiempo de ejecución de la matriz devuelta es el de la matriz especificada.

ArrayList: lista secuencial, almacenamiento secuencial de lista lineal. La capa inferior se implementa mediante matrices. También funcionalmente similar a una matriz.

(1) Relación de herencia:

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

(2) Declaración de clase:

                 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给定的队列和栈也要学会使用它的各项操作。

Supongo que te gusta

Origin blog.csdn.net/weixin_52575498/article/details/123168216
Recomendado
Clasificación
Diario
Más
2024-05-14(10)
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)

Code World

© 2018 codetd.com