Compartir tecnología

[Estructura de datos Java] Una de las primeras tablas lineales: tabla secuencial

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Implementación simple de una tabla de secuencia usando Java

Una tabla de secuencia es una estructura lineal que utiliza una unidad de almacenamiento con una dirección física continua para almacenar elementos de datos en secuencia. Generalmente, se utiliza el almacenamiento en matriz. Complete la adición, eliminación, verificación y modificación de datos en la matriz.

Las tablas lineales generalmente incluyen los siguientes métodos:

clase pública MyArrayList {
matriz privada int[];
tamaño int privado;
   //El método de construcción predeterminado asigna espacio de forma predeterminada
Lista de secuencias (){ }
    // Establece la capacidad subyacente de la tabla de secuencia a la capacidad especificada
SeqList(int capacidad inicial){ }

   // Agrega nuevos elementos, por defecto se agregan al final de la matriz
public void add(int datos) { }
    //Agregar elemento en la posición pos
público void add(int pos, int datos) { }
   // Determinar si un elemento está contenido
booleano público contiene (int toFind) { devuelve verdadero; }
    // Encuentra la posición correspondiente a un elemento
público int indexOf(int toFind) { devolver -1; }
    //Obtiene el elemento en la posición pos
público int obtener(int pos) { devolver -1; }
   // Establece el elemento en la posición pos en valor
público void set(int pos, int valor) { }
    //Eliminar la primera aparición de la palabra clave
público void remove(int paraEliminar) { }
   // Obtener la longitud de la tabla de secuencia
público int tamaño() { devolver 0; }
    //Borrar la tabla de secuencia
vacío público claro() { }
   
   //Imprimir tabla de secuencia
vacío público mostrar() { }
}

A continuación, implemente una tabla de secuencia de tipo int según el método anterior:

  1. import java.util.Arrays;
  2. public class MyArrayList {
  3.     private int[] elem;
  4.     private int usedSize;
  5.     private static final int DEFAULT_SIZE = 10;
  6.     public MyArrayList(){
  7.         elem = new int[DEFAULT_SIZE];
  8.     }
  9.     public MyArrayList(int initCapacity){
  10.         elem = new int[initCapacity];
  11.     }
  12.  
  13.     private boolean checkCapacity(){
  14.         if(this.usedSize == elem.length){
  15.             return true;
  16.         }
  17.         return false;
  18.     }
  19.  
  20.     public void display(){
  21.         for (int i = 0; i < this.usedSize; i++) {
  22.             System.out.print(this.elem[i] + " ");
  23.         }
  24.     }
  25.     public void add(int data){
  26.         if(checkCapacity()){
  27.             this.elem = Arrays.copyOf(this.elem,2*elem.length);
  28.         }
  29.         this.elem[this.usedSize] = data;
  30.         this.usedSize++;
  31.         return;
  32.     }
  33.     public void add(int pos,int data){
  34.         if(pos > this.usedSize || pos < 0){
  35.             throw new PosOutOfBoundsException("插入位置错误！");
  36.         }
  37.         if(checkCapacity()){
  38.             this.elem = Arrays.copyOf(this.elem,2*elem.length);
  39.         }
  40.         for (int i = this.usedSize - 1; i >=pos ; i--) {
  41.             elem[i+1] = elem[i];
  42.         }
  43.         this.elem[pos] = data;
  44.         this.usedSize++;
  45.         return;
  46.     }
  47.  
  48.     public boolean contains(int data){
  49.         for (int i = 0; i < this.usedSize; i++) {
  50.             if(this.elem[i] == data){
  51.                 return true;
  52.             }
  53.         }
  54.         return false;
  55.     }
  56.  
  57.     public int indexof(int data){
  58.         for (int i = 0; i < this.usedSize; i++) {
  59.             if(this.elem[i] == data){
  60.                 return i;
  61.             }
  62.         }
  63.         return -1;
  64.     }
  65.     public int get(int pos){
  66.         if(pos >= this.usedSize || pos < 0){
  67.             throw new PosOutOfBoundsException("输入的位置错误！");
  68.         }
  69.         return this.elem[pos];
  70.     }
  71.     public void set(int pos,int data){
  72.         if(pos >= this.usedSize || pos < 0){
  73.             throw new PosOutOfBoundsException("输入的位置错误！");
  74.         }
  75.         this.elem[pos] = data;
  76.     }
  77.     public int size(){
  78.         return this.usedSize;
  79.     }
  80.     public void remove(int data){
  81.         if(this.contains(data)){
  82.             int pos = this.indexof(data);
  83.             for (int i = pos; i < this.usedSize - 1; i++) {
  84.                 this.elem[pos] = this.elem[pos+1];
  85.             }
  86.             this.usedSize--;
  87.         }else{
  88.             throw new PosOutOfBoundsException("没有该元素");
  89.         }
  90.     }
  91.     public void clear(){
  92.         this.usedSize = 0;
  93.         return;
  94.     }
  95. }

Introducción a ArrayList

En el marco de la colección, ArrayList es una clase ordinaria que implementa la interfaz List. El diagrama del marco específico es el siguiente:

  • ArrayList se implementa de manera genérica y se debe crear una instancia antes de su uso.
  • ArrayList implementa la interfaz RandomAccess, lo que indica que ArrayList admite acceso aleatorio
  • ArrayList implementa la interfaz Cloneable, lo que indica que ArrayList se puede clonar
  • ArrayList implementa la interfaz Serializable, lo que indica que ArrayList admite la serialización
  • A diferencia de Vector, ArrayList no es seguro para subprocesos y se puede utilizar en un solo subproceso. En subprocesos múltiples, puede elegir Vector o.
  • Copiar al escribir lista de matrices
  • La capa inferior de ArrayList es un espacio continuo y se puede expandir dinámicamente. Es una lista de secuencia de tipo dinámico.

Cómo utilizar ArrayList

Constructor de lista de matrices

Método constructor en ArrayList:

ArrayList(); //Sin construcción de parámetros

ArrayList(Colección<? extends E> c); //Usar otras colecciones para construir ArrayList

ArrayList(int inicialCapacity); //Especifique la capacidad inicial de la tabla de secuencia

Ejemplo de código:

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list1 = new ArrayList<>();//无参构造
  4.         List<Integer> list2 = new ArrayList<>(10);//指定容量
  5.         list2.add(1);
  6.         list2.add(2);
  7.         list2.add(3);
  8.         List<Integer> list3 = new ArrayList<>(list2);//利用其他 Collection 构建 ArrayList
  9.     }
  10. }

Operaciones comunes en ArrayList

enchufe de cola

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();//无参构造
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         System.out.println(list);
  8.     }
  9. }

Insertar elemento en la posición especificada

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         list.add(1,4);
  8.         System.out.println(list);
  9.     }
  10. }

Finalizar la inserción de elementos de otra lista de secuencia

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer>  list1 = new ArrayList<>();
  4.         list1.add(4);
  5.         list1.add(5);
  6.         list1.add(6);
  7.         List<Integer> list = new ArrayList<>();
  8.         list.add(1);
  9.         list.add(2);
  10.         list.add(3);
  11.         list.addAll(list1);
  12.         System.out.println(list);
  13.     }
  14. }

Eliminar el elemento en la posición especificada

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         list.remove(1);
  8.         System.out.println(list);
  9.     }
  10. }

Eliminar datos especificados

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         list.remove(new Integer(2));
  8.         System.out.println(list);
  9.     }
  10. }

Obtener el elemento en la posición especificada.

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         System.out.println(list.get(1));
  8.     }
  9. }

Establece el elemento en la posición especificada para nuevos datos.

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         list.set(1,4);
  8.         System.out.println(list);
  9.     }
  10. }

Borrar lista de secuencias

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         list.clear();
  8.         System.out.println(list);
  9.     }
  10. }

Determinar si un elemento está en la lista de secuencia

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         System.out.println(list.contains(2));
  8.         System.out.println(list.contains(4));
  9.     }
  10. }

Devuelve el índice del primer elemento especificado.

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         list.add(1);
  8.         System.out.println(list.indexOf(1));
  9.     }
  10. }

Devuelve el índice del último elemento especificado.

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         list.add(1);
  8.         System.out.println(list.lastIndexOf(1));
  9.     }
  10. }

Interceptar parte de la lista.

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         System.out.println(list.subList(0,2));
  8.     }
  9. }

Tres formas de atravesar ArrayList

ArrayList se puede recorrer de tres formas: bucle for + subíndice, bucle mejorado foreach y uso de iteradores.

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         List<Integer> list = new ArrayList<>();
  4.         list.add(1);
  5.         list.add(2);
  6.         list.add(3);
  7.         //使用fori遍历
  8.         for (int i = 0; i < list.size(); i++) {
  9.             System.out.print(list.get(i));
  10.         }
  11.         System.out.println();
  12.         //使用foreach遍历
  13.         for(Integer integer:list){
  14.             System.out.print(integer);
  15.         }
  16.         System.out.println();
  17.         //使用迭代器遍历
  18.         Iterator<Integer> it = list.listIterator();
  19.         while(it.hasNext()){
  20.             System.out.print(it.next());
  21.         }
  22.     }
  23. }

resultado de la operación:

Uso de escenarios de ArrayList

Algoritmo de barajado

Mezcla una baraja de cartas al azar y distribúyelas entre tres personas, cada una con cinco cartas.

La ubicación del código original del algoritmo:

shufflecards · Ejemplos clásicos de Always Freshwater Fish/Java - Code Cloud - Open Source China (gitee.com)

Triángulo de Yang Hui

Tema Descripción:

Código:

  1. public class Test {
  2.     public static List<List<Integer>> generate(int numRows) {
  3.         List<List<Integer>> list = new LinkedList<>();
  4.         for (int i = 0; i < numRows; i++) {
  5.             List<Integer> row = new LinkedList<>();
  6.             for (int j = 0; j < i + 1; j++) {
  7.                 if (j == 0 || i == j) {
  8.                     row.add(1);
  9.                 } else {
  10.                     row.add(list.get(i - 1).get(j - 1) + list.get(i - 1).get(j));
  11.                 }
  12.             }
  13.             list.add(row);
  14.         }
  15.         return list;
  16.     }
  17.  
  18.     public static void main(String[] args) {
  19.         Scanner scanner = new Scanner(System.in);
  20.         int numRows = scanner.nextInt();
  21.         List<List<Integer>> list = generate(numRows);
  22.         for (int i = 0; i < numRows; i++) {
  23.             for (int j = 0; j < i + 1; j++) {
  24.                 System.out.print(list.get(i).get(j) + " ");
  25.             }
  26.             System.out.println();
  27.         }
  28.     }
  29. }

Gráfico de resultados en ejecución:

Perfil personal

Se ha dedicado a la investigación de tecnología durante más de 30 años y domina varios lenguajes como java, linux, javascript, php, css, etc. Ha realizado muchas contribuciones en el campo del código abierto. Estación de documentación para desarrolladores para compartir algunos problemas en el desarrollo de tecnología para referencia futura.

Mi informacion de contacto

Correo