java中七种常见的排序算法（面试常考！！！）

最新推荐文章于 2021-04-16 20:56:46 发布
最新推荐文章于 2021-04-16 20:56:46 发布
阅读量2.7k 收藏 35
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45691220/article/details/105999354
版权

常见的排序算法

视图总览：

在这里插入图片描述

一，插入排序

1，介绍及实现思路

整个区间被分为

  1. 有序区间
  2. 无序区间
    每次选择无序区间的第一个元素，在有序区间内选择合适的位置插

在这里插入图片描述

2，代码

//默认为升序排序
public static void insertSort(int[] array){
    //通过bound划分出两个区间
    //[0，bound)表示已排序区间
    //[bound，size )为待排序区间
    for (int bound = 1; bound < array.length  ; bound++) {//默认0号位置已将是排序得了，从1开始
        int v = array[bound];//取出bound位置元素往前插
        int cur = bound-1; //从bound-1的位置开始找位置,
        for(;cur >= 0; cur--){
            if(array[cur] > v){ //注意如果这个条件写成>=依旧可以完成排序，但是不为稳定排序了
               array[cur+1] = array[cur];
            }else {
                break;//找到了合适的位置
            }
        }
        //此时的cur+1位置即要插入的位置
        array[cur+1] = v;
    }
}

3，性能分析

在这里插入图片描述
稳定性：
稳定排序

插入排序，初始数据越接近有序，时间效率越高

二，希尔排序

1，介绍及实现思路

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所 有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1 时，所有记录在统一组内排好序。

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很 快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

在这里插入图片描述

2，代码

public static void shellSort(int[] array){
        int gap = array.length/2;
        while(gap > 1){
            //需要循环进行分组插排
            shellSortGap(array,gap);
            gap/=2;
        }
        shellSortGap(array,1); //当gap为1时再进行一次插排
}
public static void shellSortGap(int[] array,int gap){
    //通过bound划分出两个区间
    //[0，bound)表示已排序区间
    //[bound，size )为待排序区间
    for (int bound = gap; bound < array.length  ; bound++) {//默认0号位置已将是排序得了，从1开始
        int v = array[bound];//取出bound位置元素往前插
        int cur = bound-gap; //从bound-1的位置开始找位置, //找到同组中的上一个元素
        for(;cur >= 0; cur -= gap){
            if(array[cur] > v){ //注意如果这个条件写成>=依旧可以完成排序，但是不为稳定排序了
                array[cur+gap] = array[cur];
            }else {
                break;//找到了合适的位置
            }
        }
        //此时的cur+1位置即要插入的位置
        array[cur+gap] = v;
    }
}

3，性能分析

在这里插入图片描述
稳定性：
不稳定性排序

三，选择排序

1，介绍及实现思路

每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元
素排完 。
在这里插入图片描述

2，代码

public static void selectSort(int[] array){
    for (int bound = 0; bound < array.length-1 ; bound++) {
        //[0,bound)为已排序区间bound位置元素为擂主，循环取出待排序区间元素与擂主比较
        //如果小就交换（即打擂成功）
        for(int cur = bound+1;cur < array.length;cur++){
            if(array[bound] > array[cur]){  //打擂成功
                int temp = array[bound];
                array[bound] = array[cur];
                array[cur] = temp;
            }
        }
    }
}

3，性能分析

在这里插入图片描述
稳定性：
不稳定排序

四，堆排序

1，介绍及实现思路

基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的
数。

注意：排升序要建大堆；排降序要建小堆。
此处以升序为例：
在这里插入图片描述

2，代码

public static void heapSort(int[] array){
        //先建大堆
    CreatHeap(array);
    //循环把堆顶元素交换到最后，并调整堆
    for (int i = 0; i < array.length-1; i++) {
        //当堆中只剩一个元素，也不需要进行调整，本来就是有序的
        swap(array,0,array.length-1-i); //堆中元素个数为length-i,所以最后一个元素下标为length-i-1
        //交换完之后把最后一个元素删掉
        //堆的长度又进一步缩水了
        //数组中
        //[0,array.length-i-1)为待排序区间
        //[array.length-i-1,array.length)为已排序区间
        shiftDown(array,array.length-i-1,0);
    }
}

    public static void CreatHeap(int[] array) {
        //从最后一个非叶子节点出发向前循环，依次进行向下调整
        for(int i = (array.length-1-1)/2;i >=0;i--){
            shiftDown(array,array.length,i);
        }
    }

    public static void shiftDown(int[] array, int heapLength, int index) {
        int parent = index;
        int child = index*2 +1;
        while(child <heapLength){
            if(child+1 < heapLength && array[child+1] > array[child]){
                child = child +1;
            }
            //条件结束，child已经指向左右子树中较大的数
            if(array[child] > array[parent]){
                swap(array,child,parent);
            }
            parent = child;
            child = parent*2+1;
        }

    }

    public static void swap(int[] array,int i, int j){
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
}

3，性能分析

在这里插入图片描述
稳定性：
不稳定性排序

五，冒泡排序

1，介绍及实现思路

在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序 。
在这里插入图片描述

2，代码

public static  void bubbleSort(int[] array){
        //从前往后找最小的方式进行排序
    //[0,bound)为已排序区间
    //[bound,size)为待排序区间
    for(int bound = 0 ; bound < array.length;bound++){
        for(int cur = array.length-1;cur > bound; cur--){
            if(array[cur-1] > array[cur]){
                swap(array,cur-1,cur);
            }
        }
    }
    }
   public static void swap(int[] array,int i, int j){
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
}

3，性能分析

在这里插入图片描述
稳定性：
稳定排序

六，快速排序

1，介绍及实现思路

原理：

  1. 从待排序区间选择一个数，作为基准值(pivot)；
  2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的
    （可以包含相等的）放到基准值的右边；
  3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1 代表已经有序，或者小区间的长度 == 0，代表没有数据。
    在这里插入图片描述

基准值的取法：
1.选择边上（左或者右）
2. 随机选择
3. 几数取中（例如三数取中）：array[left], array[mid], array[right] 大小是中间的为基准值

2，代码

递归实现：

public static  void quickSort(int[] array){
    //借助这个方法进行辅助递归
    //此处为了简单，代码写成前闭后闭区间
    quickSortHelper(array,0,array.length-1);
}

private static void quickSortHelper(int[] array, int left, int right) {
    if(left>=right){
        return; //表示只有一个区间只有一个元素或者没有元素，直接返回
    }
    //针对[left,right]区间进行整理
    //index位置即为整理完毕后left和right重合的位置，知道了这个位置才能进一步进行递归
    int index = partition(array,left,right);
    quickSortHelper(array,left,index-1);
    quickSortHelper(array,index+1,right);
}

private static int partition(int[] array, int left, int right) {
    int i = left;
    int j = right;
    int base = array[right];//取区间最后一位为基准值
    while(i < j){
        //从左往右找比基准值大的元素
        while(i < j && array[i] <= base){
            i++;
        }
        //当上面的循环结束之后，i要么和j重合，要么指向了一个比基准值base小大的元素
        //从右往左找比基准值小的元素
        while(i < j && array[j] >= base){
            j--;
        }
        //当上面的循环结束之后，i要么和j重合，要么j指向了一个比基准值base小的元素
        //交换i和j的值
        swap(array,i,j);
    }
    //当i和j重合的时候，最后一步，把重合位置元素和基准值的交换
    swap(array,i,right);
    return i;
}
public static void swap(int[] array,int i, int j){
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
}

非递归实现：

public static void quickSortByLoop(int[] array) {
        //借助栈来模拟递归
       //stack用来存放数组下标，通过数组下标来表示接下来要处理的区间是啥
    Stack<Integer> stack = new Stack<>();
    //初始情况下，把左右边界下标入栈，左右边界仍构成闭区间
    stack.push(array.length-1);
    stack.push(0);
    while(!stack.isEmpty()){
        //取出来的顺序和push的顺序刚好相反
        int left = stack.pop();
        int right = stack.pop();
       if(left >= right){
            //区间内只有一个或0个元素不需要调整
            continue;
        }
        //通过partition把数据调整为以基准值为中心，左侧元素小于基准值，右侧元素大于基准值的序列
       int index = partition(array,left,right);
        //准备处理下个区间
        //[index+1,right]为基准值右侧范围
            stack.push(right);
            stack.push(index + 1);
        //[left,index-1]为基准值左侧数据
            stack.push(index - 1);
            stack.push(left);
    }
}
public static int partition(int[] array, int left, int right) {
    int i = left;
    int j = right;
    int base = array[right];//取区间最后一位为基准值
    while(i < j){
        //从左往右找比基准值大的元素
        while(i < j && array[i] <= base){
            i++;
        }
        //当上面的循环结束之后，i要么和j重合，要么指向了一个比基准值base小大的元素
        //从右往左找比基准值小的元素
        while(i < j && array[j] >= base){
            j--;
        }
        //当上面的循环结束之后，i要么和j重合，要么j指向了一个比基准值base小的元素
        //交换i和j的值
        swap(array,i,j);
    }
    //当i和j重合的时候，最后一步，把重合位置元素和基准值的交换
    swap(array,i,right);
    return i;
}
public static void swap(int[] array,int i, int j){
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
}

3，性能分析

在这里插入图片描述
稳定性：
不稳定性排序

七，归并排序

1,介绍及实现思路

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and
Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使
子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
在这里插入图片描述
在这里插入图片描述

2,代码

递归实现：

//[low,mid)  有序区间
//[mid,high)  有序区间
    //把这两个区间合并为一个有序区间
    public static  void merge(int[] array,int low,int mid,int high){
        int[] output = new int[high-low]; //额外空间用来临时存放数据
        int outputIndex = 0;//用来记录output中被放入了多少个元素
        int cur1 = low;
        int cur2 = mid;
        while(cur1 < mid && cur2 < high ){
            if(array[cur1] <= array[cur2]){
                output[outputIndex] = array[cur1];
                outputIndex++;
                cur1++;
            } else{
                output[outputIndex] = array[cur2];
                outputIndex++;
                cur2++;
            }
        }
        //循环结束肯定是cur1和cur2有一个先到达末尾
        //把剩下的元素一股脑拷贝到output中
        while(cur1 < mid){
            output[outputIndex] = array[cur1];
            outputIndex++;
            cur1++;
        }
        while(cur2 < high){
            output[outputIndex] = array[cur2];
            outputIndex++;
            cur2++;
        }
        //把output中的元素搬运回array中
        for (int i = 0; i < high-low; i++) {
            array[low+i] = output[i];
        }
    }
    public static  void mergeSort(int[] array){
        mergeSortHelper(array,0,array.length);
    }
//[low,high)为左闭右开区间.两者差值小于等于1，区间中就只有一个或两个元素
    private static void mergeSortHelper(int[] array, int low, int high) {
        if(high-low <= 1){
            return;
        }
        int mid = (low + high)/2;
        //这个方法执行完就认为low
        mergeSortHelper(array,low,mid);
        mergeSortHelper(array,mid,high);
        //当左右区间归并排序完了，说明左右区间已经是有序区间了
        //接下来就可以针对两个有序区间合并
        merge(array,low,mid,high);
    }

非递归实现：

public static void mergeSortByLoop(int[] array){
        //引入一个gap变量进行分组
    //当gap为1的是时候[0） [1）进行合并，[2） [3）进行合并，[4） [5）进行合并，[6）[7）进行合并.....
    //当gap为2的时候[0,1）和[2,3）进行合并，[4,5）和[6,7）进行合并......
    //当gap为4的时候[0,1,2,3）和[4，5，6，7）进行合并.....
    for (int gap = 1; gap < array.length;gap *= 2){
        //接下来进行具体的分组合并
        for(int i = 0; i < array.length;i += 2*gap){
            //当前相邻组
            //[begain,mid)
            //[mid,end)
            //begain =>i
            //mid => i+gap
            //end => i+2*gap
            int beg = i;
            int mid = i+ gap;
            int end = i + 2*gap;
            if(mid > array.length){  //防止越界
                mid = array.length;
            }
            if(end > array.length){
                end = array.length;
            }
            merge(array,beg,mid,end);
        }
    }
}
public static  void merge(int[] array,int low,int mid,int high){
    int[] output = new int[high-low]; //额外空间用来临时存放数据
    int outputIndex = 0;//用来记录output中被放入了多少个元素
    int cur1 = low;
    int cur2 = mid;
    while(cur1 < mid && cur2 < high ){
        if(array[cur1] <= array[cur2]){
            output[outputIndex] = array[cur1];
            outputIndex++;
            cur1++;
        } else{
            output[outputIndex] = array[cur2];
            outputIndex++;
            cur2++;
        }
    }
    //循环结束肯定是cur1和cur2有一个先到达末尾
    //把剩下的元素一股脑拷贝到output中
    while(cur1 < mid){
        output[outputIndex] = array[cur1];
        outputIndex++;
        cur1++;
    }
    while(cur2 < high){
        output[outputIndex] = array[cur2];
        outputIndex++;
        cur2++;
    }
    //把output中的元素搬运回array中
    for (int i = 0; i < high-low; i++) {
        array[low+i] = output[i];
    }
}

3,性能分析

在这里插入图片描述
稳定性：
稳定排序

一只懐坏旭
关注
常见的几种排序算法（java）
s_p_y_s的博客
03-29 733
一、冒泡排序 二、直接插入排序 三、秩的排序 四、选择排序 五、希尔排序 六、快排 七、堆排序 八、归并排序 九、计数基数排序 一、冒泡排序 package com.java.sort; import com.java.util.MyMath; public class BubbleSort { public static void bublleSort(i...
笔试 | Java 中 7 种常见的排序算法实现
大数据学习与分享的博客
06-20 223
一、快速排序 1.1 方法1 思路: 在数据集中,选择一个元素作为"基准(pivot)" 分区(partition)：所有小于"基准"的元素，都移到"基准"的左边；所有大于"基准"的元素都移到"基准"的右边 分区操作结束后，基准元素所处的位置就是最终排序后它所处的位置 对"基准"左边和右边的两个子集，不断重复第一步和第二步，直到所有子集都只剩下一个元素为止 /** * @param arr 待排序数组 * @param low 数组第一个元素索引 * @param high 数组
面试常问的六大排序算法（代码+动画图解）
01-20
文章目录初级排序算法选择排序插入排序希尔排序冒泡排序高级排序算法归并排序快速排序 初级排序算法 选择排序 动画演示 代码实现 public class selectSort { public static void main(String[] args) { int[] nums = {1,5,6,2,3,4,7,8,9}; selectSort(nums); for (int num:nums){ System.out.print(num); } } private static
面试中可能被问到的一些常用排序算法
weixin_34378922的博客
02-16 199
排序算法 排序算法是一种比较简单的算法，从我们一开始接触计算机编程开始接触的可能就是排序或者搜索一类的算法，但是因为排序在其他的一些算法中应用较多，所以为了提高性能已经研究了多种排序算法。目前区别排序算法主要还是以时间复杂度，空间复杂度，稳定性等来排序，接下来我们分别分析。 稳定性算法 区别一个排序算法是否是稳定算法只需看相同的关键字在排序完成后是否保持原来两者的前后关系即可，比如对于[1,2,3...
java面试常考算法组合_面试10大算法汇总+常见题目解答（Java）
weixin_39748838的博客
02-17 240
以下从Java的角度总结了面试常见的算法和数据结构：字符串，链表，树，图，排序，递归 vs. 迭代，动态规划，位操作，概率问题，排列组合，以及一些需要寻找规律的题目。1. 字符串、数组和矩阵首先需要注意的是和C++不同，Java字符串不是char数组。没有IDE代码自动补全功能，应该记住下面这些常用的方法。toCharArray()Arrays.sort()Arrays.toString([]a...
java面试排序_Java-四种面试常考排序
weixin_39761195的博客
02-18 161
快速排序快速排序的思想依据是分治法，选取第一个元素为对比值，然后将表中比对比值小的放在左边，将对比值大的放在右边，然后再将左边的列表用同样的方法进行排列，将右边的方法进行排列，依次递归下去，最终有序。下面列出java实现package arithmetic;/*** Created by elijahliu on 2017/3/2.*/public class QuickSort {int a[]...
Java面试-常考算法
Kaptcha的学习
05-20 807
常考算法排序插入希尔直插交换冒泡快排选择简单选择堆归并基数常用算法思路分治动态规划贪心回溯分支界定复杂度时间复杂度空间复杂度查找二分查找二叉排序树B树HashBloomFilter字符串匹配BF算法BM算法Sunday算法KMP算法Tire算法 排序 插入 希尔 直插 交换 冒泡 快排 选择 简单选择 堆 归并 基数 常用算法思路 分治 动态规划 贪心 回溯 分支界定 复杂度 时间复杂度 空间复杂...
java排序 面试题_Java八大排序（面试答题！）
weixin_42397024的博客
02-16 2686
八大排序(重点！！)​排序算法大体可分为两种：1、比较排序，时间复杂度O(nlogn) ~ O(n^2)，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。2、非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。一、冒泡排序算法思路1、比较相邻的元素。如果第一个比第二个大，就交换它们两个；2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这...
七种排序算法Java版性能比较+Java实现.doc
09-21
本文将详细分析七种常见的Java排序算法：冒泡排序、选择排序、快速排序、插入排序、希尔排序、归并排序和堆排序，并探讨它们在不同条件下的性能表现。 1. **冒泡排序**： - 时间复杂度：平均和最坏情况下都是O(n^2...
面试常见算法题
05-17
这是在面试中遇到的一些常见算法题，笔试面试经常遇到，所以总结了一下，方面以后查看，分享给大家。
面试常考算法解题技巧
06-20
在准备IT行业的面试时，尤其是针对大厂的面试，掌握常用的算法解题技巧至关...上述资料中的多个PDF文件，如“面试常考算法解题技巧-20201011200359551.pdf”等，将是你宝贵的参考资料，可以深入学习和巩固这些知识点。
常见：排序算法相关面试题1
08-08
在本篇文章中，我们将讨论常见的排序算法面试题，包括插入排序、希尔排序、冒泡排序、快速排序等。 1. 插入排序 插入排序是一种简单的排序算法，它的工作原理是通过将每个元素插入到已经排好序的数组中。插入排序...
面试官常考的---冒泡排序算法。
海鸥
06-26 323
一、冒泡排序是计算机领域中一种比较简单的排序算法。 他重复地走访过要排列的元素，比较相邻两个元素大小，如果他们的顺序有错误就把他们两个交换过来，走访元素重复地发现他们没有元素交换，也就是说他们已经排序完成。 二、冒泡排序原理： 1.比较相邻两个元素，如果第一个比第二个大，就把他们两个交换过来。 2.对每一对相邻元素做同样的动作，从开始第一队到最后一对...
【面试常考算法】排序算法汇总~
mango_12345的博客
04-16 184
原理性内容可参见： https://blog.csdn.net/weixin_41571493/article/details/81875088 1. 冒泡排序 相邻两个值比较，每次确定一个最值放在数据尾部 对n个值进行操作，重复n-1趟 时间复杂度O（n^2） def BubbleSort(arr): n=len(arr) if n<=1:return for i in range(n-1): for j in range(n-i-1): if arr[j]>arr[j+1]
面试java经常会问到的排序算法（java）
weixin_41531181的博客
09-30 322
目录 1.插入排序 2.交换排序 3.选择排序 4.归并排序 5.基数排序 1.插入排序 插入排序也分为两种，一种是直接插入排序，一种是Shell排序。 2.交换排序 (1)起泡排序 内层循环控制交换的次数，外层循环控制轮数。内层循环的numbers.length-1-i里面的 -i 是 因为每一轮最后的数已经确定是最大的了，不需要再对比。 //冒泡排序算法 int[] numbers=new int[]{1,5,8,2,3,9,4};
几种排序算法（面试时经常要考的）
qinjianganying的专栏
08-18 6790
第一种：冒泡排序法 算法思想：首先将第一个记录的关键字与第二个记录的关键字进行比较，若为逆序，则交换这两个记录的值，然后比较第二个记录和第三个记录的关键字，以此类推，直至第n-1个和第n个记录的关键字比较过为止；至此第一趟冒泡排序完成，对前n-1个记录的关键字按照第一趟的冒泡排
面试常考排序算法（持续更新）
小王的博客
02-14 466
1.桶排序 桶排序，也叫作箱排序，是一个排序算法，也是所有排序算法中最快、最简单的排序算法。其中的思想是我们首先需要知道所有待排序元素的范围，然后需要有在这个范围内的同样数量的桶，接着把元素放到对应的桶中，最后按顺序输出。 实际上一个桶不总是放同一个元素，在很多时候一个桶里可能会放多个元素，这是不是与散列表有点类似呢？其实真正的桶排序和散列表是一样的原理。 除了对一个桶内的元素做链表存储，我...
linux命令find实现_find.zip
最新发布
09-17
linux命令find实现_find
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值