编程难题：如何在Java中实现高效的排序算法

原创向右看齐 2024-11-29 08:18 47阅读 0赞

在Java中，我们可以选择多种高效的排序算法。这里以两种常见的快速排序和归并排序为例。

1. 快速排序：
```java
public class QuickSort {
    void quickSort(int arr[], int low, int high) {
        if (low < high) {
            // pi is partitioning index
            int pi = partition(arr, low, high);

// recursively sort elements before and after partition
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }

// Partition function to find the partitioning index
    private int partition(int arr[], int low, int high) {
        // choose the rightmost element as pivot
        int pivot = arr[high];

// Initialize index of smaller element
        int i = (low - 1);

// Traverse through array from left to right
        for (int j = low; j <= high - 1; j++) {
            // If current element is smaller than or equal to pivot
            if (arr[j] <= pivot) {
                // Swap arr[i] and arr[j]
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;

// Move the index of smaller element i
                i++;
            }
        }

// If current partition has the pivot
        if (arr[i] == pivot) {
            // then swap arr[i] and arr[high]
            int temp = arr[i];
            arr[i] = arr[high];
            arr[high] = temp;
        }

// Return the new position of pivot element
        return i + 1;
    }
}
```
2. 归并排序：
```java
public class MergeSort {
    void mergeSort(int arr[], int low, int high) {
        if (low < high) {
            // Find the middle index
            int mid = (low + high) / 2;

// Recursive call to sort elements before middle index
            mergeSort(arr, low, mid - 1);

// Recursive call to sort elements after middle index
            mergeSort(arr, mid + 1, high);

// Merge the sorted subarrays
            merge(arr, low, mid, high);
        }
    }

// Merge two subarrays into one sorted array
    private void merge(int arr[], int low, int mid, int high) {
        int i = low; // Index for first subarray
        int j = mid + 1; // Index for second subarray

// Create temporary arrays to store elements of first and second subarrays
        int[] temp1 = new int[mid - low];
        int[] temp2 = new int[high - mid];

// Copy the elements from first subarray into temporary array
        while (i <= mid) {
            temp1[i - low] = arr[i];
            i++;
        }

// Copy the elements from second subarray into temporary array
        while (j <= high) {
            temp2[j - mid - 1] = arr[j];
            j++;
        }

// Copy the merged temporary array back to original array
        for (i = low; i <= mid; i++) {
            arr[i] = temp1[i - low];
        }
        for (j = mid + 1; j <= high; j++) {
            arr[j] = temp2[j - mid - 1];
        }

// Free the memory used by temporary arrays
        Arrays.fill(temp1, 0);
        Arrays.fill(temp2, 0);
    }
}
```
这两种排序算法在Java中都可以实现，具体使用哪种取决于你的需求和数据规模。