Java面试之七大排序算法

#冒泡排序

排序原理：

1、比较相邻的两个元素，如果前一个元素比后一个元素大，就交换两个元素的位置。

2、对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素，最终最后位置的元素就是最大值

public static void bubbleSort(int[] nums){
        //控制冒泡轮次，最后一次冒泡不用比较
        for (int i = 0; i < nums.length - 1; i++){
            //每次比较完之后，就减少一次比较
            for (int j = 0; j < nums.length - 1 - i; j++){
                if(nums[j] > nums[j + 1]){
                    //交换两个数字的位置
                    nums[j] = nums[j] + nums[j + 1];
                    nums[j + 1] = nums[j] - nums[j + 1];
                    nums[j] = nums[j] - nums[j + 1];
                }
            }
        }
    }

#选择排序

排序原理：

将未排序的第一个数字和剩余的每个数字进行对比，如果大于则换位，

public static void SelectionSort(int[] arr){
        //控制比较次数，最后一次不用比较
        for (int i = 0; i < arr.length; i++){
            //第一个元素跟后面元素比较，第一轮找出最小值
            for(int j = i + 1; j < arr.length; j++){
                if(arr[i] > arr[j]){
                    //交换两个元素位置
                    arr[i] = arr[i] + arr[j];
                    arr[j] = arr[i] - arr[j];
                    arr[i] = arr[i] - arr[j];
                }
            }
        }
    }

#插入排序

排序原理：

将0索引的元素到N索引的元素看做是有序的，把N+ 1索引的元素到最后一个看做是无序的，遍历无序的数据，将遍历的元素插入到有序序列中适当的位置，如遇到相同的数据，插在后面

public static void insertSort(int[] arr){
        //定义无序数组默认起始索引
        int startIndex = -1;
        //找出无序数组起始索引
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > arr[i + 1]){
                startIndex = i + 1;
                break;
            }
        }
        //遍历无序数组
        for(int i = startIndex; i < arr.length;i++){
            //表示当前无序元素的下标
            int unsortIndex = i;
            //相邻元素开始比较，小的放前面，大的放后面
            while (unsortIndex > 0 && arr[unsortIndex] < arr[unsortIndex - 1]){
                arr[unsortIndex] = arr[unsortIndex] + arr[unsortIndex - 1];
                arr[unsortIndex - 1] = arr[unsortIndex] - arr[unsortIndex - 1];
                arr[unsortIndex] = arr[unsortIndex] - arr[unsortIndex - 1];
                //前移
                unsortIndex--;
            }
        }
    }

#快速排序

排序原理：

定义两个变量，一个从头开始遍历找比基准数大的数字，一个从尾开始找比基准数小的数字，找到之后两个数字交换，然后依次递归即可

public static void quickSort(int[] arr,int i,int j){
        //定义两个索引
        int start = i;
        int end = j;
        //递归出口
        if(start > end){
            return;
        }
        //定义默认基准数
        int baseNum = arr[i];

        while (start != end){
            while (true){
                //找比基础数小的
                if (end <= start || arr[end] < baseNum){
                    break;
                }
                end--;
            }
            while (true){
                //找比基准数大的
                if (start >= end || arr[start] > baseNum){
                    break;
                }
                start++;
            }
            //交换两个元素
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        //基准数归位
        int temp = arr[start];
        arr[start] = arr[i];
        arr[i] = temp;
        //递归遍历基准数左边
        quickSort(arr,i,start - 1);
        //递归遍历基准数右边
        quickSort(arr,start + 1,j);
    }