冒泡排序、选择排序、直接插入排序

我们来了解一下Java中常见的三种排序方式，这里我们说的是

1.冒泡排序

2.选择排序

3.插入排序

排序中要考虑到的主要因素是时间复杂度和空间复杂度，时间我们可以用

System.currentTimeMillis()这个来查看。

下面我们依次来说明：

1、冒泡排序

所谓冒泡排序就是从前到后遍历选出最大值放到最后一个，然后在遍历剩下的找出剩

下中最大的放到倒数第二个，依次直至遍历到最后一个，也就是最小的放到第一个，

使其有序。下面我们来举例说明：

private static void bubbleSort(int[] array) {
		//冒泡排序
		/*
		 * 稳定： 没有跳跃的比较，所以比较稳定
		 * 时间复杂度：o(n^2)
		 */
		// TODO Auto-generated method stub
		
		System.out.println(System.currentTimeMillis());//程序执行的时间
		int tmp=0;
		for(int i=0;i<array.length;i++){//趟数
			for(int j=0;j<array.length-1-i;j++){//比较的次数
				if(array[j+1]<array[j]){
					tmp=array[j];
					array[j]=array[j+1];
					array[j+1]=tmp;
				}
			}
		}
		System.out.println(System.currentTimeMillis());
		
	}
	public static void main(String[] args) {
		//冒泡排序
		//int[] array={12,43,2,1,54,76};
		int[] array=new int[10000];//随机生成一万个数据;
		for(int i=0;i<array.length;i++){
			array[i]=i;
		}
		bubbleSort(array);
		System.out.println(Arrays.toString(array));
		
	}

这里要说明的是这里有两个for循环嵌套，其中第一个for循环是控制比较的趟数（每一趟选出一个最大值），第二个for是比较的次数（比较相邻两个是中较大的值）。
但这个冒泡排序是有缺憾的，是可以优化的。这里我们说一个简单的优化，如果原来的数组就是有序的，那这个排序还是会选择每一个比较，时间复杂度会很大，于是我们可以这么优化：
在第二个for设计一个int类型标志flg定义为0，如果发生交换，那么flg++，如果flg结果为0，说明没有发生交换，那么数组本身就是有序的。函数如下：

public static void newbbsort(int[] array){
		System.out.println(System.currentTimeMillis());
		int tmp=0;
		for(int i=0;i<array.length;i++){//趟数
		int flg=0;
			for(int j=0;j<array.length-1-i;j++){//比较的次数
				if(array[j+1]<array[j]){
					flg++;
					tmp=array[j];
					array[j]=array[j+1];
					array[j+1]=tmp;
				}
			}
			if(i==0&&flg==0)
			{
				break;
			}
		}
		System.out.println(System.currentTimeMillis());
	}

2、选择排序

选择排序就是从第一趟开始，用第一个元素和剩下中的每一个元素比较，如果比第一个小，就和第一个元素交换值，最后使得第一个元素中的值最小，第二趟选择出第二小的放到第二元素，依次，使得数组有序。下面我们举例说明：

public class Test7 {
	public static void main(String[] args) {
		int[] array={23,45,2,3,657,8};		
		selectSort(array);
		System.out.println(Arrays.toString(array));
	}
	public static void selectSort(int[] array){
		int min;
		int tmp;
		for(int i=0;i<array.length;i++){
			min=i;
			for(int j=i;j<array.length;j++){
				if(array[j]<array[min]){
					min=j;//选出最小值下标
				}
			}
			/*
			 * 将第一个元素和最小值交换
			 */
			tmp=array[i];
			array[i]=array[min];
			array[min]=tmp;
		}
	}
}

如同冒泡排序一般，第一个for循环控制趟数，第二个for循环控制每一趟中比较的次数。

3、直接插入排序

插入排序类似于打扑克牌，从第二张牌开始插入，小的插到大的前面，然后使其有序。再拿第三张牌来，找到合适的位置继续插入，使这三张有序。在第四张直至全部插入有序。举例说明：

public class Test7 {
	public static void main(String[] args) {
		int[] array={23,45,2,3,657,8};		
		InsrtSort(array);
		System.out.println(Arrays.toString(array));
	}
	public static void InsrtSort(int[] array){
		//不稳定
		int temp;
		int j;
		for(int i=1;i<array.length;i++){
			temp = array[i];//从i号位置开始进行排序。
			for(j=i-1;j>=0;j--){
				if(array[j]>temp){
					array[j+1]=array[j];
				}else {//每次排序过后前面已经有序，找到第一个比temp小的。
					break;
				}
			}
			array[j+1]=temp;
		}
	}
}