day07-插入排序、希尔排序、快速排序、归并排序的思路及代码实现

插入排序思路

  插入排序是一种简单直观的排序算法，其基本思想是将一个元素插入到已经排好序的数组中的合适位置，使得插入后数组仍然有序。

插入排序代码实现 

package algorithm.day07;

import java.util.Arrays;

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {101,34,119,1};
        insertSort(arr);
    }
    //插入排序
    public static void insertSort(int[] arr) {
        //一轮一轮逐步推导
        for (int i = 1; i < arr.length; i++) {
            int insertValue = arr[i];
            int insertIndex = i - 1;//即arr[n]前面这个数的下标

            //给insertValue找打插入的位置
            //没找到插入的位置，就要将arr[insertIndex]后移
            while (insertIndex >= 0 && insertValue < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];//将它后移
                insertIndex--;//循环退出的条件，找到最前面也没有比它更小的，就与前一个换位置
            }
            //当退出while循环时，说明插入的位置找到，就是index+1的位置
            arr[insertIndex + 1] = insertValue;
            System.out.println(i+"轮输出");
            System.out.println(Arrays.toString(arr));
        }
    }
}

希尔排序

  也是一种插入排序，是简单插入排序的优化,尽量减少排序次数

 希尔排序代码实现

  交换法，效率较低

public static void shellSort(int[] arr){
        int temp = 0;
        //循环处理
        for (int gap = arr.length/2;gap > 0;gap /= 2){
            for (int i = gap;i < arr.length;i++){
                for (int j = i - gap;j >= 0;j -= gap){//遍历各组中的元素，共gap组，步长gap
                    //如果当前元素大于加上步长后的那个元素，就进行交换
                    if (arr[j] > arr[j + gap]){
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
        }
        System.out.println("排序结果等于"+ Arrays.toString(arr));
    }

  移位法

 public static void shellSort2(int[] arr){
        for (int gap = arr.length/2;gap > 0;gap /= 2){
            //从第gap个元素，逐个对 其所在的组进行直接插入排序
            for (int i = gap;i < arr.length;i++){
                int j = i;
                int temp = arr[i];
                while (j - gap >= 0 && arr[j - gap] > temp){
                    arr[j] = arr[j - gap];
                    j -= gap;
                }
                //退出while循环，就给temp找到了插入的位置
                arr[j] = temp;
            }
        }
        System.out.println("排序结果等于"+ Arrays.toString(arr));
    }

快速排序

  是对冒泡排序的改进，就是找一个中间值，比这个数大的放到右边，小的放到左边，运用递归，从而达成排序

 快速排序代码实现

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {-9,78,0,23,-567,70};
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
    public static void quickSort(int[] arr,int left,int right) {
        int l = left;//左下标
        int r = right;//右下标
        int pivot = arr[(l + r) / 2];//pivot中轴值
        int temp = 0;//交换时使用
        //循环的目的是让比pivot值小放到左边，大放到右边
        while (l < r) {
            while (arr[l] < pivot) {//在左边找，找到比pivot大的值
                l += 1;
            }
            while (arr[r] > pivot) {
                r -= 1;
            }
            //交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            //如果l >= r说明已经找完了
            if (l >= r) {
                break;
            }
            //如果交换完后，发现arr[l] == pivot,就让r--；
            if (arr[l] == pivot){
                r--;
            }
            if (arr[r] == pivot){
                l++;
            }
        }
        //开始递归
        //应该先判断是否l == r
        if (l == r){
            l++;
            r--;
        }
        //向左递归
        if (left < r){
            quickSort(arr,left,r);
        }
        //向右递归
        if (right > l){
            quickSort(arr,l,right);
        }
    }
}

归并排序

  归并排序（Merge Sort）是一种经典的排序算法，采用分治法（Divide and Conquer）的思想实现。其基本思路是将待排序的序列分成若干个子序列，分别进行排序，然后再将已排序的子序列合并成一个有序序列。

 归并排序代码实现

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {8,4,5,7,1,3,6,2};
        int[] temp = new int[arr.length];//归并排序需要一个额外的空间
        mergeSort(arr,0,arr.length -1,temp);
        System.out.println(Arrays.toString(arr));
    }

    //分+合并的方法
    public static void mergeSort(int[] arr,int left,int right,int[] temp){
        if(left < right){
            int mid = (left + right)/2;//中间索引
            mergeSort(arr, left, mid, temp);//左边递归分割
            mergeSort(arr, mid + 1, right, temp);//向右递归进行分解
            merge(arr,left,right,mid,temp);
        }
    }
    /**
     *
     * @param arr  待排序的原始数组
     * @param left 左边有序数列的索引
     * @param right 右边有序数列的索引
     * @param mid 中间索引
     * @param temp 做中转的数组
     */
    public static void merge(int[] arr,int left,int right,int mid,int[] temp){
        int i = left;//初始化i，左边有序序列的初始索引
        int j = mid + 1;//初始化j，右边有序序列的初始索引
        int t = 0;//临时数组temp的索引，用来存放
        //1、先将左右两边按照规则进行存放
        while (i <= mid && j <= right){
            //如果左边的数小于右边的就填充到临时数组，反之右边的填充进去
            if (arr[i] <= arr[j]){
                temp[t] = arr[i];
                t += 1;
                i += 1;
            }else {
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }
        }
        //2、把有剩余数据的一边的数据依次存放到temp
        while (i <= mid){
            temp[t] = arr[i];
            t += 1;
            i += 1;
        }
        while (j <= right){
            temp[t] = arr[j];
            t += 1;
            j += 1;
        }
        //3、把temp数组中的值拷贝到arr,但是不是每次都拷贝所有
        t = 0;
        int tempLeft = left;
        while (tempLeft <= right){
            arr[tempLeft] = temp[t];
            t += 1;
            tempLeft += 1;
        }
    }
}

今日到此为此，还是谨记，他强任他强，清风拂山岗，路在自己的脚下