面试常问的排序算法和经典算法（代码示例）

已于 2022-06-07 23:05:45 修改
阅读量241 收藏 1
点赞数 1
分类专栏： 面试 技术分享 文章标签： 算法 排序算法 面试
于 2022-06-07 21:57:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33424446/article/details/125174139
版权

排序算法

关于时间复杂度：

  1. 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。
  2. 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序。
  3. O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。希尔排序。
  4. 线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。

关于稳定性：

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。

不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

1.冒泡排序
  /**
   * 冒泡排序
   * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
   * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
   * 针对所有的元素重复以上的步骤，除了最后一个，即需要进行length-1次。
   * 第一次是对n个数进行n-1次比较，进行到最后第n个的一个是最大的；
   * 第二次是对n-1个数进行n-2次比较，进行到最后第n-1个的一个是最大的；
   * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
   */
	@Test
    public void bubbleSort(String[] args) {
        int[] num = new int[]{3, 2, 1, 4, 5, 6, 8, 9, 7};
        // 需进行length-1次冒泡
        for (int i = 0; i < num.length - 1; i++) {
            for (int j = 0; j < num.length - 1 - i; j++) {
                // 比较并交换
                if (num[j] > num[j + 1]) {
                    int temp = num[j];
                    num[j] = num[j + 1];
                    num[j + 1] = temp;
                }
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for (int i = 0; i < num.length; i++) {
            System.out.print(num[i] + " ");
        }
    }
2.选择排序
    /**
     * 选择排序
     * <p>
     * 选择排序原理即是，遍历元素找到一个最小（或最大）的元素，把它放在第一个位置，
     * 然后再在剩余元素中找到最小（或最大）的元素，把它放在第二个位置，依次下去，完成排序。
     * 选择排序的时间复杂度为 O(n^2)。
     * 第一次需要检查n个元素，但随后检查的元素数依次为n - 1, n – 2, …, 2和1。
     * 平均每次检查的元素数为1/2 * n， 因此运行时间为 n * 1/2 * n，简单地写作 O(n^2)。
     */
    @Test
    public void selectionSort() {
        int[] num = new int[]{3, 2, 1, 4, 5, 6, 8, 9, 7};
        // 需进行length-1次遍历
        for (int i = 0; i < num.length - 1; i++) {
            // 记录最小值的索引位置，默认值为i
            int index = i;
            for (int j = i + 1; j < num.length; j++) {
                // 获取最小值的下标
                if (num[j] < num[index]) {
                    index = j;
                }
            }
            // 交换位置
            if (i != index) {
                int temp = num[i];
                num[i] = num[index];
                num[index] = temp;
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for (int i = 0; i < num.length; i++) {
            System.out.print(num[i] + " ");
        }
    }
3.插入排序
	/**
     * 插入排序
     * <p>
     * 插入排序（英语：Insertion Sort）是一种简单直观的排序算法。
     * 它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。(类似打扑克)
     * 插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
     */
    @Test
    public void insertionSort() {
        int[] num = new int[]{3, 2, 1, 4, 5, 6, 8, 9, 7};
        for (int i = 1; i < num.length; i++) {
            for (int j = i; j > 0; j--) {
                if (num[j] < num[j - 1]) {
                    int temp = num[j - 1];
                    num[j - 1] = num[j];
                    num[j] = temp;
                }
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for (int i = 0; i < num.length; i++) {
            System.out.print(num[i] + " ");
        }
    }
4.希尔排序
	/**
     * 希尔排序
     *
     * 希尔排序也成为“缩小增量排序”，其基本原理是，现将待排序的数组元素分成多个子序列，使得每个子序列的元素个数相对较少，
     * 然后对各个子序列分别进行直接插入排序，待整个待排序列“基本有序”后，最后在对所有元素进行一次直接插入排序。
     * 因此，我们要采用跳跃分割的策略：将相距某个“增量”的记录组成一个子序列，这样才能保证在子序列内分别进行直接插入排序后得到的结果是基本有序而不是局部有序。
     * 希尔排序是对直接插入排序算法的优化和升级。
     * 所谓的基本有序，就是小的关键字基本在前面，大的基本在后面，不大不小的基本在中间，例如｛2,1,3,6,4,7,5,8,9,｝就可以称为基本有序了。
     * 但像｛1,5,9,3,7,8,2,4,6｝这样，9在第三位，2在倒数第三位就谈不上基本有序。
     * 希尔排序的关键并不是随便分组后各自排序，而是将相隔某个“增量”的记录组成一个子序列，实现跳跃式移动，使得排序的效率提高。
     * 需要注意的是，增量序列的最后一个增量值必须等于1才行。另外，由于记录是跳跃式的移动，希尔排序并不是一种稳定的排序算法。
     * 希尔排序最好时间复杂度和平均时间复杂度都是O(nlogn)，最坏时间复杂度为 O(n^2)。
     */
    @Test
    public void shellSortSmallToBig() {
        int[] num = new int[]{3, 2, 1, 4, 5, 6, 8, 9, 7};
        int j = 0;
        int temp = 0;
        for (int increment = num.length / 2; increment > 0; increment /= 2) {
            for (int i = increment; i < num.length; i++) {
                temp = num[i];
                for (j = i - increment; j >= 0; j -= increment) {
                    if (temp < num[j]) {
                        num[j + increment] = num[j];
                    } else {
                        break;
                    }
                }
                num[j + increment] = temp;
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for (int i = 0; i < num.length; i++) {
            System.out.print(num[i] + " ");
        }
    }
5.归并排序
	/**
     * 归并排序
     *
     * 归并排序是一种概念上最简单的排序算法，与快速排序一样，归并排序也是基于分治法的。
     * 归并排序将待排序的元素序列分成两个长度相等的子序列，为每一个子序列排序，然后再将他们合并成一个子序列。合并两个子序列的过程也就是两路归并。
     * 归并排序是一种稳定的排序算法，归并排序的主要问题在于它需要一个与待排序数组一样大的辅助数组空间。
     * 由于归并排序每次划分时两个子序列的长度基本一样，所以归并排序最好、最差和平均时间复杂度都是nlog2n。
     */
    @Test
    public void mergeSort () {
        int[] num = new int[]{3, 2, 1, 4, 5, 6, 8, 9, 7};
        int j = 0;
        int temp = 0;
        for (int increment = num.length / 2; increment > 0; increment /= 2) {
            for (int i = increment; i < num.length; i++) {
                temp = num[i];
                for (j = i - increment; j >= 0; j -= increment) {
                    if (temp < num[j]) {
                        num[j + increment] = num[j];
                    } else {
                        break;
                    }
                }
                num[j + increment] = temp;
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for (int i = 0; i < num.length; i++) {
            System.out.print(num[i] + " ");
        }
    }
6.快速排序
/**
 * 快速排序
 * <p>
 * 快速排序（Quicksort）使用分治思想对冒泡排序作了改进，效率非常高。
 * 其基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
 * 从快速排序的基本思想可以分析出其实现思路：
 * 一、选取一个枢轴元素（也叫基准元素）
 * 二、将数组分割成两部分，一部分数据都小于或等于枢轴元素，另一部分数据都大于枢轴元素
 * 三、对分割的子数组递归地执行步骤一二，直到无法分割
 */
public class QuickSort {
    public static void sort(int a[], int low, int hight) {
        int i, j, index;
        if (low > hight) {
            return;
        }
        i = low;
        j = hight;
        index = a[i]; // 用子表的第一个记录做基准
        while (i < j) { // 从表的两端交替向中间扫描
            while (i < j && a[j] >= index) {
                j--;
            }
            if (i < j) {
                a[i++] = a[j];// 用比基准小的记录替换低位记录
            }
            while (i < j && a[i] < index) {
                i++;
            }
            if (i < j) // 用比基准大的记录替换高位记录
            {
                a[j--] = a[i];
            }
        }
        a[i] = index;// 将基准数值替换回 a[i]
        sort(a, low, i - 1); // 对低子表进行递归排序
        sort(a, i + 1, hight); // 对高子表进行递归排序

    }

    public static void quickSort(int a[]) {
        sort(a, 0, a.length - 1);
    }

    public static void main(String[] args) {

        int arr[] = {49, 38, 65, 97, 76, 13, 27, 49};
        quickSort(arr);
        System.out.println("从小到大排序的结果为: " + Arrays.toString(arr));
    }

}
7.计数排序
/**
 * 计数排序
 * <p>
 * 计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
 * 找出待排序的数组中最大和最小的元素；
 * 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
 * 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
 * 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
 */
public class CountingSort {
    public static int[] countingSort(int[] array) {
        if (array.length == 0) {
            return array;
        }
        int bias, min = array[0], max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
            if (array[i] < min) {
                min = array[i];
            }
        }
        bias = 0 - min;
        int[] bucket = new int[max - min + 1];
        Arrays.fill(bucket, 0);
        for (int i = 0; i < array.length; i++) {
            bucket[array[i] + bias]++;
        }
        int index = 0, i = 0;
        while (index < array.length) {
            if (bucket[i] != 0) {
                array[index] = i - bias;
                bucket[i]--;
                index++;
            } else {
                i++;
            }
        }
        return array;
    }

    public static void main(String[] args) {
        int[] arr = new int[]{5, 3, 6, 2, 1, 9, 4, 8, 7};
        countingSort(arr);
        System.out.println("从小到大排序的结果为: " + Arrays.toString(arr));

    }

}
8.基数排序
/**
 * 基数排序
 * <p>
 * 首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
 * 基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
 * 基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）
 */
public class RadixSort {
    public static void main(String[] args) {
        //定义整型数组
        int[] arr = {21, 56, 88, 195, 354, 1, 35, 12, 6, 7};
        //调用基数排序函数
        lsd_RadixSort(arr, 3);
        //输出排序后的数组
        System.out.println("从小到大排序的结果为: " + Arrays.toString(arr));
    }

    /**
     * @param arr 排序的数组
     * @param max 数组中最大的数有几位
     */
    public static void lsd_RadixSort(int[] arr, int max) {
        //count数组用来计数
        int[] count = new int[arr.length];
        //bucket用来当桶（在下面你就理解了什么是桶了），放数据，取数据
        int[] bucket = new int[arr.length];

        //k表示第几位，1代表个位，2代表十位，3代表百位
        for (int k = 1; k <= max; k++) {
            //把count置空，防止上次循环的数据影响
            for (int i = 0; i < arr.length; i++) {
                count[i] = 0;
            }

            //分别统计第k位是0,1,2,3,4,5,6,7,8,9的数量
            //以下便称为桶
            //即此循环用来统计每个桶中的数据的数量
            for (int i = 0; i < arr.length; i++) {
                count[getFigure(arr[i], k)]++;
            }

            //利用count[i]来确定放置数据的位置
            for (int i = 1; i < arr.length; i++) {
                count[i] = count[i] + count[i - 1];
            }
            //执行完此循环之后的count[i]就是第i个桶右边界的位置

            //利用循环把数据装入各个桶中，注意是从后往前装
            //这里是重点，一定要仔细理解
            for (int i = arr.length - 1; i >= 0; i--) {
                int j = getFigure(arr[i], k);
                bucket[count[j] - 1] = arr[i];
                count[j]--;
            }

            //将桶中的数据取出来，赋值给arr
            for (int i = 0, j = 0; i < arr.length; i++, j++) {
                arr[i] = bucket[j];
            }

        }
    }

    //此函数返回整型数i的第k位是什么
    public static int getFigure(int i, int k) {
        int[] a = {1, 10, 100};
        return (i / a[k - 1]) % 10;
    }

}

经典算法题

1.斐波那契问题
/**
 * 斐波那契问题
 *
 * 已知:斐波那契数列的前几个数分别为0,1,1,2,3,5…从第三项开始,每一项都等于前两项的和.请接收用户输入的整数n,求出此数列的前n项.
 * 斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，
 * 故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……
 * 其规律很明显，从第3个数开始，每个数都等于它前两个数的和。
 * 下面我们可以通过用户输入的数字n来输出斐波那契数列的前n项
 */
public class Faibonacci {
    public static void main(String[] args) {
        System.out.println("请输入您要测试的数:");
        int n = new Scanner(System.in).nextInt();
        //判断n是否是不正常的范围
        if (n < 1) {
            System.out.println("输入数据有误！！！");
        }
        //n==1
        if (n == 1) {
            System.out.println(0);
        }
        //n==2
        if (n == 2) {
            System.out.println(0 + "\t" + 1);
        }
        //n==3
        if (n == 3) {
            System.out.println(0 + "\t" + 1 + "\t" + 1);
        }
        //拼接前n项
        if (n > 3) {
            System.out.print(0 + "\t" + 1 + "\t" + 1 + "\t");
        }
        //循环输出后面的数据
        int f1 = 1;
        int f2 = 1;
        int next = 0;
        for (int i = 4; i <= n; i++) {
            next = f1 + f2;
            f1 = f2;
            f2 = next;
            System.out.print(next + "\t");
        }
    }
}
2.生兔子问题
/**
 * 古典问题：生兔子问题
 * <p>
 * 有一对兔子，从出生后第3个月起都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月兔子的对数为多少？
 * 程序分析：前两个月兔子的对数为1
 * 从第三个月开始，兔子的对数变成了 2 3 5 8 13 21 …
 */
public class GetRabbitNum {
    public static void main(String[] args) {
        System.out.println("请输入要判断的月数：");
        int month = new Scanner(System.in).nextInt();
        System.out.println("第" + month + "月兔子的对数为：" + getSum(month));
    }

    public static int getSum(int month) {
        //如果是前两个月，还是1对兔子
        if (month == 1 || month == 2) {
            return 1;
        } else {
            //从第三个开始，兔子按照2 3 5 8 13 21变化
            return getSum(month - 1) + getSum(month - 2);
        }
    }
}
3.打印水仙花数
/**
 * 打印水仙花数
 * <p>
 * 水仙花数：是指一个三位数，其各位数字立方和等于该数字本身
 * 例如：153就是一个水仙花数，因为153 = 1³ + 5³ + 3³
 */
public class GetDaffodilNum {
    public static void main(String[] args) {
        //1.遍历所有的三位数
        for (int i = 100; i < 1000; i++) {
            //2.调用自定义方法判断是不是水仙花数
            if (isAim(i)) {
                //3.如果是水仙花数，就打印
                System.out.println(i);
            }
        }
    }

    //4.自定义判断水仙花数的方法
    public static boolean isAim(int a) {
        int x = a / 100;
        int y = a / 10 % 10;
        int z = a % 10;
        if (a == x * x * x + y * y * y + z * z * z) {
            return true;
        }
        return false;
    }
}
4.回文问题
/**
 * 回文问题
 * <p>
 * 需求,如果一个用户输入的数据,从前到后或者从后到前读到的内容都是一样的,我们就称这种数据为"回文",
 * 比如123321 或者 12321 或者上海自来水来自海上等等
 */
public class TestNumber {
    public static void main(String[] args) {
        System.out.println("请输入一个字符串:");
        String s = new Scanner(System.in).nextLine();

        if (!stringJudge(s)) {
            System.out.println(s + "不是回文字符串");
        } else {
            System.out.println(s + "是回文字符串");
        }

    }

    //判断字符串是否回文
    private static boolean stringJudge(String str) {
        for (int i = 0; i < str.length() - i - 1; i++) {
            if (str.charAt(i) == str.charAt(str.length() - i - 1)) {
                continue;
            } else {
                return false;
            }
        }

        return true;
    }

}
5.二分法查找
/**
 * 二分法查找
 * <p>
 * 二分法查找（Binary Search）也称折半查找，是指当每次查询时，将数据分为前后两部分，再用中值和待搜索的值进行比较，
 * 如果搜索的值大于中值，则使用同样的方式（二分法）向后搜索，反之则向前搜索，直到搜索结束为止。
 * 二分法使用的时候需要注意：二分法只适用于有序的数据，也就是说，数据必须是从小到大，或是从大到小排序的。
 */
public class DichotomizingSearch {
    public static void main(String[] args) {
        // 二分法查找
        int[] binaryNums = {1, 6, 15, 18, 27, 50};
        int findValue = 27;
        int binaryResult = binarySearch(binaryNums, 0, binaryNums.length - 1, findValue);
        System.out.println("元素第一次出现的位置（从0开始）：" + binaryResult);
    }

    /**
     * 二分查找，返回该值第一次出现的位置（下标从 0 开始）
     *
     * @param nums      查询数组
     * @param start     开始下标
     * @param end       结束下标
     * @param findValue 要查找的值
     * @return int
     */
    private static int binarySearch(int[] nums, int start, int end, int findValue) {
        if (start <= end) {
            // 中间位置
            int middle = (start + end) / 2;
            // 中间的值
            int middleValue = nums[middle];
            if (findValue == middleValue) {
                // 等于中值直接返回
                return middle;
            } else if (findValue < middleValue) {
                // 小于中值，在中值之前的数据中查找
                return binarySearch(nums, start, middle - 1, findValue);
            } else {
                // 大于中值，在中值之后的数据中查找
                return binarySearch(nums, middle + 1, end, findValue);
            }
        }
        return -1;
    }
}

6.杨辉三角

/**
 * 杨辉三角
 * <p>
 * 他的两条斜边都是数字1组成，其余的数等于他肩上的两数之和
 * 每行数字左右对称，由1开始，逐渐增大
 * 第n行的数字个数为n
 * 第n行的数字之和为2^n-1;
 */
public class TriangleArray {
    public static void main(String[] args) {
        final int NMAX = 10;
        // allocate triangular array
        int[][] odds = new int[NMAX + 1][];
        for (int n = 0; n <= NMAX; n++) {
            odds[n] = new int[n + 1];
        }
        // fill triangular array
        for (int n = 0; n < odds.length; n++) {
            for (int k = 0; k < odds[n].length; k++) {
                /*
                 * compute binomial coefficient n*(n-1)*(n-2)*...*(n-k+1)/(1*2*3*...*k)
                 */
                int lotteryOdds = 1;
                for (int i = 1; i <= k; i++)
                    lotteryOdds = lotteryOdds * (n - i + 1) / i;

                odds[n][k] = lotteryOdds;
            }
        }

        for (int[] row : odds) {
            for (int odd : row) {
                System.out.printf("%4d", odd);
            }
            System.out.println();
        }
    }
}

由于网页不好传动图，排序算法的动图关注私信我领取

阿旭的编程之路
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
面试官超级喜欢问的排序算法
m0_61544080的博客
11-10 988
前言 自学了一年JAVA阿巴阿巴终于约到了面试，然而这次面试官让她谈谈对排序算法的理解。 面试官： 你对算法这一块了解吗？排序这一块了解吗？ 阿巴阿巴： 了解一点，排序算法这一块主要有冒泡排序、插入排序、希尔排序、选择排序、快速排序、归并排序、堆排序、基数排序、桶排序。 面试官： 很不错，那你知道什么是稳定性吗，这些算法都是稳定的吗？他们的复杂度分别是多少呀？ 阿巴阿巴： 稳定性就是说，如果有2个元素a和b，且 a = b，且a排在b前面，如果经过排序算进行排序后，b在a前面了，那么我们就说这个算法是
经典算法面试题库小练习（附带注释+解题思路+优化）
weixin_46066254的博客
07-26 182
经典java算法面试题库小练习
面试官问你排序算法最基础的这几问，把这篇文章扔给他
Z景明的博客
06-20 334
前段时间，好多小禹禹征询是否可以更新排序算法相关的内容，所以就有了这个 「排序算法」专题，也很感谢这些提需求的小禹禹，恭喜你是第一次看到这个专题，也希望你从中有所收获。今天主要针对一些排...
排序用的题目例子
linyi_1115的博客
02-06 295
Description 有n个数，要对它们按从小到大排列。 Input 输入有若干种情况，每种情况一行。每行的第一个数是n（1<=n<=100），接着是n个整数。n=0时,表示结束. Ouput 对应按从小到大输出n个数。 Sample Input 3 0 7 4 10 3 4 -9 0 4 5 4 2 9 23 0Sample Output 0 4 7 -9 0 2 3 4 4 4 ...
一文看懂面试中常问的排序算法！
Coder-Bai的博客
06-06 259
我们知道在一些互联网等公司的面试中会经常被问到介绍几种常见的排序算法，甚至会让我们手撕出来。在此，我在备战秋招的过程中整理了一些常见的排序算法，写在这里供大家分享。几种排序算法不分先后顺序。 **快速排序**（时间复杂度为nlogn，空间复杂度为logn，不稳定排序） public void quickSort(int[] nums, int l, int r) { if(l>=r) return; int p=partition(nums,l,r); quickSort(n
面试常问的排序算法分析及代码实现
weixin_43691723的博客
07-05 133
本文介绍了七种常用的排序算法，这些排序算法，都非常的基础，必须要掌握。
leetcode按算法与数据结构类型总结+java面试知识+互联网公司JAVA笔试题总结.zip
最新发布
10-03
文件内容可能包括对LeetCode中常见算法和数据结构的详细解析，Java面试常问问题的解答，以及一些互联网公司Java笔试题的汇总。以下是对这些关键知识点的深入阐述： 1. **LeetCode**: LeetCode是一个在线平台，提供...
Java后台技术面试题目及解题思路.zip
10-03
"fucking-java-interview-master"这个项目的目录结构可能包含了各种题目、解答、代码示例，甚至可能包含了一些实战练习和常见面试陷阱，对于准备Java后台技术面试的人来说，无疑是一份宝贵的资源。 为了充分准备...
Java-Interview-Collection.rar_java 面试
09-22
面试中常问的问题包括它们之间的区别、线程安全性、迭代器的使用等。 4. **内存管理**：理解JVM内存模型，包括堆内存、栈内存、方法区、本地方法栈等。垃圾回收机制也是面试的重点，包括GC算法、新生代和老年代的...
Java数据结构和算法第二版.rar
09-29
本书还可能包含实际案例和练习，以帮助读者巩固所学知识，并提供Java实现这些数据结构和算法的代码示例，这将使读者更好地理解它们的工作原理。通过实践，读者可以提高编程能力，学会如何在实际项目中应用这些概念。...
经典排序算法讲解（面试）
weixin_42551107的博客
07-26 383
面试算法聊天
【面试】一些排序算法代码
贾博士的专栏
10-08 762
直接插入排序 #include void InsertSort(int data[],int num) { int temp = 0; for(int i = 1 ; i < num ; i++) { if(data[i] < data[i-1]) { temp = data[i]; for(int j = i-1 ; j >= 0 ; j--) {
面试常考！！！快速排序代码
YHbackkon
03-31 175
int partition(vector<int> &arr, int low, int high) { int tmp = arr[low]; while (low < high) { while (low < high && arr[high] >= tmp) high--; //当前数字<tmp了，将...
面试必问：十大经典排序算法总结
软件开发实战项目分享
02-28 920
面试必备十大算法，助你顺利进入大厂
排序算法分析及代码实现——五类九种排序（面试考研必备）
aruewds的博客
04-19 759
目录一、前言二、插入排序2.1 直接插入排序2.2 折半插入排序2.3 希尔插入排序三、交换排序3.1 冒泡排序3.2 快速排序四、选择排序4.1 简单选择排序4.2 堆排序五、归并排序六、基数排序 一、前言   排序算法是一类很经典的算法，在面试中经常被问到，需要我们手撕某个排序算法，或者分析其时间、空间复杂度并与其他算法比较优劣。而在考研中，也是数据结构必考知识，还可能涉及稳定性、内外排序问题，可见排序算法是基础中的基础。以下将仅仅简单分析各类排序算法并贴出代码，更详细地可具体百度某类算法。 二、插入排
快速排序算法-c语言实现,快速排序算法实现（C语言）（转）
weixin_29664063的博客
05-24 815
快速排序算法 的基本思想是：将所要进行排序的数分为左右两个部分，其中一部分的所有数据都比另外一部分的数据小，然后将所分得的两部分数据进行同样的划分，重复执行以上的划分操作，直到所有要进行排序的数据变为有序为止。可能仅根据基本思想对快速排序的认识并不深，接下来以对n个无序数列A[0], A[1]…,A[n-1]采用快速排序方法进行升序排列为例进行讲解。(1)定义两个变量low和high，将low、h...
各种常用的排序算法实现对数组的排序——整理总结（代码实现）
zm1_1zm
07-13 803
冒泡排序、插入排序、折半排序（二分插入排序）、快速排序、选择排序、归并排序、希尔排序、堆排序
排 序 算 法
baidulixueqin的博客
05-09 495
排序算法(上) 算法里面最简单的就是排序算法，这节课主要讲选择排序。 算法入门:四种排序算法(选择、归并、快速、技术)和对应的结构。 实现minOf2:2个数找出较小的那个 再优化 析构赋值:把结构拆开，依次复制 let minOf2=([a,b]) => a < b ? a : b //调用 minOf2([1,2]) //小白调用法 minOf2.call(null,[1,2]) //高手调用法 现成API JS内置了Math.min Math.min(1,2) Math.min.ca
八大排序算法
46426906的博客
11-12 1154
冒泡排序(Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。稳定:如果a原本在b前面，而a=b，排序之后a仍然在b的前面;
十大经典排序算法.pdf
12-08
十大经典排序算法是数据结构和算法领域的重要组成部分，这些算法对于理解和实现高效的数据组织至关重要。本文档涵盖了十种主要的排序算法，包括： 1. 冒泡排序：这是一种简单的比较排序，通过不断交换相邻元素如果...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值