Struktur dan algoritma data Java: penjelasan terperinci tentang kes praktikal

Struktur dan algoritma data ialah elemen utama untuk kecekapan program. Struktur data yang biasa digunakan dalam Java termasuk tatasusunan, senarai terpaut, tindanan dan pepohon binari. Algoritma biasa termasuk isihan pantas dan carian binari. Artikel ini menerangkan konsep ini dengan cara yang mudah dan mudah difahami melalui kes praktikal: Tatasusunan: menyimpan unsur-unsur jenis yang sama secara berterusan, seperti markah pelajar. Senarai terpaut: elemen dipautkan melalui penunjuk, seperti baris gilir simulasi. Timbunan: Ikut prinsip LIFO, seperti menjejak panggilan fungsi. Pokok binari: Struktur data pokok, seperti direktori sistem fail. Isih cepat: Bahagikan dan takluki strategi, bahagikan tatasusunan kepada dua bahagian dan susun secara berasingan. Carian binari: Lakukan carian binari pada tatasusunan tertib untuk mengecilkan skop carian.

Struktur dan algoritma data Java: penerangan terperinci tentang kes praktikal

Pengenalan

Struktur dan algoritma data ialah asas sains komputer, dan ia menentukan kecekapan dan keteguhan program. Artikel ini akan menerangkan struktur data dan algoritma yang biasa digunakan dalam Java dengan cara yang mudah dan mudah difahami melalui satu siri kes praktikal.

Array

Definisi: Himpunan elemen dari jenis yang sama disimpan dalam ruang ingatan berterusan.

Kes praktikal: Menyimpan gred pelajar

int[] scores = {90, 85, 78, 95, 82};

Senarai terpaut

Definisi: Struktur data linear yang unsur-unsurnya dipautkan oleh penunjuk.

Kes praktikal: Baris gilir simulasi

class Node {
    int value;
    Node next;
}

class Queue {
    Node head;
    Node tail;

    public void enqueue(int value) {
        Node newNode = new Node();
        newNode.value = value;
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            tail.next = newNode;
            tail = newNode;
        }
    }

    public int dequeue() {
        if (head == null) {
            throw new RuntimeException("Queue is empty");
        }

        int value = head.value;
        head = head.next;
        if (head == null) {
            tail = null;
        }
        return value;
    }
}

Timbunan

Definisi: Struktur data linear yang mengikut prinsip lepas masuk dahulu (LIFO).

Kes praktikal: Panggilan fungsi menjejak

class Stack<T> {
    private List<T> elements = new ArrayList<>();

    public void push(T element) {
        elements.add(element);
    }

    public T pop() {
        if (elements.isEmpty()) {
            throw new RuntimeException("Stack is empty");
        }
        return elements.remove(elements.size() -1);
    }

    public T peek() {
        if (elements.isEmpty()) {
            throw new RuntimeException("Stack is empty");
        }
        return elements.get(elements.size() -1);
    }
}

Pokok binari

Definisi: Struktur data pokok yang mengandungi nod akar dan sifar atau lebih nod anak.

Kes praktikal: Direktori sistem fail

class TreeNode {
    private String name;
    private List<TreeNode> children;

    // ... 其他代码
}

class FileSystem {
    private TreeNode root;

    // ... 其他代码
}

Isih algoritma

Isih cepat

Penerangan: Bahagi, bahagikan dan takluki strategi tersebut.

Kes praktikal: Mengisih set nombor

public static void quickSort(int[] arr) {
    if (arr == null || arr.length <= 1) {
        return;
    }

    int pivot = arr[0];
    int leftIndex = 0;
    int rightIndex = arr.length - 1;

    while (leftIndex < rightIndex) {
        while (arr[rightIndex] >= pivot && rightIndex > leftIndex) {
            rightIndex--;
        }
        arr[leftIndex] = arr[rightIndex];

        while (arr[leftIndex] <= pivot && rightIndex > leftIndex) {
            leftIndex++;
        }
        arr[rightIndex] = arr[leftIndex];
    }
    arr[leftIndex] = pivot;

    quickSort(arr, 0, leftIndex - 1);
    quickSort(arr, leftIndex + 1, arr.length - 1);
}

Algoritma carian

Carian binari

Penerangan: Lakukan julat carian terperingkat, selangkah demi selangkah

Kes praktikal: Cari elemen dalam tatasusunan

public static int binarySearch(int[] arr, int target) {
    int left = 0;
    int right = arr.length - 1;

    while (left <= right) {
        int mid = (left + right) / 2;

        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

Atas ialah kandungan terperinci Struktur dan algoritma data Java: penjelasan terperinci tentang kes praktikal. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!