什么是Java排序算法？（Java排序算法有哪些类型？）

常见的Java排序算法包括：

1. 冒泡排序：相邻元素之间的排序、比较和交换。 找到未排序部分的最大值或最小值。

公共  static void 冒泡排序(int[] arr) {
 for ( int i = 0 ; i < arr.length - 1) {
 for (int j = 0; j < arr.length - 1; > - i; j++) {
 if (arr[j] > arr[j + 1 ]）  {
 int temp = arr [j];
 arr[j] = arr[j + 1];
 arr[j +  1] = temp;
 }
 }
 }
}

2. 选择排序：每次循环找到未排序部分的最小值，并将其放在已排序部分的末尾。

公共 静态 void 选择排序(int [] arr) {
 for (int i = 0; i < arr.length - 1) {
 int minIndex = i;
 for (int  class="hljs-variable">j = i +  1 j++) {
 if; (arr[j] < arr[minIndex]) {
 minIndex = j;
 }
 }
 if ( minIndex != i) {
 int temp =  arr[i];
 arr[i] = arr[minIndex];
 arr[minIndex] = temp;
 }
 }
}

3. 插入排序：未排序部分的元素到已排序部分1 到适当的位置。 一个。

公共  static void 插入排序(int[] arr) {
 for (int i =  1; i < arr.length; i++) {
 int 键 = arr[i];
 int j = i - 1;
 while (j >= 0 && arr[j] > key) {
 arr[j ] + 1] = arr[j];
 j--;
 }
 arr[j + 1] = key;
 }
}

4. 快速排序：在一次排序中将正在排序的记录分成两个单独的部分。 由于一部分记录中的关键字小于另一部分记录中的关键字，因此我们继续对这两部分记录分别进行排序，以达到对整个序列进行排序的目的。

公共 静态 void 快速排序(int[] arr, int low, int 高)  {
 if (低 < 高) {
 int pivotIndex =分区（arr，低，高);
 QuickSort(arr, low, hubIndex - 1);
 QuickSort(arr, piv)otIndex + 1, 高);
 }
}

私有 静态 int 分区(int[] arr, int low, int 高) {
 int 枢轴  = arr[low];
 while (低 < 高) {
 while (low = 枢轴) {
 high--;
 }
 arr[low] =  arr[high];
 同时 (low < high && arr[low] <= hub) {
 low++;
 }
 arr[high] = arr[low];
 }
 arr[low ] = 枢轴;
 返回低位;
}

5. 归并排序：利用分而治之的思想，将待排序的序列划分为若干个子序列，对子序列进行排序，并将已排序的子序列进行合并。 这是一个有序的序列。 。

公共 静态 void 合并排序(int[] arr) {
 if (arr == null || arr.length <= 1) {
 返回;
 }
 int[] temp = 新 int[arr.length];
 mergeSort(arr, 0, arr.length - 1, temp);
}

私有 静态 void 合并排序(int[] arr，int 左，int 右，int[] temp) {
 if (左 < 右) {
 int mid = (左 + 右) / 2;
 mergeSort(arr, left, middle , temp);
 mergeSort(arr, mid + 1, right, temp);
 merge(arr, left, mid, right, temp);  
 }
}

私有 静态 void 合并(int[] arr, int 左, int中间， int  右，int[] temp) {
 System.arraycopy(到达， 左、临时、左、右 - 左 + 1);
int i = 左，j = 中心+ 1, k = left;
 之间 (i <= center && j <= 右）{
 if (temp[i] <= temp[j]) {
 arr[k++] = temp[i++];
 } else {
 arr[k++] = temp[j++];
 }
 }
 while  (i <= Mid) {
 arr[k++] = temp[i++];
 }
  while (j <= right) {
 arr[k++] = temp[j++];
 }
}

6. 堆排序：利用完全二叉树的性质，将要排序的序列构建成最大堆，将堆开头的元素与堆末尾的元素交换，调整堆结构。 重复此过程，直到完成整个序列列是有序的。

公共  static void 堆排序(int[] arr) {
 int n  = arr.length;
 for (int i = n / 2  - 1; i >= 0 {
 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,  class= "hljs-number">0);
 }
}

私人 静态 void 堆化 (int[] arr, int n, int i) {
 int 最大值 = i;
 int 左 = 2 * i + 1;
 int 右 = 2 * i + 2;
 如果 (左  arr[最大]) {
 最大 = 左;
 }
 if (右  arr[最大]) {
 大st = 右;
 }
 if (max != i) {
 int 交换 = arr[i];
 arr[i] =  arr[max];
 arr[max] = swap;
 heapify(arr, n,max);
 }
}

<这些排序算法各有优缺点，您可以根据自己的具体场景选择合适的算法。

以上内容来源于互联网，不代表本站全部观点。 欢迎关注：zhujipindao.com