Partage de technologie

[Structure de données Java] L'une des premières tables linéaires : table séquentielle

2024-07-12

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

Implémentation simple d'une table de séquence en utilisant Java

Une table de séquence est une structure linéaire qui utilise une unité de stockage avec une adresse physique continue pour stocker des éléments de données en séquence. Généralement, le stockage en tableau est utilisé. Terminez l'ajout, la suppression, la vérification et la modification des données sur la baie.

Les tableaux linéaires incluent généralement les méthodes suivantes :

classe publique MyArrayList {
tableau privé int[] ;
taille int privée ;
   //La méthode de construction par défaut alloue de l'espace par défaut
Liste de séquences(){ }
    // Définit la capacité sous-jacente de la table de séquence sur la capacité spécifiée
SeqList(int initcapacity){ }

   // Ajoute de nouveaux éléments, par défaut ils sont ajoutés à la fin du tableau
public void add(int données) { }
    //Ajouter un élément à la position pos
public void add(int pos, int données) { }
   // Détermine si un élément est contenu
public boolean contient(int toFind) { renvoie vrai; }
    // Trouver la position correspondant à un élément
public int indexOf(int toFind) { return -1; }
    // Récupère l'élément en position pos
public int get(int pos) { return -1; }
   // Définit l'élément en position pos sur la valeur
public void set(int pos, int valeur) { }
    //Supprime la première occurrence du mot-clé key
public void remove(int toRemove) { }
   // Récupère la longueur de la table de séquence
public int size() { return 0; }
    //Effacer la table de séquence
public void clear() { }
   
   //Imprimer la table de séquence
public void affichage() { }
}

Ensuite, implémentez une table de séquence de type int selon la méthode ci-dessus :

  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. }

Introduction à ArrayList

Dans le framework de collection, ArrayList est une classe ordinaire qui implémente l'interface List. Le diagramme du framework spécifique est le suivant :

  • ArrayList est implémenté de manière générique et doit être instancié avant utilisation.
  • ArrayList implémente l'interface RandomAccess, indiquant qu'ArrayList prend en charge l'accès aléatoire
  • ArrayList implémente l'interface Cloneable, indiquant qu'ArrayList peut être cloné
  • ArrayList implémente l'interface Serialisable, indiquant qu'ArrayList prend en charge la sérialisation
  • Contrairement à Vector, ArrayList n'est pas thread-safe et peut être utilisé dans un seul thread. En multi-threads, vous pouvez choisir Vector ou.
  • Liste de tableaux CopyOnWrite
  • La couche inférieure d'ArrayList est un espace continu et peut être développée dynamiquement. Il s'agit d'une liste de séquences typée dynamiquement.

Comment utiliser ArrayList

Constructeur ArrayList

Méthode constructeur dans ArrayList :

ArrayList(); //Aucune construction de paramètre

TableauListe(Collection<? extends E> c); //Utiliser d'autres collections pour créer ArrayList

ArrayList(int initialCapacity); //Spécifiez la capacité initiale de la table de séquence

Exemple de code :

  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. }

Opérations courantes sur ArrayList

bouchon de queue

  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. }

Insérer un élément à la position spécifiée

  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. }

Fin de l'insertion d'éléments d'une autre liste de séquences

  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. }

Supprimer l'élément à la position spécifiée

  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. }

Supprimer les données spécifiées

  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. }

Obtenez l'élément à la position spécifiée

  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. }

Définit l'élément à la position spécifiée sur de nouvelles données

  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. }

Effacer la liste des séquences

  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. }

Déterminer si un élément est dans la liste de séquences

  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. }

Renvoie l'index du premier élément spécifié

  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. }

Renvoie l'index du dernier élément spécifié

  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. }

Intercepter une partie de la liste

  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. }

Trois façons de parcourir ArrayList

ArrayList peut être parcouru de trois manières : boucle for + indice, boucle améliorée foreach et utilisation d'itérateurs

  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. }

résultat de l'opération :

Utilisation de scénario d'ArrayList

Algorithme de brassage

Mélangez un jeu de cartes au hasard et distribuez-les à trois personnes, chacune avec cinq cartes.

L'emplacement du code original de l'algorithme :

shufflecards · Exemples classiques Always Freshwater Fish/Java - Code Cloud - Open Source Chine (gitee.com)

Triangle Yang Hui

Description du sujet:

Code:

  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. }

Graphique des résultats d'exécution :

Profil personnel

Il se consacre à la recherche technologique depuis plus de 30 ans et maîtrise divers langages tels que java, linux, javascript, php, css, etc. Il a apporté de nombreuses contributions dans le domaine de l'open source. station de documentation pour les développeurs pour partager certains problèmes de développement technologique pour référence future.

mes coordonnées

Mail