【日积月累】算法常用面试题

java面试常见算法

时间复杂度

冒泡排序

原理： 最简单的一种排序算法。假设长度为n的数组arr，要按照从小到大的排序，则冒泡排序的具体过程可以描述为：首先从数组的第一个元素开始到数组的最后一个元素为止，对数组中相邻的两个元素进行比较，如果相邻两个元素中左边的元素大于右边的元素，则交换两个元素的位置，此时数组最右端的元素即为该数组中所有元素的最大值。接着对该数组剩下的（n-1）个元素进行冒泡排序，直到整个数组有序排列。
**总结：由数组中的第一个元素开始，与他相邻的元素进行比较，如果当前元素的值小于它的下一个元素，则顺序不变，如果当前元素的值大于它的下一个元素，则两个元素交换位置，也就是说在第一轮排序时就会将最大的值π到了数组的最后一位。 **

public class BubblSort {
    public static void main(String[] args) {
        int[] arr = new int[]{3,2,78,34,50,89,1,45,7};
        System.out.println("before" + Arrays.toString(arr));
        sortSelect(arr);
        System.out.println("after" + Arrays.toString(arr));
    }
    
    static void sortSelect(int[] arr){
    for(int i=0;i < arr.length-1; i++) {
        for (int j = 0; j < arr.length - 1; j++) {
            //比较相邻的元素，第一个比第二个大，则调换位置，除了最后一个，针对所有元素都要进行相邻比较，在这轮循环中，最后的元素是最大的数
            if (arr[j] > arr[j + 1]) {
                int aa = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = aa;
            }
        }

    }
        
    }
}

直接选择排序

原理： 在严蔚敏版本的《数据结构》中对选择排序的基本描述为：每一轮在n-i+1(i=1,2,…,n-1)个记录中选择关键字最小的记录作为有序序列中第 i个记录。假设长度为n的数组arr，要按照从小到大排序，那么先从n个数字中找到最小值min1，如果最小值min1的位置不在数组的最左端（也就是min1不等于arr[0]），则将最小值arr[0] = min1，接着在剩下的(n-1)个数字中找到最小值min2，如果最小值min2不等于arr[1]，那么则arr[1] = min2，依次类推，直到数组arr有序排列。
总结:在一轮循环中，由数组的最左侧开始，依次排序出最小值，第一个比第二个大，则记录下第二个数字的坐标（较小的值），依次往下比对，如果有更小于当前最小值，则记录的坐标变更为最新的最小值的坐标，一轮比对完，将当前最小值与本轮开始位置的坐标互换，使他排在最左侧

public class SelectSort {

    public static void main(String[] args) {
        int[] arr = new int[]{3,2,78,34,50,89,1,45,7};
        System.out.println("排序之前：" + Arrays.toString(arr));
        selectSort(arr);
        System.out.println("排序之后：" + Arrays.toString(arr));
    }

    /**
     * 简单选择排序
     * @param arr
     */
    
    // int[] arr = new int[]{3,78,34,50,89,1,45,7};
    static void selectSort(int[] arr){
        for(int i=0;i<arr.length; i++){
            int index = i;
            for(int j=i+1;j<arr.length;j++){
                if(arr[index] > arr[j]){
                    //筛选出的数组中的最小值的坐标
                    index = j;
                }
            }

            if(index == i){
                //当这个值是这一轮循环中最小的时候，未与其他的值的位置发生互换
                continue;
            } else {
                int tem = arr[index];
                arr[index] = arr[i];
                arr[i] = tem;
            }
        }
    }
 

直接插入排序

插入排序的基本思想就是将无序序列插入到有序序列中。例如：将数组arr=[4,2,8,0,5,1]排序，可以将4看做是一个有序序列（图中用蓝色标出），将[2,8,0,5,1]看做是一个无序序列，无序序列中2比4小，于是将2插入到4的左边，于是将2插入到4的左边，此时有序序列变成了[2,4]，无序序列变成了[8,0,5,1]。无序序列中8比4大，所以将8插入到4的右边，有序序列变成了[2,4,8]，无序序列变成了[0,5,1]。依次类推最终数组按照从小到大的排序。
一般是将第一个数作为一个基准值，然后下一个数做对比，小左大右，组成了一个有序序列(已经排序完的序列)下一次比对时的数字是和这个有序序列的每一个数字对比，小左大右。

public class InsertSort2 {
    public static void main(String[] args) {
        int[] arr = new int[]{4,2,8,0,5,1};
        System.out.println("排序之前：" + Arrays.toString(arr));
        insertSort(arr);
        System.out.println("排序之后：" + Arrays.toString(arr));
    }
    
    static void insertSort(int[] arr){
        for(int i=1;i<arr.length;i++){
            
            
            for(int j=i;j>0;j--){
                if(arr[j] < arr[j-1]){
                    int val = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = val;
                }
            }
        }
    }
}

快速排序

快速排序（Quick Sort）算法和冒泡排序算法类似，都是基于交换排序思想实现的，快速排序算法是对冒泡排序算法的改进，从而具有更高的执行效率。
总结：快速排序与冒泡排序相似，都是基于交换排序思想实现的，算是对于冒泡排序的改进，从而具有更好的时间复杂度。1.首先确定一个分界值（基本都是第一个）将这个数组分为两部分，大于分界值的元素放在分界值右边，小于的放左边。2.对左右两边的数据进行同样的操作（递归调用），当左右各数据排序完成后，整个数组也就完成了排序。
主要就是寻找一个基准值，将小于基准值的数置于基准值的左侧，将大于基准值的数置于右侧；坐标从右侧开始查找，如果是大于基准值的则略过，如果是小于基准值的则记住这个坐标，从左侧开始，如果是小于基准值的则略过，如果是大于基准值的则记住这个坐标，
左右坐标值互换，下一轮由当前位置继续，直到左右坐标指向同一个坐标，当两个指针相遇了，i=j时，这时将基准值和这个位置的值互换。这时可以说以这个基准值来判断的一轮快速排序结束了，剩下左右两侧就再继续递归调用快速排序方法，直到结束。

    package com.linewell.gov.hoox.uop.run;
    
    import java.util.Arrays;
    
    /**
     * @author wjieyang
     * @version 1.0
     * @date 2023/3/21 11:25
     */
    public class QuickSort2 {
        public static void main(String[] args) {
            int[] arr = new int[]{4,2,8,0,5,1};
            System.out.println("排序之前：" + Arrays.toString(arr));
            quickSort(arr,0,arr.length-1);
            System.out.println("排序之后：" + Arrays.toString(arr));
        }
    
        /**
         * 主要就是寻找一个基准值，将小于基准值的数置于基准值的左侧，将大于基准值的数置于右侧；坐标从右侧开始查找，如果是大于基准值的则略过，如果是小于基准值的则记住这个坐标，从左侧开始，如果是小于基准值的则略过，如果是大于基准值的则记住这个坐标，
         * 左右坐标值互换，下一轮由当前位置继续，直到左右坐标指向同一个坐标，当两个指针相遇了，i=j时，这时将基准值和这个位置的值互换。这时可以说以这个基准值来判断的一轮快速排序结束了，剩下左右两侧就再继续递归调用快速排序方法，直到结束。
         * @param arr 数组
         * @param left 左侧坐标
         * @param right 右侧坐标
         */
        static void quickSort(int[] arr,int left,int right){
            
            
            
            if(left >= right){
                return;
            }
            int i = left;
            int j  = right;
            int baseVal  = arr[left];
            while(i<j){
                while(i<j && arr[j] >= baseVal){
                    //坐标从右侧开始查找，如果是大于基准值的则略过，如果是小于基准值的则记住这个坐标
                    j--;
                }
                while(i<j && arr[i] <= baseVal){
                    i++;
                }
                int val  = arr[i];
                arr[i] = arr[j];
                arr[j] = val;
                
            }
            arr[left] = arr[i];
            arr[i] = baseVal;
            //递归调用左右两边序列
            quickSort(arr,left,i-1);
            quickSort(arr,i+1,right);
        }
    }

参考

【Java面试题】常见算法总结

java面试 算法_Java面试被经常问到的常用算法

算法常用面试题汇总