Technologieaustausch

[Java-Datenstruktur] Eine der ersten linearen Tabellen: sequentielle Tabelle

2024-07-12

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

Einfache Implementierung einer Sequenztabelle mit Java

Eine Sequenztabelle ist eine lineare Struktur, die eine Speichereinheit mit einer kontinuierlichen physischen Adresse verwendet, um Datenelemente der Reihe nach zu speichern. Im Allgemeinen wird Array-Speicher verwendet. Schließen Sie das Hinzufügen, Löschen, Überprüfen und Ändern von Daten im Array ab.

Lineare Tabellen umfassen im Allgemeinen die folgenden Methoden:

öffentliche Klasse MyArrayList {
privates int[]-Array;
private int-Größe;
   // Die Standardkonstruktionsmethode weist standardmäßig Speicherplatz zu
SeqList(){ }
    // Setze die zugrunde liegende Kapazität der Sequenztabelle auf die angegebene Kapazität
SeqList(int initcapacity){ }

   // Neue Elemente hinzufügen, standardmäßig werden sie am Ende des Arrays hinzugefügt
öffentliche void add(int Daten) { }
    //Element an Pos-Position hinzufügen
öffentliche void add(int pos, int data) { }
   // Bestimmen Sie, ob ein Element enthalten ist
öffentliches Boolean enthält (int toFind) { return true; }
    // Finden Sie die Position, die einem Element entspricht
öffentliche int indexOf(int toFind) { return -1; }
    // Holen Sie sich das Element an der Pos-Position
öffentliche int get(int pos) { return -1; }
   // Setze das Element an der Pos-Position auf den Wert
öffentliche void set(int pos, int value) { }
    //Das erste Vorkommen des Schlüsselwortschlüssels löschen
öffentliche void entfernen(int toRemove) { }
   // Länge der Sequenztabelle ermitteln
öffentliche int size() { return 0; }
    //Sequenztabelle löschen
öffentliche Leere löschen() { }
   
   //Sequenztabelle drucken
öffentliche Leere Anzeige() { }
}

Als nächstes implementieren Sie eine Sequenztabelle vom Typ int gemäß der obigen Methode:

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

Einführung in ArrayList

Im Sammlungsframework ist ArrayList eine gewöhnliche Klasse, die die List-Schnittstelle implementiert. Das spezifische Framework-Diagramm lautet wie folgt:

  • ArrayList wird generisch implementiert und muss vor der Verwendung instanziiert werden.
  • ArrayList implementiert die RandomAccess-Schnittstelle und gibt an, dass ArrayList Direktzugriff unterstützt
  • ArrayList implementiert die Cloneable-Schnittstelle und gibt an, dass ArrayList geklont werden kann
  • ArrayList implementiert die Serializable-Schnittstelle und gibt an, dass ArrayList die Serialisierung unterstützt
  • Im Gegensatz zu Vector ist ArrayList nicht threadsicher und kann in einem einzelnen Thread verwendet werden. In Multithreads können Sie Vector oder wählen
  • KopierenBeimSchreibenArrayList
  • Die unterste Ebene von ArrayList ist ein kontinuierlicher Raum und kann dynamisch erweitert werden. Es handelt sich um eine dynamisch typisierte Sequenzliste.

So verwenden Sie ArrayList

ArrayList-Konstruktor

Konstruktormethode in ArrayList:

ArrayList(); //Keine Parameterkonstruktion

ArrayList(Collection<? extends E> c); //Andere Sammlungen zum Erstellen einer ArrayList verwenden

ArrayList(int initialCapacity); //Geben Sie die Anfangskapazität der Sequenztabelle an

Codebeispiel:

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

Allgemeine Operationen für ArrayList

Schwanzstecker

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

Element an angegebener Position einfügen

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

Fügen Sie am Ende Elemente aus einer anderen Sequenzliste ein

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

Löschen Sie das Element an der angegebenen Position

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

Angegebene Daten löschen

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

Holen Sie sich das Element an der angegebenen Position

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

Setzt das Element an der angegebenen Position auf neue Daten

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

Übersichtliche Sequenzliste

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

Bestimmen Sie, ob ein Element in der Sequenzliste enthalten ist

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

Gibt den Index des ersten angegebenen Elements zurück

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

Gibt den Index des zuletzt angegebenen Elements zurück

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

Einen Teil der Liste abfangen

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

Drei Möglichkeiten, ArrayList zu durchlaufen

ArrayList kann auf drei Arten durchlaufen werden: for-Schleife + Index, foreach-erweiterte Schleife und Verwendung von Iteratoren

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

Operationsergebnis:

Szenarioverwendung von ArrayList

Mischalgorithmus

Mischen Sie einen Stapel Spielkarten nach dem Zufallsprinzip und verteilen Sie ihn an drei Personen mit jeweils fünf Karten.

Der Speicherort des Originalcodes des Algorithmus:

Shufflecards · Always Freshwater Fish/Java Classic-Beispiele – Code Cloud – Open Source China (gitee.com)

Yang-Hui-Dreieck

Themenbeschreibung:

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

Laufergebnisdiagramm:

Persönliches Profil

Er widmet sich seit mehr als 30 Jahren der Technologieforschung und beherrscht verschiedene Sprachen wie Java, Linux, Javascript, PHP, CSS usw. Er hat viele Beiträge im Open-Source-Bereich geleistet, Entwicklerdokumentationsstation, um einige Themen in der Technologieentwicklung als zukünftige Referenz zu teilen

meine Kontaktdaten

Post