java排序 冒泡排序，选择排序，插入排序，希尔排序，快速排序

冒泡排序

相邻元素比较，大的向右冒泡

public class Bubble {//相邻元素比较，大的向右冒泡
    public static void main(String[] args) {
        int[] nums={10,38,65,97,76,13};
        for (int i = 0; i < nums.length; i++) {
            for (int j=0;j<nums.length-i-1;j++){
                if (nums[j+1]<nums[j])
                {
                    int t=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=t;
                }
            }
        }
        for (int num : nums) {
            System.out.println(num);
        }
    }
}

选择排序

直接插入
选出固定位置与后面元素逐个比较，交换

        for (int i = 0; i < nums.length-1; i++) {
            for (int j = i+1; j < nums.length; j++) {
                if (nums[i]>nums[j]){
                    int t=nums[i];
                    nums[i]=nums[j];
                    nums[j]=t;
                }
            }
        }

优化后无需多次交换，pos直接指向最小值进行交换

for (int i = 0; i < nums.length-1; i++) {//优化后无需多次交换，pos直接指向最小值进行交换
            int pos=i;
            for (int j = i+1; j <nums.length ; j++) {
                if (nums[pos]>nums[j]){
                    pos=j;
                }
            }
            if(i!=pos){
                int t=nums[i];
                nums[i]=nums[pos];
                nums[pos]=t;
            }
        }

插入排序

前边有序，后边无序，后边的跟前边的逐个比较，确定位置

        for (int i = 1; i < nums.length; i++) {
            for (int j = i-1; j >=0; j--) {
                if(nums[j+1]<nums[j]){//从i的位置向前边的有序表插入
                    int t=nums[j+1];
                    nums[j+1]=nums[j];
                    nums[j]=t;
                }
            }

        }

优化后只需一次交换，在选出元素位置挖出一个坑，前边的元素依次后移，最后把选出元素填入前边的坑

for (int i = 1; i < nums.length; i++) {
            int temp=nums[i];
            int pos=i;
            for (int j = i-1; j >=0 ; j--) {
                if (temp<nums[j]){//拿选出的值依次与前边的逐个比较
                    nums[j+1]=nums[j];//挖出空缺位置 逐位后移 把值填入
                    pos=j;
                }else {
                    break;
                }

            }
            nums[pos]=temp;
        }

希尔排序

直接插入的优化，通过设置间隔让元素分组进行插入排序

int[] nums={10,38,65,97,76,13,27,49,78,34,12,64,1};
        int gap=nums.length;
        while (gap!=1){
            gap/=2;
            for (int i = 0; i <gap ; i++) {
                for (int j=i+gap;j<nums.length;j+=gap){
                    int temp=nums[j];
                    int pos=j;
                    for (int k =j-gap; k >=0 ; k-=gap) {
                        if (temp<nums[k]){
                            nums[k+gap]=nums[k];
                            pos=k;
                        }
                    }
                    nums[pos]=temp;
                }
            }
        }

快速排序

后边指针先动，相遇时停下

public static void quickSort(int[] arr,int start,int end){
        int i=start;int j=end;
        int p=arr[start];//取第一个元素作为轴
        while (i<j){
            //从后向前
            while (i<j&&p<arr[j]){
                j--;
            }
            arr[i]=arr[j];//小于轴的元素去前边的坑
            i++;
            //从前向后
            while (i<j&&arr[i]<p){
                i++;
            }
            arr[j]=arr[i];//大于轴的元素去arr[j]前移后留下的坑
            j--;
        }
        arr[i]=p;
        //此时i,j相等，都指向目前轴所在的位置
        //前面有元素
        if(i-2>=start){//前边至少有两个数才需要再排序
            quickSort(arr, start, i-1);
        }
        //后面又元素
        if(j+2<=end){//后边至少有两个数才需要再排序
            quickSort(arr, j+1, end);
        }
    }