-
冒泡排序（Bubble Sort）：通过不断比较相邻的元素并交换位置，将最大的元素逐步“冒泡”到右侧。
public static void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i < n-1; i++) { for (int j = 0; j < n-i-1; j++) { if (arr[j] > arr[j+1]) { // 交换arr[j]和arr[j+1] int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } } -
选择排序（Selection Sort）：每次从未排序部分选择最小的元素，并将其放置在已排序部分的末尾。
public static void selectionSort(int[] arr) { int n = arr.length; for (int i = 0; i < n-1; i++) { int minIndex = i; for (int j = i+1; j < n; j++) { if (arr[j] < arr[minIndex]) { minIndex = j; } } // 交换arr[i]和arr[minIndex] int temp = arr[i]; arr[i] = arr[minIndex]; arr[minIndex] = temp; } } -
插入排序（Insertion Sort）：将数组分为已排序和未排序两部分，不断将未排序部分中的元素插入到已排序部分的正确位置。
public static void insertionSort(int[] arr) { int n = arr.length; for (int i = 1; i < n; i++) { int key = arr[i]; int j = i - 1; while (j >= 0 && arr[j] > key) { arr[j+1] = arr[j]; j--; } arr[j+1] = key; } }-
快速排序（Quick Sort）：通过选取一个基准元素，将数组分为小于基准和大于基准的两个部分，再对这两部分分别进行快速排序。
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++; // 交换arr[i]和arr[j] int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } // 交换arr[i+1]和arr[high] int temp = arr[i+1]; arr[i+1] = arr[high]; arr[high] = temp; return i + 1; } -
归并排序（Merge Sort）：将数组分成两个子数组，递归地对子数组进行排序，然后合并这两个子数组以获得最终的排序结果。
public static void mergeSort(int[] arr, int low, int high) { if (low < high) { int middle = (low + high) / 2; mergeSort(arr, low, middle); mergeSort(arr, middle + 1, high); merge(arr, low, middle, high); } } private static void merge(int[] arr, int low, int middle, int high) { int n1 = middle - low + 1; int n2 = high - middle; int[] left = new int[n1]; int[] right = new int[n2]; for (int i = 0; i < n1; i++) { left[i] = arr[low + i]; } for (int j = 0; j < n2; j++) { right[j] = arr[middle + 1 + j]; } int i = 0, j = 0, k = low; while (i < n1 && j < n2) { if (left[i] <= right[j]) { arr[k] = left[i]; i++; } else { arr[k] = right[j]; j++; } k++; } while (i < n1) { arr[k] = left[i]; i++; k++; } while (j < n2) { arr[k] = right[j]; j++; k++; } } -
堆排序（Heap Sort）：构建一个最大堆或最小堆，然后依次移除堆顶元素，即可得到有序序列。
public static void heapSort(int[] arr) { int n = arr.length; // 构建最大堆 for (int i = n / 2 - 1; i >= 0; i--) { heapify(arr, n, i); } // 依次从堆中取出元素并调整堆结构 for (int i = n - 1; i >= 0; i--) { // 交换根节点与最后一个节点 int temp = arr[0]; arr[0] = arr[i]; arr[i] = temp; // 调整堆结构 heapify(arr, i, 0); } } private static void heapify(int[] arr, int n, int rootIndex) { int largest = rootIndex; // 最大值节点的索引 int leftChild = 2 * rootIndex + 1; int rightChild = 2 * rootIndex + 2; if (leftChild < n && arr[leftChild] > arr[largest]) { largest = leftChild; } if (rightChild < n && arr[rightChild] > arr[largest]) { largest = rightChild; } if (largest != rootIndex) { // 交换根节点与最大值节点 int temp = arr[rootIndex]; arr[rootIndex] = arr[largest]; arr[largest] = temp; // 继续调整堆结构 heapify(arr, n, largest); } } -
希尔排序（Shell Sort）：通过将元素按照一定增量进行分组，分组内使用插入排序，然后逐渐缩小增量直至为1。
public static void shellSort(int[] arr) { int n = arr.length; for (int gap = n / 2; gap > 0; gap /= 2) { for (int i = gap; i < n; i++) { int key = arr[i]; int j = i; while (j >= gap && arr[j - gap] > key) { arr[j] = arr[j - gap]; j -= gap; } arr[j] = key; } } } -
计数排序（Counting Sort）：统计待排序元素的出现次数，然后根据统计结果将元素放回正确的位置。
public static void countingSort(int[] arr) { int n = arr.length; int max = Arrays.stream(arr).max().getAsInt(); int min = Arrays.stream(arr).min().getAsInt(); int range = max - min + 1; int[] count = new int[range]; int[] output = new int[n]; for (int i = 0; i < n; i++) { count[arr[i] - min]++; } for (int i = 1; i < range; i++) { count[i] += count[i - 1]; } for (int i = n - 1; i >= 0; i--) { output[count[arr[i] - min] - 1] = arr[i]; count[arr[i] - min]--; } for (int i = 0; i < n; i++) { arr[i] = output[i]; } } -
桶排序（Bucket Sort）：将元素划分为若干个有序的桶，然后对每个桶内的元素进行排序，最后依次输出所有桶中的元素。
public static void bucketSort(int[] arr, int numBuckets) { if (arr.length == 0) { return; } int maxVal = arr[0]; int minVal = arr[0]; for (int i = 1; i < arr.length; i++) { maxVal = Math.max(maxVal, arr[i]); minVal = Math.min(minVal, arr[i]); } int bucketSize = (maxVal - minVal) / numBuckets + 1; List<List<Integer>> buckets = new ArrayList<>(); for (int i = 0; i < numBuckets; i++) { buckets.add(new ArrayList<>()); } for (int i = 0; i < arr.length; i++) { int bucketIndex = (arr[i] - minVal) / bucketSize; buckets.get(bucketIndex).add(arr[i]); } int k = 0; for (int i = 0; i < numBuckets; i++) { Collections.sort(buckets.get(i)); for (int j = 0; j < buckets.get(i).size(); j++) { arr[k++] = buckets.get(i).get(j); } } } -
基数排序（Radix Sort）：根据元素的位数将元素从最低位到最高位依次进行排序，如先按个位排序、再按十位排序，以此类推。
public static void radixSort(int[] arr) { if (arr.length == 0) { return; } int maxVal = arr[0]; for (int i = 1; i < arr.length; i++) { maxVal = Math.max(maxVal, arr[i]); } for (int exp = 1; maxVal / exp > 0; exp *= 10) { countingSortByDigit(arr, exp); } } private static void countingSortByDigit(int[] arr, int exp) { int n = arr.length; int[] count = new int[10]; int[] output = new int[n]; for (int i = 0; i < n; i++) { count[(arr[i] / exp) % 10]++; } for (int i = 1; i < 10; i++) { count[i] += count[i - 1]; } for (int i = n - 1; i >= 0; i--) { output[count[(arr[i] / exp) % 10] - 1] = arr[i]; count[(arr[i] / exp) % 10]--; } for (int i = 0; i < n; i++) { arr[i] = output[i]; } }
-
JAVA中常见的排序算法实现
最新推荐文章于 2024-07-08 22:12:26 发布
1058
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
