引言

在Java編程的世界里，算法是構(gòu)建高效、可維護(hù)代碼的基石。掌握核心算法不僅能夠提升編程實(shí)力，還能顯著提高開發(fā)效率。本文將深入探討Java編程中的核心算法，并提供實(shí)際案例以幫助讀者理解和應(yīng)用。

第一章：算法基礎(chǔ)

1.1 算法概述

算法是一系列解決問題的步驟。在Java編程中，算法的應(yīng)用體現(xiàn)在數(shù)據(jù)處理、排序、搜索等多個(gè)方面。

1.2 算法復(fù)雜度

理解算法的時(shí)間復(fù)雜度和空間復(fù)雜度對(duì)于評(píng)估算法效率至關(guān)重要。

1.3 常見數(shù)據(jù)結(jié)構(gòu)

熟練掌握數(shù)組、鏈表、棧、隊(duì)列、樹、圖等數(shù)據(jù)結(jié)構(gòu)是應(yīng)用算法的基礎(chǔ)。

第二章：排序算法

2.1 冒泡排序

public class BubbleSort {
    public static void sort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

2.2 快速排序

public class QuickSort {
    public static void sort(int[] array, int low, int high) {
        if (low < high) {
            int pivot = partition(array, low, high);
            sort(array, low, pivot - 1);
            sort(array, pivot + 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;
    }
}

2.3 歸并排序

public class MergeSort {
    public static void sort(int[] array) {
        if (array.length < 2) {
            return;
        }
        int mid = array.length / 2;
        int[] left = new int[mid];
        int[] right = new int[array.length - mid];

        System.arraycopy(array, 0, left, 0, mid);
        System.arraycopy(array, mid, right, 0, array.length - mid);

        sort(left);
        sort(right);

        merge(array, left, right);
    }

    private static void merge(int[] array, int[] left, int[] right) {
        int i = 0, j = 0, k = 0;
        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                array[k++] = left[i++];
            } else {
                array[k++] = right[j++];
            }
        }
        while (i < left.length) {
            array[k++] = left[i++];
        }
        while (j < right.length) {
            array[k++] = right[j++];
        }
    }
}

第三章：搜索算法

3.1 線性搜索

public class LinearSearch {
    public static int search(int[] array, int key) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == key) {
                return i;
            }
        }
        return -1;
    }
}

3.2 二分搜索

二分搜索適用于有序數(shù)組。

public class BinarySearch {
    public static int search(int[] array, int key) {
        int low = 0;
        int high = array.length - 1;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (array[mid] == key) {
                return mid;
            } else if (array[mid] < key) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        return -1;
    }
}

第四章：圖算法

4.1 深度優(yōu)先搜索（DFS）

public class DFS {
    public void dfs(int v, Graph graph) {
        boolean visited[] = new boolean[graph.V];
        dfsUtil(v, visited, graph);
    }

    private void dfsUtil(int v, boolean visited[], Graph graph) {
        visited[v] = true;
        System.out.print(v + " ");

        for (int n : graph.adj[v]) {
            if (!visited[n])
                dfsUtil(n, visited, graph);
        }
    }
}

4.2 廣度優(yōu)先搜索（BFS）

public class BFS {
    public void bfs(Graph graph, int startVertex) {
        boolean visited[] = new boolean[graph.V];
        Queue<Integer> queue = new LinkedList<>();

        visited[startVertex] = true;
        queue.add(startVertex);

        while (!queue.isEmpty()) {
            int currentVertex = queue.poll();
            System.out.print(currentVertex + " ");

            for (int adjVertex : graph.adj[currentVertex]) {
                if (!visited[adjVertex]) {
                    visited[adjVertex] = true;
                    queue.add(adjVertex);
                }
            }
        }
    }
}

第五章：總結(jié)

掌握J(rèn)ava編程中的核心算法對(duì)于提高編程實(shí)力和效率至關(guān)重要。通過本文的介紹和示例代碼，讀者可以更好地理解和應(yīng)用這些算法，從而在編程實(shí)踐中取得更好的成果。