黑马程序员-----排序算法总结

 1 /**  
 2      * 插入排序  的思路： 
 3      * 1、从第一个元素开始，该元素可以认为已经被排序
 4      * 2、取出下一个元素，在已经排序的元素序列中从后向前扫描  
 5      * 3、如果该元素（已排序）大于新元素，将该元素移到下一位置  
 6      * 4、重复步骤3，直到找到已排序的元素小于或者等于新元素的位置 
 7      * 5、将新元素插入到该位置中  
 8      * 6、重复步骤2  
 9      *  
10      * @param numbers  要进行排序的数组
11      */       
12     
13     public static void insertSort(int[] numbers)
14     {
15         int temp,j;
16         for(int i=1;i<numbers.length;i++)
17         {
18             temp=numbers[i];
19             for(j=i;j>0&&temp<numbers[j-1];j--)
20                 numbers[j]=numbers[j-1];
21             numbers[j]=temp;
22         }
23     
24     }

 1 /**
 2      * 选择排序
 3      * 1、在未排序序列中找到最小元素，存放到排序序列的起始位置
 4      * 2、再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。
 5      * 3、  以此类推，直到所有元素均排序完毕。 
 6      * 
 7      * @param numbers 要进行排序的数组
 8      */
 9     public static void selectSort(int[] numbers)
10     {
11         long start,end;    //计时用，算程序的耗时
12         int minIndex;
13         start=System.nanoTime();
14         for(int i=0;i<numbers.length-1;i++)
15         {
16             minIndex=i;
17             for(int j=i+1;j<numbers.length;j++)
18             {
19                 if(numbers[j]<numbers[minIndex])
20                 {
21                     minIndex=j;    //记录本次循环中数据最小的脚标
22                 }            
23             }
24             if(minIndex!=i)    //如果不相等则说明需要进行交换，相等说明当前项就是需要放到最前面的数，进行比较判断避免不必要的交换
25             {
26                 swap(numbers,minIndex,i);
27             }
28         }
29         end=System.nanoTime();
30         System.out.println("2、选择排序，耗时："+(end-start));
31     }

 1 /**  
 2      * 冒泡法排序  
 3      * 1、比较相邻的元素。如果第一个比第二个大，就交换他们两个。  
 4      * 2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素就会是最大的数。 
 5      * 3、针对所有的元素重复以上的步骤，除了最后一个。  
 6      * 4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。  
 7      * @param numbers 要排序的数组
 8      */
 9     public static void bubbleSort(int[] numbers)
10     {
11         long start,end;    //计时用，算程序的耗时
12         start=System.nanoTime();
13         for(int i=0;i<numbers.length-1;i++)
14         {
15             for(int j=0;j<numbers.length-1-i;j++)
16             {
17                 if(numbers[j]>numbers[j+1])
18                 {
19                     swap(numbers,j,j+1);
20                 }
21             }
22         }
23         end=System.nanoTime();
24         System.out.println("冒泡排序，耗时："+(end-start));
25     }

 1 /**
 2      * 加入旗标的冒泡算法
 3      * @param numbers
 4      */
 5     public static void bubbleSortEx(int[] numbers)
 6     {
 7         boolean flag = true;//旗标
 8         long start,end;    //计时用，算程序的耗时
 9         start=System.nanoTime();
10         for(int i=0;i<(numbers.length-1)&&flag==true;i++)
11         {
12             flag=false;
13             for(int j=0;j<numbers.length-1-i;j++)
14             {
15                 if(numbers[j]>numbers[j+1])
16                 {
17                     swap(numbers,j,j+1);
18                     flag=true;//如果本次循环中没有发生任何依次交换，则旗标flag的值就会为false；排序已经完成，这时外层循环条件也会不成立。避免了不必要的比较与交换
19                 }
20             }
21         }
22         end=System.nanoTime();
23         System.out.println("旗标改进过的冒泡排序，耗时："+(end-start));
24     }

 1 /*
 2          * 快速排序的排序算法
 3          * @param a 要排序的数组
 4          * @param  low 要排序的开始的索引值
 5          * @param  height 要排序的结束的索引值
 6          */
 7         public static void quickSort(int a[], int low, int height)
 8         {
 9             if (low < height) 
10             {
11                 //调用算法，将数组分成大于关键元素和小于关键元素的两部分，获取返回的关键元素的位置
12                 int result = partition(a, low, height);
13                 //小于关键元素的部分递归调用快排序
14                 quickSort(a, low, result - 1);
15                 //大于关键元素的部分递归调用快排序
16                 quickSort(a, result + 1, height);
17             }
18         }
19         
20         //核心算法
21         //以关键元素将数组分成大于关键元素和小于关键元素的两部分，
22         //函数返回最终关键元素位于数组的位置
23         public static int partition(int a[], int low, int height)
24         {
25             //以第一个数组元素作为关键数据key；
26             int key = a[low];
27             while (low < height) 
28             {
29                     //从height开始向前搜索，即由后开始向前搜索，找到第一个小于key的值，两者交换；
30                     while (low < height && a[height] >= key)
31                         height--;                
32                     a[low] = a[height];
33                     //从low开始向后搜索，即由前开始向后搜索，找到第一个大于key的值，两者交换；
34                     while (low < height && a[low] <= key)
35                         low++;
36                     a[height] = a[low];
37                     //重复上面的两步直到low=height；
38             }
39             a[low] = key;
40             return low;
41         }