java 选择，插入，冒泡排序

1，选择排序

原理：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

public int[] select(){
  int t=0;
  int[] a= new int[]{10,17,45,8,75,24,44,11,7};
  
  for(int i=0;i<a.length-1;i++) 
  { 
   for(int j=i+1;j<a.length;j++)
    if(a[j]<a[i])
     {t=a[i];
     a[i]=a[j];
     a[j]=t;}
  
  //System.out.println("  第"+(i+1)+"趟后数组为："+Arrays.toString(a)); 
  }
 
   return a;
 }

分步运行：
第2趟后数组为：[10, 17, 45, 8, 75, 24, 44, 11, 7]
第3趟后数组为：[10, 17, 45, 8, 75, 24, 44, 11, 7]
第4趟后数组为：[8, 10, 17, 45, 75, 24, 44, 11, 7]
第5趟后数组为：[8, 10, 17, 45, 75, 24, 44, 11, 7]
第6趟后数组为：[8, 10, 17, 24, 45, 75, 44, 11, 7]
第7趟后数组为：[8, 10, 17, 24, 44, 45, 75, 11, 7]
第8趟后数组为：[8, 10, 11, 17, 24, 44, 45, 75, 7]
第9趟后数组为：[7, 8, 10, 11, 17, 24, 44, 45, 75]

2，插入排序
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列
a、(1)第一部分包含了这个数组的所有元素，但将最后一个元素除外，而第二部分就只包含这一个元素
(2)在第一部分排序后，再把这个最后元素插入到此刻已是有序的第一部分里的位置
b、插入排序的核心思想是局部有序，非局部有序的元素与局部有序的元素比较，并排 序，直到全部有序，这个过程局部有序序列不断变大。空间复杂度为O（n*n）,但是比冒泡和选择排序速度快

import java.util.Arrays;

public class Test{
	public static void main(String[] args){
		int[] array = {34,8,64,51,32,21};
		System.out.println("插入排序数组为："+Arrays.toString(array));
		for(int i=1;i<array.length;i++) {
			int temp = array[i];	//插入元素的值
			int index=i;			//插入元素的下标值
				//array[i]与 它前面的元素(a[0]-a[i-1])进行比较。
			for(int j=i-1;j>=0;j--) {
							//当a[i]比前一个元素小，将前一个元素向后移动。
				if (temp < array[j]) {
					array[j + 1] = array[j];
					index--;				//插入元素下标值减小
				} 
				System.out.println("第"+(i+1)+"趟后数组为："+Arrays.toString(array));
			}
		//最后将a[0]-a[i-1]之间移动后空缺的位置array[index]插入a[i]
			array[index] = temp; 
			System.out.println("第"+(i+1)+"趟后数组为："+Arrays.toString(array)); 
		}
	}
}

从第二项开始依次与前面的比较，小于前一项，插入交换

插入排序数组为：[34, 8, 64, 51, 32, 21]
第2趟后数组为：[8, 34, 64, 51, 32, 21]
第3趟后数组为：[8, 34, 64, 51, 32, 21]
第4趟后数组为：[8, 34, 51, 64, 32, 21]
第5趟后数组为：[8, 32, 34, 51, 64, 21]
第6趟后数组为：[8, 21, 32, 34, 51, 64]

插入排序数组为：[34, 8, 64, 51, 32, 21]
[34, 34, 64, 51, 32, 21]
第2趟后数组为：[8, 34, 64, 51, 32, 21]
[8, 34, 64, 51, 32, 21]
[8, 34, 64, 51, 32, 21]
第3趟后数组为：[8, 34, 64, 51, 32, 21]
[8, 34, 64, 64, 32, 21]
[8, 34, 64, 64, 32, 21]
[8, 34, 64, 64, 32, 21]
第4趟后数组为：[8, 34, 51, 64, 32, 21]
[8, 34, 51, 64, 64, 21]
[8, 34, 51, 51, 64, 21]
[8, 34, 34, 51, 64, 21]
[8, 34, 34, 51, 64, 21]
第5趟后数组为：[8, 32, 34, 51, 64, 21]
[8, 32, 34, 51, 64, 64]
[8, 32, 34, 51, 51, 64]
[8, 32, 34, 34, 51, 64]
[8, 32, 32, 34, 51, 64]
[8, 32, 32, 34, 51, 64]
第6趟后数组为：[8, 21, 32, 34, 51, 64]

2，冒泡排序
相邻的俩个元素比较,让值较大的数据逐渐向数组的底部(即朝最后一个元素)移动。

public void sort(int[] a) {
			for(int i=0;i<a.length-1;i++) 
				for(int j=0;j<a.length-i-1;j++) 
					if(a[j]>a[j+1]) {
						int temp = a[j];
						a[j] = a[j+1];
						a[j+1] = temp;
					}
		}