排序方式Java代码实现（快速排序，插入排序，冒泡排序，希尔排序，选择排序）

快速排序

无序区排序时选择一个元素作为基准（此处选用第一个元素作为基准），大于基准得放到右边，小于基准的放到左边。排序结束后，再对基准左右两边得无序区进行快速排序

例如：
定义数组为[1,5,6,3,4,8,7,2]
1)第一次排序时，将1作为基准，排序后为(1)、(5,6,3,4,8,7,2)
2)第二次排序时，因为左边没有无序区，对右边的无序区进行排序，选择5作为基准，排序后为(1)、(2,4,3)、(5)、(8,7,6)
3)第三次排序时，左边无序区选择2作为基准，右边无序区选择8作为基准，排序后为(1)、(2)、(4,3)、(5)、(6,7)、(8)
4)第四次排序时，分别选择4、6为基准，排序后为(1)、(2)、(3)、(4)、(5)、(6)、(7)、(8)

代码如下

//定义快速排序方法 参数列表：待排序数组，起始坐标，结束坐标
public static void sort(int[] arr,int start,int end){
    //为左、右坐标赋值
    int left=start;
    int right=end;
    //定义基准元素
    int temp;
    //起始坐标小于结束左边，进行排序
    if(start<end){
        //为继续准元素赋值
        temp=arr[left];
        //左边坐标不等于右边坐标 从区间两边交替向中间扫描
        while (left!=right){
            //从右向左扫描  当右边坐标的值大于等于基准，继续比较下一个
            while(right>left&&arr[right]>=temp){
                right--;
            }
            //当右边坐标的值小于基准，将右边坐标的值移动到基准左边
            arr[left]=arr[right];

            //从左向右扫描  当左边坐标的值小于于等于基准，继续比较下一个
            while(left<right&&arr[left]<=temp){
                left++;
            }
            //当左边坐标的值大于基准，将左边坐标的值移动到基准右边
            arr[right]=arr[left];
        }
        //将基准插入中间位置
        arr[left]=temp;

        //输出
        System.out.println(Arrays.toString(arr));

        //对左边区间和右边区间进行递归调用
        sort(arr,start,left-1);
        sort(arr,left+1,end);
    }
}

直接插入排序

每次排序时，将无序区元素与有序区元素进行比较，插入到合适位置，直至无序区所有元素插入完

例如：
定义数组为[1,5,6,3,4,8,7,2]
1)第一次排序时，有序区没有数据，直接将无序区第一个元素1插入，排序后数组为(1)、(5,6,3,4,8,7,2)
2)第二次排序后，遍历有序区，将无序区第二个元素5插入，排序后数组为(1,5)、(6,3,4,8,7,2)
3)第三次排序后，遍历有序区，将无序区第三个元素6插入，排序后数组为(1,5,6)、(3,4,8,7,2)
4)第四次排序后，遍历有序区，将无序区第四个元素3插入，排序后数组为(1,3,5,6)、(4,7,8,2)
5)第五次排序后，遍历有序区，将无序区第五个元素4插入，排序后数组为(1,3,4,5,6)、(7,8,2)
6)第六次排序后，遍历有序区，将无序区第六个元素7插入，排序后数组为(1,3,4,5,6,7)、(8,2)
7)第七次排序后，遍历有序区，将无序区第七个元素8插入，排序后数组为(1,3,4,5,6,7,8)、(2)
8)第八次排序后，遍历有序区，将无序区最后一个元素2插入，无序区没有元素，排序结束。排序后数组为(1,2,3,4,5,6,7,8)

代码如下：

//定义数组
int[] arr={1,5,6,3,4,8,7,2};
//标识待插入元素
int temp;
//一个一个将无序区数字插入
for (int i = 1; i < arr.length; i++) {
   //为待插入元素赋值
   temp=arr[i];
   int y;
   //遍历有序区
   for(y=i-1;y>0;y--){
       //判断 有序区元素大于待插入元素，向后移
       if(arr[y]>temp){
           arr[y+1]=arr[y];
       }else{
           break;
       }
   }
   //插入元素
   arr[y+1]=temp;
   System.out.println("第"+i+"次排序"+ Arrays.toString(arr));
}

希尔排序

定义固定值n（此处使用数组长度作为n），设置增量d初始值为n/2，每次排序后d=d/2，每次排序时，将索引相隔为d得元素作为一组，对每组进行直接插入排序，直至增量为1结束排序

例如：
定义数组为[1,8,5,7,3,2,4,6] , n=arr.length
1)第一次排序时，d=n/2=4 ;分组并排序后为(1,3)、(2,8)、(4,5)、(6,7)。排序后数组为[1,2,4,6,3,8,5,7].
2)第二次排序时，d=d/2=2 ;分组并排序后为(1,3,4,5)、(2,6,7,8) 。排序后数组为[1,2,3,6,4,7,5,8]
3)第三次排序时，d=d/2=1 ;分组并排序后为(1,2,3,4,5,6,7,8)。排序结束

代码如下：

//定义数组
int[] arr={1,8,5,7,3,2,4,6};
//定义排序次数
int n=1;
//d为增量 当增量为1时排序结束，每次增量/2
for(int d=arr.length/2;d>0;d=d/2){
    //对索引相隔d的元素进行直接插入排序
    for (int i = d; i < arr.length; i++) {
        //标识待插入元素
        int temp=arr[i];
        //找到相隔d的坐标
        int j=i-d;
        //循环对元素进行排序 将大于待排序元素的元素后移
        while(j>=0&&temp<arr[j]){
            //元素后移
            arr[j+d]=arr[j];
            //寻找与当前坐标相隔d的坐标
            j=j-d;
        }
        //插入待插入元素
        arr[j+d]=temp;
    }
    //输出
    System.out.println("第"+n+"次排序"+ Arrays.toString(arr));
    System.out.println("d = "+d);
    //排序次数+1
    n++;
}

冒泡排序

对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序。如果有n个数据进行排序，总共需要比较n-1次。每一次比较完毕，下一次的比较就会少一个数据参与

例如：
定义数组为[1,5,6,3,4,8,7,2]
1)第一次排序时，相邻元素两两比较，将最大元素8放到了最后面，排序结果为(1,5,3,4,6,7,2)、(8)
2)第二次排序时，相邻元素两两比较，将最大元素7放到了最后面，排序结果为(1,3,4,5,6,2)、(7,8)
3)第三次排序时，相邻元素两两比较，将最大元素6放到了最后面，排序结果为(1,3,4,5,2)、(6,7,8)
4)第四次排序时，相邻元素两两比较，将最大元素5放到了最后面，排序结果为(1,3,4,2)、(5,6,7,8)
5)第五次排序时，相邻元素两两比较，将最大元素4放到了最后面，排序结果为(1,3,2)、(4,5,6,7,8)
6)第六次排序时，相邻元素两两比较，将最大元素3放到了最后面，排序结果为(1,2)、(3,4,5,6,7,8)
7)第七次排序时，相邻元素两两比较，将最大元素2放到了最后面，无序区只剩下一个元素，排序结束，共排序7次。排序结果为(1)、(2,3,4,5,6,7,8)

代码如下：

//定义数组
int[] arr={1,5,6,3,4,8,7,2};
//控制遍历次数
for (int i = 0; i < arr.length - 1; i++) {
   //每次将最大的放到最后面
   for (int j = 0; j < arr.length - i - 1; j++) {
       if(arr[j]>arr[j+1]){
           //相邻元素比较
           int temp=arr[j];
           arr[j]=arr[j+1];
           arr[j+1]=temp;
       }
   }
   System.out.println("第"+(i+1)+"次排序"+ Arrays.toString(arr));
}

选择排序

每次选择无序区最小得元素放到无序区最前面，形成有序区

例如：
定义数组为[1,5,6,3,4,8,7,2]
1)第一次排序选出最小值–“1”，放到最无序区前面后数组为(1)、(5,6,3,4,8,7,2)
2)第二次排序选出最小值–“2”，放到最无序区前面后数组为(1,2)、(5,6,3,4,8,7)
3)第三次排序选出最小值–“3”，放到最无序区前面后数组为(1,2,3)、(5,6,4,8,7)
4)第四次排序选出最小值–“4”，放到最无序区前面后数组为(1,2,3,4)、(5,6,8,7)
5)第五次排序选出最小值–“5”，放到最无序区前面后数组为(1,2,3,4,5)、(6,8,7)
6)第六次排序选出最小值–“6”，放到最无序区前面后数组为(1,2,3,4,5,6)、(8,7)
7)第七次排序选出最小值–“7”，放到最无序区前面后数组为(1,2,3,4,5,6,7,8)

代码如下：

//定义数组
int[] arr={1,5,6,3,4,8,7,2};
//确定排序次数   i++有序区每次循环后长度增加  相对应的，无序区长度减少
for (int i = 0; i < arr.length - 1; i++) {
	//标识最小值坐标
	int k = i;
	for (int j = i + 1; j < arr.length; j++) {
	//每次循环找到无序区最小值
	if (arr[j] < arr[k])
		k = j;
	}
	//最小值放到无序区最前面
	if (k != i) {
		int temp = arr[i];
		arr[i] = arr[k];
		arr[k] = temp;
	}
	System.out.println("第"+(i+1)+"次排序"+ Arrays.toString(arr));
}