Java算法系列1 — 常见的排序算法

最近本人在工作之余重新温习了Java数据结构，然后萌生了深入学习Java算法的想法。。。
想做就做，虽然这并不是那么容易，但搞Java后台的不懂点算法实在说不过去。做好了学习的目标与规划，于是就从平时看书、看技术栈、视频课、理解后自己练习开始吧。
今天回顾了Java算法基础的8大排序算法（其实自己之前就只会手写3种，其他的方法也只是大概听说过…）所以今天在下班的时间点，我准备整理一下自己的学习笔记，一方面可以加深一遍自己的理解，第二就是哪怕以后忘了也方便查看。

常用排序算法：
1、 交换排序（冒泡排序、快速排序）
2、 插入排序（直接插入排序、希尔排序）
3、 选择排序（简单选择排序、堆排序）
4、 归并排序
5、 基数排序

废话不多说，我就直接开始上代码，具体细节步骤都有注释！

1、最简单的冒泡排序

/**
 * 冒泡排序
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[] {9,5,1,3,7,2,8,4,6};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void bubbleSort(int[] arr){
        //控制比较轮数
        for(int i = 0; i < arr.length-1; i++){
            //控制比较的次数
            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;
                }
            }
        }
    }
}

2、效率高的快速排序

/**
 * 快速排序法
 */
public class QuickSort {
    public static void main(String[] args) {
        int[] arr = new int[] {3,5,1,7,4,9,5,2,8,10};
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
    private static void quickSort(int[] arr, int left, int right){
        if(left > right){
            return;
        }
        //定义标准数
        int base = arr[left];
        //定义移动下标
        int i = left;
        int j = right;
        //开始移动比较
        while(i != j) {
            //先从右往左
            while(i < j && base <= arr[j]) {
                j--;
            }
            //再从左往右
            while(i < j && base >= arr[i]){
                i++;
            }
            //都停下时，交换i,j位置的元素
            int temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
        }
        //i与j相等时，交换i/j位置的元素与基准数位置的元素
        arr[left] = arr[i];
        arr[i] = base;
        //此时i/j位置左右两边递归排序
        //左边
        quickSort(arr, left, i-1);
        //右边
        quickSort(arr, j+1, right);
    }
}

3、简单插入排序

/**
 * 插入排序
 */
public class InsertSort {
    public static void main(String[] args) {
        int[] arr = new int[] {9,3,5,2,8,1,0,7,6,4};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void insertSort(int[] arr){
        //遍历所有数字
        for(int i = 1; i < arr.length; i++){
            //如果当前数字比前一个数字小
            if(arr[i] < arr[i-1]){
                //把当前遍历数字存起来
                int temp = arr[i];
                int j;
                //遍历当前数字前面所有的数字
                for(j = i-1; j >= 0 && temp < arr[j]; j--){
                    arr[j+1] = arr[j];
                }
                arr[j+1] =temp;
            }
        }
    }
}

4、希尔排序

/**
 * 希尔排序
 */
public class ShellSort {
    public static void main(String[] args) {
        int[] arr = new int[] {3,5,1,7,4,9,5,2,8,10};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void shellSort(int[] arr) {
        //遍历所有的步长
        for(int d = arr.length/2; d > 0; d /= 2 ){
            //遍历所有元素
            for(int i = d; i < arr.length; i++){
                //遍历本组中所有元素
                for(int j = i-d; j >= 0; j -= d){
                    //如果当前元素大于加上步长后的那个元素
                    if(arr[j] > arr[j+d]){
                      int temp = arr[j];
                      arr[j] = arr[j+d];
                      arr[j+d] = temp;
                    }
                }
            }
        }
    }
}

5、选择排序

/**
 * 选择排序
 */
public class SelectSort {
    public static void main(String[] args) {
        int[] arr = new int[] {9,4,0,6,7,5,2,1,3,8};
        selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void selectSort(int[] arr){
        //遍历所有的数
        for(int i = 0; i <arr.length; i++){
            int minIndex = i;
            //把当前遍历的数和后面所有数依次进行比较，并记录最小数下标
            for(int j = i+1; j < arr.length; j++){
                if(arr[minIndex]>arr[j]){
                    minIndex = j;
                }
            }
            //如果最小的数和当前遍历的数下标不一致,说明下标为minIndex的数比当前遍历的数更小
            if(i != minIndex){
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }
}

6、归并排序

/**
 * 归并排序
 */
public class MergeSort {
    public static void main(String[] args) {
        int[] arr = new int[] {1,3,5,2,4,6,9,8,7};
//        mergeSort(arr,0,3,arr.length-1);
        merge(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
    public static void merge(int[] arr,int low,int high){
        int middle = (low+high)/2;
        if(low < high) {
            //处理左边
            merge(arr, low, middle);
            //处理右边
            merge(arr, middle + 1, high);
            //归并
            mergeSort(arr, low, middle, high);
        }
    }
    public static void mergeSort(int[] arr,int low,int middle,int high){
        //用于存储归并后的临时数组
        int[] temp = new int[high-low+1];
        //用于记录第一个数组中需要遍历的下标
        int i = low;
        //用于记录第二个数组中需要遍历的下标
        int j = middle+1;
        //用于记录在临时数组中存放的下标
        int index = 0;
        //遍历两个数组取出小的数字，放入临时数组中
        while(i<=middle&&j<=high){
            if(arr[i]<=arr[j]){
                temp[index]=arr[i];
                i++;
            }else {
                temp[index]=arr[j];
                j++;
            }
            index++;
        }
        //处理多余数据
        while(j<=high){
            temp[index]=arr[j];
            j++;
            index++;
        }
        while(i<=middle){
            temp[index]=arr[i];
            i++;
            index++;
        }
        //把临时数组中的数据放入原数组中
        for(int k=0;k<temp.length;k++){
            arr[k+low]=temp[k];
        }
    }
}

7、基数排序

/**
 * 基数排序
 */
public class RadixSort {
    public static void main(String[] args) {
        int[] arr =new int[] {666,234,123,1,9,32,56,78,99,245,5};
        radixSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void radixSort(int[] arr){
        //存数组中最大的数字
        int max = Integer.MIN_VALUE;
        for(int i=0; i<arr.length; i++){
            if(arr[i]>max){
                max = arr[i];
            }
        }
        //计算最大数字是几位数
        int maxLength = (max+"").length();
        //用于临时存储数据的二维数组
        int[][] temp = new int[10][arr.length];
        //用于记录在二维数组中某个数组存放的数据个数
        int[] counts = new int[arr.length];
        //根据最大长度的数决定比较的次数
        for(int i=0,n=1; i<maxLength; n*=10,i++){
            //分别计算每一个数字的余数
            for(int j=0; j<arr.length; j++){
                //取出余数
                int ys = arr[j]/n%10;
                //把当前遍历的数据放入指定数组中
                temp[ys][counts[ys]] = arr[j];
                //记录数量
                counts[ys]++;
            }
            //记录取出元素存放位置
            int index = 0;
            //把数字再取出来
            for(int k=0; k<counts.length; k++){
                if(counts[k] != 0){
                    //循环遍历取出元素
                    for(int l=0; l<counts[k]; l++){
                        arr[index] = temp[k][l];
                        index++;
                    }
                    //把数量置空
                    counts[k]=0;
                }
            }
        }
    }
}

？？怎么只有7个排序算法，哪一个搞掉了？？算啦，，，反正堆排序也不会，就不写了，真是头大。。。