冒泡排序和选择排序的Java实现

Posted 2021-02-19 majortom

 1 /*
 2     冒泡排序和选择排序的Java实现
 3     冒泡排序：平均时间复杂度O(n方) 最坏时间复杂度O(n方)  最好时间复杂度O(n) 空间复杂度O(1) 不稳定
 4     思路：冒泡排序可以说是我接触到的第一个排序算法,核心思想是依次比较相邻的两个元素，若右边的大于左边的
 5          则将两个元素的位置进行调换。等到自己手写代码时，才发现自己居然一直把冒泡排序和选择排序给搞混了
 6          我一直把选择排序当成冒泡排序来写......
 7     Step1：从首元素开始，比较第一个与第二个元素，若第一个大于第二个，则调换两者的位置。然后比较第二个和第三
 8            个元素，若第二个大于第三个，则调换两者的位置，依次类推，直至到尾元素。此时，尾元素即为本次比较中
 9            最大的数据；
10     Step2：重复Step1，但是比较到尾元素的前一个即停止；
11     .....
12     源数据：6 1 2 7 9 3
13     第一趟第一次比较：1 6 2 7 9 3
14     第一趟第二次比较：1 2 6 7 9 3
15     第一趟第三次比较：1 2 6 7 9 3
16     第一趟第四次比较：1 6 2 7 9 3
17     第一趟第五次比较：1 6 2 7 3 9
18     ....
19 
20     选择排序：平均时间复杂度O(n方) 最坏时间复杂度O(n方)  最好时间复杂度O(n方) 空间复杂度O(1) 不稳定
21     思路：将第一个元素依次与后面的元素进行比较，若第一个元素小于与其比较的元素的值，则交换两个元素的位置，
22          一轮下来后，最小的元素便位于最前面了；然后，将第二个元素依次与后面的元素进行比较......重复以上
23          操作
24     Step1：从首元素开始，依次与后面的元素进行比较，若数值大于与其比较的元素，则交换之；
25     Step2：从第二个元素开始，重复Step2；
26     .......
27     源数据：6 1 2 7 9 3
28     第一趟第一次比较：1 6 2 7 9 3
29     第一趟第二次比较：1 6 2 7 9 3
30     第一趟第三次比较：1 6 2 7 9 3
31     第一趟第四次比较：1 6 2 7 9 3
32     第一趟第五次比较：1 6 2 7 9 3
33     ......
34  */
35 public class BubbleSortAndSelectionSortDemo {
36     public static void main(String[] args) {
37         int[] arra={6,1,2,7,9,3};
38         int[] arrb={6,1,2,7,9,3};
39         bubbleSort(arra);
40         selectionSort(arrb);
41         System.out.println(Arrays.toString(arra));
42         System.out.println(Arrays.toString(arrb));
43     }
44     //选择排序
45     private static void selectionSort(int[] arr) {
46         int temp=0;
47         for (int i = 0; i < arr.length; i++) {
48             for (int j = i; j < arr.length; j++) {
49                 if (arr[i]>arr[j]){
50                     temp=arr[i];
51                     arr[i]=arr[j];
52                     arr[j]=temp;
53                 }
54             }
55         }
56     }
57     //冒泡排序
58     private static void bubbleSort(int[] arr) {
59         int temp=0;
60         //外层循环为排序需要的总趟数
61         for (int i = 0; i < arr.length-1; i++) {
62             //内层循坏为每趟循环需要比较的次数。这里的 j < arr.length-i-1是因为要与j+1比较
63             for (int j = 0; j < arr.length-i-1; j++) {
64                 if(arr[j]>arr[j+1]){
65                     temp=arr[j];
66                     arr[j]=arr[j+1];
67                     arr[j+1]=temp;
68                 }
69             }
70         }
71     }
72 }