java三种排序算法的实现

三种简单排序算法（java实现）

一、冒泡排序

算法思想：遍历待排序的数组，每次遍历比较相邻的两个元素，如果他们的排列顺序错误就交换他们的位置，经过一趟排序后，最大的元素会浮置数组的末端。重复操作，直到排序完成。

示例演示：

                  待排序数组：4，3，7，6，9

       第一趟：9，7，3，4，6
       第二趟：9，3，4，6，7
       第三趟：9，4，3，6，7
       第四趟：9，6，3，4，7
       第五趟：9，7，3，4，6
       第六趟：9，7，4，3，6
       第七趟：9，7，6，3，4
       第八趟：9，7，6，4，3 

算法实现：

/**  
 * 冒泡法排序<br/>  

 * <li>比较相邻的元素。如果第一个比第二个大，就交换他们两个。</li>  
 * <li>对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。</li>  
 * <li>针对所有的元素重复以上的步骤，除了最后一个。</li>  
 * <li>持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。</li>  

 *   
 * @param numbers  
 *            需要排序的整型数组  
 */  
public static void bubbleSort(int[] numbers) {   
    int temp; // 记录临时中间值   
    int size = numbers.length; // 数组大小   
    for (int i = 0; i < size - 1; i++) {   
        for (int j = i + 1; j < size; j++) {   
            if (numbers[i] < numbers[j]) { // 交换两数的位置   
                temp = numbers[i];   
                numbers[i] = numbers[j];   
                numbers[j] = temp;   
            }   
        }   
    }   
}  

算法时间复杂度：O(n²)      外层循环需要比较n-1次，内层循环需要比较n次。

二、选择排序

算法思想：重待排序的数组中选择一个最小的元素，将它与数组的第一个位置的元素交换位置。然后从剩下的元素中选择一个最小的元素，将它与第二个位置的元素交换位置，如果最小元素就是该位置的元素，就将它和自身交换位置，依次类推，直到排序完成。

示例演示：                    

                        待排序数组：4，3，7，6，9

         第一趟：3，4，7，6，9

         第二趟：3，4，7，6，9

         第三趟：3，4，6，7，9

         第四趟：3，4，6，7，9

         第五趟：3，4，6，7，9

算法实现：

 1 /**  
 * 选择排序<br/>  
 * <li>在未排序序列中找到最小元素，存放到排序序列的起始位置</li>  
 * <li>再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。</li>  
 * <li>以此类推，直到所有元素均排序完毕。</li>  

 *   
 * @param numbers  
 */  
public static void selectSort(int[] numbers) {   
    int size = numbers.length, temp;   
    for (int i = 0; i < size; i++) {   
        int k = i;   
        for (int j = size - 1; j >i; j--)  {   
            if (numbers[j] < numbers[k])  k = j;   
        }   
        temp = numbers[i];   
        numbers[i] = numbers[k];   
        numbers[k] = temp;   
    }   
}  

时间复杂度：O(n²)     需要n² /2次比较和n次交换

三、插入排序

算法思想：从数组的第二个元素开始遍历，将该元素与前面的元素比较，如果该元素比前面的元素小，将该元素保存进临时变量中，依次将前面的元素后移，然后将该元素插入到合适的位置。每次排序完成后，索引左边的元素一定是有序的，但是还可以移动。对于倒置越少的数组，该算法的排序效率越高。

示例演示：

              

              待排序数组：4，3，7，6，9

         第一趟：3，4，7，6，9

         第二趟：3，4，7，6，9

         第三趟：3，4，6，7，9

         第四趟：3，4，6，7，9

 

算法实现：

代码
/**  
 * 插入排序<br/>  
 * <ul>  
 * <li>从第一个元素开始，该元素可以认为已经被排序</li>  
 * <li>取出下一个元素，在已经排序的元素序列中从后向前扫描</li>  
 * <li>如果该元素（已排序）大于新元素，将该元素移到下一位置</li>  
 * <li>重复步骤3，直到找到已排序的元素小于或者等于新元素的位置</li>  
 * <li>将新元素插入到该位置中</li>  
 * <li>重复步骤2</li>  
 * </ul>  
 *   
 * @param numbers 
 */  
public static void insertSort(int[] numbers) {   
    int size = numbers.length, temp, j;   
    for(int i=1; i<size; i++) {   
        temp = numbers[i];   
        for(j = i; j > 0 && temp < numbers[j-1]; j--)   
            numbers[j] = numbers[j-1];   
        numbers[j] = temp;   
    }   
}  

时间复杂度：O(n²)       最坏情况下n² /2次比较，n² /2交换    最好情况N-1次比较，0次交换