看了毕老师的视频，提到数组排序时，不必每次比较时都进行位置交换，可以在每次外层循环结束时再交换，可以提升效率。
本不想深究这个问题，不知道怎么回事，钻起了牛角尖，试着写了一下。既然写了，便贴出来，有什么问题，望大家指教。

1. public class ArraySortDemo {
   
2.         public static void main(String[] args) {
   
3.                 int[] arr = new int[]{7,4,3,2,88,9,6};
   
4. /*                printArray(arr);
   
5.                 selectSort_1(arr);
   
6.                 printArray(arr);*/
   
7.                 printArray(arr);
   
8.                 bubbleSort(arr);
   
9.                 printArray(arr);
   
10.         }
    
11.         public static void printArray(int[] arr){
    
12.                 System.out.print("[");
    
13.                 for(int i=0;i<arr.length;i++){
    
14.                         if(i!=(arr.length-1))
    
15.                                 System.out.print(arr[i]+",");
    
16.                         else
    
17.                                 System.out.println(arr[i]+"]");
    
18.                 }
    
19.         }
    
20.         
    
21.         //选择排序，未优化
    
22.         public static void selectSort(int[] arr){
    
23.                 for(int x=0;x<arr.length-1;x++){
    
24.                         for(int y=x+1;y<arr.length;y++){
    
25.                                 if(arr[x]>arr[y]){
    
26.                                         int temp = arr[x];
    
27.                                         arr[x] = arr[y];
    
28.                                         arr[y] = temp;
    
29.                                 }
    
30.                         }
    
31.                 }
    
32.         }         
    
33.                
    
34.         //冒泡排序，未优化
    
35.         public static void bubbleSort(int[] arr){
    
36.                 for(int x=0;x<arr.length-1;x++){
    
37.                         for(int y=0;y<arr.length-x-1;y++){
    
38.                                 if(arr[y]<arr[y+1]){
    
39.                                         int temp = arr[y];
    
40.                                         arr[y] = arr[y+1];
    
41.                                         arr[y+1] = temp;
    
42.                                 }                                       
    
43.                         }
    
44.                 }
    
45.         }         
    
46. 
    
47.         //选择排序，已优化
    
48.         public static void selectSort_1(int[] arr){
    
49.                 int min = 0;
    
50.                 for(int x=0;x<arr.length-1;x++){
    
51.                         min = x;
    
52.                         for(int y=x+1;y<arr.length;y++){
    
53.                                 if(arr[min]>arr[y]){
    
54.                                         min = y;
    
55.                                 }
    
56.                         }
    
57.                         int temp = arr[x];
    
58.                         arr[x] = arr[min];
    
59.                         arr[min] = temp;
    
60.                 }
    
61.         }         
    
62.         
    
63.         //冒泡排序，已优化，减少存放在堆内存中数组元素交换次数,max在每次外层循环时初始化为0
    
64.         public static void bubbleSort_1(int[] arr){
    
65.                 int max;
    
66.                 for(int x=0;x<arr.length-1;x++){
    
67.                         max = 0;
    
68.                         for(int y=0;y<arr.length-x-1;y++){
    
69.                                 if(arr[max]<arr[y+1]){
    
70.                                         max = y+1;
    
71.                                 }                                       
    
72.                         }
    
73.                         int temp = arr[arr.length-x-1];
    
74.                         arr[arr.length-x-1] = arr[max];
    
75.                         arr[max] = temp;
    
76.                 }
    
77.         }
    
78. }

复制代码

很欣赏这样老师说了一句就付诸实践的性格呢~   赞一个~  :handshake

涉及到算法与数据结构，LZ 应该知道 算法 有两个因素 空间复杂度 与 时间复杂度 ，而且之间是成正比
冒泡，还是选择或其他，总之 操作数据交换不要操作堆区的数据，堆区方的数据太多，执行时间长，效率很差，操作栈区的数据，改变栈区的指向，执行的效率更高，常见的商业化的垂直搜索引擎就是典型的例子