八大排序的java实现（上）

1、冒泡排序

冒泡排序属于交换排序的一种，是基本的排序算法，最坏的时间复杂度为O(n²)，最好的时间复杂度为O(n²)，平均时间复杂为O(n²)，冒泡排序是稳定的排序。

以下是百度百科对算法过程的描述：

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

为方便看出效果，在此使用最坏情况。排序中用到的方法代码如下：

/**
	 * 交换两个数
	 * @param i
	 * @param j
	 */
	public static void swap(int[]array,int i,int j){
		int temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}

/**
	 * 打印出排序步骤
	 * @param array	打印的数组
	 * @param times	排序的次数
	 */
	public static void showProcess(int[] array,int times){
		for(int a : array){
			System.out.print(a+" ");
		}
		System.out.println("  第"+times+"次");
	}

冒泡 排序 代码如下：

/**
	 * 冒泡排序
	 * @param array 要排序的数组
	 */
	public static void bubbleSort(int[] array){
		final int length = array.length;
		System.out.println("the process of Sort:");
		for(int i = 0; i < length -1; i++){
			for(int j = length-1; j > 0; j--){
				if(array[j] < array[j-1])
					swap(array,j,j-1);
			}
			showProcess(array, i+1);
		}
	}

排序过程如下：

2、简单选择排序

简单选择排序是选择排序的一种，简单选择排序每次从数组中找出一个最小的数，放在数组的第一个位置，然后在第二个位置找第二小的数，依此类推，进行N-1次后，

数组就排好序了。简单选择排序的最好和最坏情况都是O(n²)，平均时间复杂度为O(n²)，简单选择排序是不稳定的排序算法。

简单选择排序代码如下：

/**
	 * 选择排序
	 * @param array	要排序的数组
	 */
	public static void selectSort(int[] array){
		final int length = array.length;
		int min;    //存放数组中最小的数
		for(int i = 0; i < length-1; i++){
			min = array[i];
			for(int j = i+1; j < length; j++){
				if(min > array[j]){
					int temp = min;
					min = array[j];
					array[j] = temp;
				}
			}
			array[i] = min;
			showProcess(array, i+1);
		}
	}

排序过程如下：

3、直接插入排序

直接插入排序是插入排序的一种，主要是假设数组是有序的，需要在有序的数组中插入一个数。于是将待排序的数组分成两部分，前面的部分是有序的，后面的部分是无序的，于是从无序的数中取出一个数来插入前面有序的数中，当取完无序的部分时，整个数组就是有序的了。直接插入排序的最好情况是O(n)，最坏情况是O(n²)，直接插入排序的平均时间复杂度是O(n²)，是稳定的排序方法。

直接插入排序的代码如下：

/**
	 * 直接插入排序
	 * @param array	要排序的数组
	 */
	public static void insertSort(int[] array){
		final int length = array.length;
		int temp = 0;   //用来存放待插入的值
		for(int i = 1; i < length; i++){
			temp = array[i];
			int j = i - 1;
			for(;j >= 0 && array[j] > temp; j--){
				array[j+1] = array[j];
			}
			array[j+1] = temp;
			showProcess(array, i);
		}
	}

排序过程如下：

4、希尔排序

希尔排序也是插入排序的一种，主要思想是将数组按照某个增量分成若干个子数组分别进行直接插入排序，然后依次递减增量进行排序，当增量足够小的时候，再对所有进行直接插入排序，因为在数组基本有序的情况下，直接插入排序的效率是很高的，因此可以使整个排序达到较高的效率。希尔排序在最好的情况是O(n)，最坏情况是 O(n²)，平均时间复杂度比O(n²)少点，大概O(n)nr的1.3次方左右。希尔排序是不稳定的排序。

希尔排序代码如下所示：

public static void showProcess(int[] array,int gap){
		System.out.println("间隔为 "+gap+" 时，分为 "+gap+" 组，并为每组排好序：");
		for(int j = 0; j < gap; j++){
		for(int i = j; i < array.length; i = i + gap){
			System.out.print(array[i]+" ");
		}
		System.out.println();
		}
	}

/**
	 * 希尔排序
	 * @param array	要排序的数组
	 */
	public static void shellSort(int[] array){
		final int length = array.length;
		for(int gap = length/2; gap > 0; gap = gap/2){
			for(int i = gap; i < length; i++){
				for(int j = i - gap; j >= 0 && array[j] > array[j+gap]; j = j - gap){
					swap(array,j,j+gap);
				}
			}
			showProcess(array, gap);
		}
	}

过程如下所示：