JAVAコアのデータ構造とアルゴリズムの実装

記事のスペースが限られているため、いくつかの主要なデータ構造とアルゴリズムの実装例を示します。まず、いくつかのコアとなるデータ構造とアルゴリズムが紹介され、次に対応する Java コードの例が示されます。

1. #配列
   動的に拡張される配列の実装
   • #配列の追加、削除、変更、クエリ操作の実装

   public class DynamicArray<T> {
       private Object[] array;
       private int size;
       private int capacity;
   
       public DynamicArray() {
           capacity = 10;
           array = new Object[capacity];
           size = 0;
       }
   
       public void add(T element) {
           if (size == capacity) {
               capacity *= 2;
               Object[] newArray = new Object[capacity];
               System.arraycopy(array, 0, newArray, 0, size);
               array = newArray;
           }
           array[size++] = element;
       }
   
       public T get(int index) {
           if (index < 0 || index >= size) throw new IndexOutOfBoundsException();
           return (T) array[index];
       }
   
       public void remove(int index) {
           if (index < 0 || index >= size) throw new IndexOutOfBoundsException();
           for (int i = index; i < size - 1; i++) {
               array[i] = array[i + 1];
           }
           size--;
       }
   }

   ログイン後にコピー

2. 単一のリンク リストの実装

   追加、削除、変更、およびクエリ操作の実現リンク リストの

   public class ListNode {
       int val;
       ListNode next;
   
       ListNode(int val) {
           this.val = val;
       }
   }
   
   public class LinkedList {
       private ListNode head;
   
       public void addAtHead(int val) {
           ListNode newHead = new ListNode(val);
           newHead.next = head;
           head = newHead;
       }
   
       public void addAtTail(int val) {
           if (head == null) {
               head = new ListNode(val);
           } else {
               ListNode current = head;
               while (current.next != null) {
                   current = current.next;
               }
               current.next = new ListNode(val);
           }
       }
   
       public void deleteAtIndex(int index) {
           if (index == 0) {
               head = head.next;
               return;
           }
           int count = 0;
           ListNode current = head;
           ListNode prev = null;
           while (current != null && count < index) {
               prev = current;
               current = current.next;
               count++;
           }
           if (current != null) {
               prev.next = current.next;
           }
       }
   
       public ListNode get(int index) {
           ListNode current = head;
           int count = 0;
           while (current != null && count < index) {
               current = current.next;
               count++;
           }
           return current;
       }
   }

   ログイン後にコピー

3. 配列ベースのスタックの実装

   スタックの実装プッシュおよびポップ操作

   public class ArrayStack {
       private int[] array;
       private int top;
       private int capacity;
   
       public ArrayStack(int capacity) {
           this.capacity = capacity;
           array = new int[capacity];
           top = -1;
       }
   
       public void push(int value) {
           if (top == capacity - 1) throw new IllegalStateException("Stack is full");
           array[++top] = value;
       }
   
       public int pop() {
           if (top == -1) throw new IllegalStateException("Stack is empty");
           return array[top--];
       }
   
       public int peek() {
           if (top == -1) throw new IllegalStateException("Stack is empty");
           return array[top];
       }
   
       public boolean isEmpty() {
           return top == -1;
       }
   }

   ログイン後にコピー

4. 配列ベースのキューの実装

   操作の実現キューの入口と出口など

   public class ArrayQueue {
       private int[] array;
       private int front;
       private int rear;
       private int capacity;
   
       public ArrayQueue(int capacity) {
           this.capacity = capacity;
           array = new int[capacity];
           front = 0;
           rear = -1;
       }
   
       public void enqueue(int value) {
           if (rear == capacity - 1) throw new IllegalStateException("Queue is full");
           array[++rear] = value;
       }
   
       public int dequeue() {
           if (isEmpty()) throw new IllegalStateException("Queue is empty");
           int value = array[front];
           front++;
           return value;
       }
   
       public int peek() {
           if (isEmpty()) throw new IllegalStateException("Queue is empty");
           return array[front];
       }
   
       public boolean isEmpty() {
           return front > rear;
       }
   }

   ログイン後にコピー
#ソートアルゴリズム

5. バブルソート、挿入ソート、選択ソート、クイック実装ソートおよびその他のアルゴリズム

   • public class Sort {
         public static void bubbleSort(int[] array) {
             int length = array.length;
             for (int i = 0; i < length - 1; i++) {
                 for (int j = 0; j < length - 1 - i; j++) {
                     if (array[j] > array[j + 1]) {
                         int temp = array[j];
                         array[j] = array[j + 1];
                         array[j + 1] = temp;
                     }
                 }
             }
         }
     
         public static void insertionSort(int[] array) {
             for (int i = 1; i < array.length; i++) {
                 int current = array[i];
                 int j = i - 1;
                 while (j >= 0 && array[j] > current) {
                     array[j + 1] = array[j];
                     j--;
                 }
                 array[j + 1] = current;
             }
         }
     
         public static void selectionSort(int[] array) {
             for (int i = 0; i < array.length - 1; i++) {
                 int minIndex = i;
                 for (int j = i + 1; j < array.length; j++) {
                     if (array[j] < array[minIndex]) {
                         minIndex = j;
                     }
                 }
                 int temp = array[i];
                 array[i] = array[minIndex];
                 array[minIndex] = temp;
             }
         }
     
         public static void quickSort(int[] array, int low, int high) {
             if (low < high) {
                 int mid = partition(array, low, high);
                 quickSort(array, low, mid - 1);
                 quickSort(array, mid + 1, high);
             }
         }
     
         private static int partition(int[] array, int low, int high) {
             int pivot = array[high];
             int i = low - 1;
             for (int j = low; j < high; j++) {
                 if (array[j] < pivot) {
                     i++;
                     int temp = array[i];
                     array[i] = array[j];
                     array[j] = temp;
                 }
             }
             int temp = array[i + 1];
             array[i + 1] = array[high];
             array[high] = temp;
             return i + 1;
         }
     }

     ログイン後にコピー
   上記は、いくつかのコア データ構造とアルゴリズムの Java 実装例です。

以上がJAVAコアのデータ構造とアルゴリズムの実装の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。