第五部分-算法-001排序

选择排序
找出最大值及其索引，与最后一个元素交换

/*
选择排序：
    每次找出最大值及其下标，与最后一个数交换
 */
public class SelectSort {
    public static void main(String[] args) {
        int[] arr={3,9,-1,10,-2};
        for(int i=0;i<arr.length-1;i++){
            int max=arr[0];
            int index=0;
            for(int j=0;j<arr.length-1-i;j++){
                if(max<arr[j]){
                    max=arr[j];
                    index=j;
                }
            }
            int temp=arr[index];
            arr[index]=arr[arr.length-1-i];
            arr[arr.length-1-i]=temp;
        }
        System.out.println(Arrays.toString(arr));
    }
}

冒泡排序
两两比较，大的下沉；如果一次完整比较没有下沉，说明有序

/*
冒泡法：
    两两比较，大的下沉；
    如果有一次没有出现下沉，说明数组有序
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr={3,9,-1,10,-2};
        for(int i=0;i<arr.length-1;i++){
            boolean flag=false;
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                    flag=true;
                }
            }
            if(!flag)break;
        }
        System.out.println(Arrays.toString(arr));
    }

}

插入排序

/*
插入排序：
    待排序的数与它前面的有序数组依次进行比较，小的话就插入
 */
public class InsertSort {
    public static void main(String[] args) {
        int[] arr={3,9,-1,10,-2};
        for(int i=1;i<arr.length;i++){
            int insertVal=arr[i];//取出要插入的数，因为之后的插入操作，是向后写值
            int insertIndex=i-1;//定位插入的位置，初始值是i-1
            while(insertIndex>=0 && insertVal < arr[insertIndex]){
                arr[insertIndex+1]=arr[insertIndex];
                insertIndex--;
            }
            arr[insertIndex+1]=insertVal;
        }
        System.out.println(Arrays.toString(arr));
    }
}

希尔排序
对于[2,3，4,5，6,1]，1插入时，插入排序后移次数太多，因此，希尔排序是对插入排序的一种优化
选择移位式希尔排序

/*
    交换式希尔排序：
        缺点：0 1 3 9 7
            9和7比较完之后=====》0 1 3 7 9====》然后是3和7比较====》有序
            但是1和3，以及0和1，还会继续比较
 */
public class ShellSort1 {
    public static void main(String[] args) {
        int[] arr={3,9,-1,10,-2};
        for(int gap = arr.length / 2 ; gap > 0 ; gap /= 2){ //定义每次循环的增量
            //i定位到第（1,2，...）个数组的第（2,3，...length）个元素
            for(int i = gap ; i < arr.length ; i++){
                //j根据i定位到第（1,2，...）个数组的第（2-1,3-1，...length-1）个元素
                for(int j = i - gap ; j >= 0 ; j -= gap){
                    //当前元素与步长之后的元素比较，大则交换
                    if(arr[j] > arr[j+gap]){
                        int temp=arr[j];
                        arr[j]=arr[j+gap];
                        arr[j+gap]=temp;
                    }
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

public class ShellSort2 {
    public static void main(String[] args) {
        int[] arr={8,9,1,7,2,3,5,4,6,0};
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {

                int insertIndex=i-gap;
                int insertVal = arr[i];
                while (insertIndex>= 0 && insertVal< arr[insertIndex]) {
                    // 移动
                    arr[insertIndex+gap] = arr[insertIndex];
                    insertIndex -= gap;
                }
                arr[insertIndex+gap] = insertVal;

            }
        }
        System.out.println(Arrays.toString(arr));
    }
}