Struktur Data: Tatasusunan

Tatasusunan Statik

Array ialah struktur data linear di mana semua elemen disusun secara berurutan. Ia ialah koleksi elemen jenis data yang sama yang disimpan di lokasi memori bersebelahan.

Inisialisasi

public class Array<T> {
    private T[] self;
    private int size;
    @SuppressWarnings("unchecked")
    public Array(int size) {
        if (size <= 0) {
            throw new IllegalArgumentException("Invalid array size (must be positive): " + size);
        } else {
            this.size = size;
            this.self = (T[]) new Object[size];
        }
    }
}

Dalam Kelas Tatasusunan Teras, kami akan menyimpan saiz tatasusunan dan rangka umum untuk pemula tatasusunan. Dalam pembina, kami meminta saiz tatasusunan dan membuat objek serta menaipnya dalam tatasusunan yang kami kehendaki.

Tetapkan Kaedah

public void set(T item, int index) {
        if (index >= this.size || index < 0) {
            throw new IndexOutOfBoundsException("Index Out of bounds: " + index);
        } else {
            this.self[index] = item;
        }
    }

Kaedah ini meminta item disimpan dalam tatasusunan dan indeks pada item yang harus disimpan.

Dapatkan Kaedah

public T get(int index) {
        if (index >= this.size || index < 0) {
            throw new IndexOutOfBoundsException("Index Out of bounds");
        } else {
            return self[index];
        }
    }

Get Method meminta indeks dan mendapatkan semula item daripada indeks tersebut.

Kaedah Cetak

public void print() {
        for (int i = 0; i < size; i++) {
            System.out.println(this.self[i]+" ");
        }
    }

Kaedah Cetak hanya mencetak semua ahli tatasusunan dalam satu baris dengan ruang yang memisahkan setiap item antara mereka.

Susunan Diisih

Tatasusunan tetapi mempunyai fungsi untuk mengisih unsur itu sendiri.

Inisialisasi

public class SortedArray<T extends Comparable<T>> {
    private T[] array;
    private int size;
    private final int maxSize;
    @SuppressWarnings("unchecked")
    public SortedArray(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("Invalid array max size (must be positive): " + maxSize);
        }
        this.array = (T[]) new Comparable[maxSize];
        this.size = 0;
        this.maxSize = maxSize;
    }
}

Dalam Kelas Tatasusunan Diisih, kita akan menyimpan saiz tatasusunan dan meminta saiz maksimum tatasusunan juga dan rangka umum untuk pemula tatasusunan. Dalam pembina, kami meminta Saiz Maks tatasusunan dan membuat objek dan taip menghantarnya dalam tatasusunan yang kami kehendaki.

Getters

public int length() {
        return this.size;
    }
 public int maxLength() {
        return this.maxSize;
    }
 public T get(int index) {
        if (index < 0 || index >= this.size) {
            throw new IndexOutOfBoundsException("Index out of 
 bounds: " + index);
        }
        return this.array[index];
    }

Kaedah Sisipan

private int findInsertionPosition(T item) {
        int left = 0;
        int right = size - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            int cmp = item.compareTo(this.array[mid]);
            if (cmp < 0) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }
public void insert(T item) {
        if (this.size >= this.maxSize) {
            throw new IllegalStateException("The array is already full");
        }

        int position = findInsertionPosition(item);

        for (int i = size; i > position; i--) {
            this.array[i] = this.array[i - 1];
        }
        this.array[position] = item;
        size++;
    }

Kaedah Sisipan memasukkan item pada kedudukannya dalam bentuk yang diisih.

Kaedah Pemadaman

    public void delete(T item) {
        int index = binarySearch(item);
        if (index == -1) {
            throw new IllegalArgumentException("Unable to delete element " + item + ": the entry is not in the array");
        }

        for (int i = index; i < size - 1; i++) {
            this.array[i] = this.array[i + 1];
        }
        this.array[size - 1] = null;
        size--;
    }

Kaedah Carian

private int binarySearch(T target) {
        int left = 0;
        int right = size - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            int cmp = target.compareTo(this.array[mid]);
            if (cmp == 0) {
                return mid;
            } else if (cmp < 0) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return -1;
    }
public Integer find(T target) {
        int index = binarySearch(target);
        return index == -1 ? null : index;
    }

Kaedah Traverse

public void traverse(Callback<T> callback) {
        for (int i = 0; i < this.size; i++) {
            callback.call(this.array[i]);
        }
    }

Antara Muka Panggilan Balik

public interface Callback<T> {
        void call(T item);
    }

Penggunaan Antara Muka Panggilan Balik dalam Traversing

public class UppercaseCallback implements UnsortedArray.Callback<String> {
    @Override
    public void call(String item) {
        System.out.println(item.toUpperCase());
    }
}

Tatasusunan Tidak Diisih

Ia hampir sama dari atas
Permulaan dan pengambil adalah sama.

Kaedah Sisipan

public void insert(T item) {
        if (this.size >= this.maxSize) {
            throw new IllegalStateException("The array is already full");
        } else {
            this.self[this.size] = item;
            this.size++;
        }
    }

Kaedah Padam juga sama

Kaedah Carian

public Integer find(T target) {
        for (int i = 0; i < this.size; i++) {
            if (this.self[i].equals(target)) {
                return i;
            }
        }
        return null;
    }

Tatasusunan Dinamik

Susun Dinamik adalah seperti senarai atau senarai tatasusunan.

Inisialisasi

public class DynamicArray<T> {
    private T[] array;
    private int size;
    private int capacity;

    @SuppressWarnings("unchecked")
    public DynamicArray(int initialCapacity) {
        if (initialCapacity <= 0) {
            throw new IllegalArgumentException("Invalid initial capacity: " + initialCapacity);
        }
        this.capacity = initialCapacity;
        this.array = (T[]) new Object[initialCapacity];
        this.size = 0;
    }
}

Kaedah Sisip

private void resize(int newCapacity) {
        @SuppressWarnings("unchecked")
        T[] newArray = (T[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newArray[i] = array[i];
        }
        array = newArray;
        capacity = newCapacity;
    }
    public void insert(T item) {
        if (size >= capacity) {
            resize(2 * capacity);
        }
        array[size++] = item;
    }

Kaedah Padam

public void delete(T item) {
        int index = find(item);
        if (index == -1) {
            throw new IllegalArgumentException("Item not found: " + item);
        }

        for (int i = index; i < size - 1; i++) {
            array[i] = array[i + 1];
        }
        array[--size] = null;
        if (capacity > 1 && size <= capacity / 4) {
            resize(capacity / 2);
        }
    }

Semua yang lain adalah sama.
Harap ini membantu dalam bekerja dengan tatasusunan. Semoga Berjaya!

Atas ialah kandungan terperinci Struktur Data: Tatasusunan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!