数据结构与算法：选择排序与快速排序

在Java中实现选择排序和快速排序，可以遵循与Python中相同的算法逻辑。以下是两种排序算法的Java实现代码：

选择排序（Selection Sort）

public class SelectionSort {
    public static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            // 交换找到的最小值和当前位置的值
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 25, 12, 22, 11};
        selectionSort(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

快速排序（Quick Sort）

public class QuickSort {
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(arr, low, high);
            quickSort(arr, low, pivotIndex - 1);
            quickSort(arr, pivotIndex + 1, high);
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high]; // 选择最右边的元素作为基准值
        int i = low - 1; // 指向最小元素的指针

        for (int j = low; j < high; j++) {
            if (arr[j] <= pivot) {
                i++;
                // 交换元素
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        // 将基准值放到正确的位置
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;

        return i + 1;
    }

    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 5};
        quickSort(arr, 0, arr.length - 1);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

在这两个示例中，selectionSort 方法实现了选择排序，而 quickSort 方法实现了快速排序。选择排序通过遍历未排序部分来找到最小（或最大）的元素，并将其与当前位置的元素交换。快速排序则使用一个基准值来将数组分为两部分，然后递归地对这两部分进行排序。

注意：在实际应用中，快速排序的实现可能会包含额外的优化，比如三数取中法来选择基准值，或者在数组长度较小时切换到插入排序等。这些优化可以提高快速排序的性能，特别是在处理部分已排序或包含大量重复元素的数组时。