冒泡排序和快速排序

  1. /**
  2. * @Author leijs
  3. * @date 2021/8/16
  4. */
  5. public class ExchangeSort {
  6. public static void main(String[] args) {
  7. int[] arr = {1, 4, 3, 6, 8, 4, 9, 6, 2};
  8. int[] arr1 = bubbleSort(arr);
  9. for (int i = 0; i < arr1.length; i++) {
  10. System.out.print(arr1[i]);
  11. }
  12. System.out.println();
  13. int[] arr2 = quickSort(arr);
  14. for (int i = 0; i < arr2.length; i++) {
  15. System.out.print(arr2[i]);
  16. }
  17. }
  18. /**
  19. * 冒泡排序:
  20. * 对于当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,
  21. * 让最大的数往下沉,较小的往上冒
  22. * 每当相邻的数比较之后发现和排序要求相反,则交换
  23. *
  24. * @param arr
  25. * @return
  26. */
  27. public static int[] bubbleSort(int[] arr) {
  28. for (int i = 0; i < arr.length; i++) {
  29. for (int j = 0; j < arr.length - 1; j++) {
  30. if (arr[j] > arr[j + 1]) {
  31. int temp = arr[j];
  32. arr[j] = arr[j + 1];
  33. arr[j + 1] = temp;
  34. }
  35. }
  36. }
  37. return arr;
  38. }
  39. /**
  40. * 快速排序
  41. * 选择一个基准元素,通过选择第一个元素或者最后一个元素,通过一次排序,
  42. * 将待排序的列分为两个部分,一部分比基准元素小,一部分比基准元素大
  43. * 此时基准元素在其排好序后的正确位置,然后再用同样的方法递归的排序划分的两部分
  44. *
  45. * @param arr
  46. * @return
  47. */
  48. public static int[] quickSort(int[] arr) {
  49. if (arr.length > 0) {
  50. quickSort(arr, 0, arr.length - 1);
  51. }
  52. return arr;
  53. }
  54. private static void quickSort(int[] arr, int low, int high) {
  55. if (low < high) {
  56. int middle = getMiddle(arr, low, high);
  57. quickSort(arr, 0, middle - 1);
  58. quickSort(arr, middle + 1, high);
  59. }
  60. }
  61. private static int getMiddle(int[] arr, int low, int high) {
  62. int temp = arr[low];
  63. while (low < high) {
  64. // 找到比基准元素小的元素位置
  65. while (low < high && arr[high] >= temp) {
  66. high--;
  67. }
  68. arr[low] = arr[high];
  69. while (low < high && arr[low] <= temp) {
  70. low++;
  71. }
  72. arr[high] = arr[low];
  73. }
  74. arr[low] = temp;
  75. return low;
  76. }
  77. }