排序算法

最新推荐文章于 2025-09-07 20:32:33 发布
最新推荐文章于 2025-09-07 20:32:33 发布
阅读量73 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： 数据结构与算法 java 面试
原文链接：http://www.cnblogs.com/optor/p/8480654.html

印象中，三次面试都被问到了快速排序算法，有的甚至要求当场手写实现，就比如今天下午的转转面试。艰难困苦中，幸好我写出了一个不太正规的冒泡排序。这里就记录下常见的几种排序算法吧！

分类

  1. 基于“交换”的排序算法：冒泡排序、快速排序
  2. 基于“选择”的排序算法：简单选择排序（Simple Selection Sort）、树形选择排序（Tree Selection Sort）、堆排序（Heap Sort）

冒泡排序

/**
 * Created by clearbug on 2018/2/27.
 */
public class Sort {

    public static void main(String[] args) {
        int[] arr = new int[]{49, 38, 65, 97, 76, 13, 27, 49};

        Sort sort = new Sort();
        sort.bubbleSort(arr);
    }

    /**
     * 冒泡排序
     *
     * 原理：藉助“交换”操作
     * 时间复杂度：O(n^2)
     * 空间复杂度：O(1)
     * 是否稳定：稳定
     *
     * @param arr 待排序的数组
     */
    public void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            boolean sorted = true;
            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;
                    sorted = false;
                }
            }
            if (sorted) {
                break;
            }
        }
    }
}

快速排序

/**
 * Created by clearbug on 2018/2/27.
 */
public class Sort {

    public static void main(String[] args) {
        int[] arr = new int[]{49, 38, 65, 97, 76, 13, 27, 49};

        Sort sort = new Sort();
        sort.quickSort(arr);
    }

    /**
     * 快速排序
     *
     * 原理：藉助“交换”操作，是冒泡排序的一种改进
     * 时间复杂度：O(nlogn)
     * 空间复杂度：O(1)。但是需要一个栈空间来实现递归，栈的最大深度为 log2n + 1，最坏情况下栈深度为 n。
     * 是否稳定：不稳定
     * 注意点：
     *      1. 通常，快速排序被认为是在所有同数量级（O(nlogn)）的排序方法中平均性能最好；
     *      2. 快速排序算法中，若待排序数组是有序的，那么快速排序将蜕化为冒泡排序，其时间复杂度为 O(n^2)；如何改善这一点？记录一次遍历中
     *          是否有“交换”操作，若没有则不再进行递归排序了；
     *
     * @param arr 待排序的数组
     */
    public void quickSort(int[] arr) {
        qSort(arr, 0, arr.length - 1);
    }

    public void qSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotLoc = partition(arr, low, high);
            qSort(arr, low, pivotLoc - 1);
            qSort(arr, pivotLoc + 1, high);
        }
    }

    public int partition(int[] arr, int low, int high) {
        int pivotKey = arr[low];
        while (low < high) {
            while (low < high && arr[high] >= pivotKey) {
                high--;
            }
            arr[low] = arr[high];

            while (low < high && arr[low] <= pivotKey) {
                low++;
            }
            arr[high] = arr[low];
        }
        arr[low] = pivotKey;
        return low;
    }
    
}

简单选择排序

import java.util.Arrays;

/**
 * Created by clearbug on 2018/2/27.
 */
public class Sort {

    public static void main(String[] args) {
        int[] arr = new int[]{49, 38, 65, 97, 76, 13, 27, 49};

        Sort sort = new Sort();
        sort.simpleSelectionSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 简单选择排序
     *
     * 原理：藉助“选择”操作
     * 时间复杂度：O(n^2)
     * 空间复杂度：O(1)
     * 是否稳定：不稳定
     * 注意点：暂无
     *
     * @param arr 待排序的数组
     */
    public void simpleSelectionSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int minIndex = selectMinKey(arr, i);
            if (minIndex != i) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }

    /**
     * 寻找并返回数组 arr 中从索引 start 开始的最小值的索引位置
     *
     * @param arr 待排序的数组
     * @param start 寻找最小值起始索引未知
     * @return 最小值的索引未知
     */
    private int selectMinKey(int[] arr, int start) {
        int res = start;
        for (int i = start + 1; i < arr.length; i++) {
            if (arr[i] < arr[res]) {
                res = i;
            }
        }
        return res;
    }


}

树形选择排序

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;

/**
 * Created by clearbug on 2018/2/27.
 */
public class Sort {

    static class BinaryTree {
        public TreeNode root;
    }

    static class TreeNode {
        public int val;
        public TreeNode leftChild;
        public TreeNode rightChild;

        public boolean from; // true 为 left，false 为 right

        public TreeNode(int val) {
            this.val = val;
        }
    }

    public static void main(String[] args) {
        int[] arr = new int[]{49, 38, 65, 97, 76, 13, 27, 49};

        Sort sort = new Sort();
        sort.treeSelectionSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 树形选择排序（Tree Selection Sort），又称锦标赛排序（Tournament Sort），是一种按照锦标赛的思想进行选择排序的方法，是对
     * 简单选择排序算法的一种改进。
     *
     * 原理：藉助“选择”操作
     * 时间复杂度：O(nlogn)
     * 空间复杂度：O(1)
     * 是否稳定：不稳定
     * 注意点：暂无
     *
     * @param arr 待排序的数组
     */
    public int[] treeSelectionSort(int[] arr) {
        TreeNode[] treeNodes = new TreeNode[arr.length];
        for (int i = 0; i < arr.length; i++) {
            treeNodes[i] = new TreeNode(arr[i]);
        }



        int[] res = new int[arr.length];

        Queue<TreeNode> queue = new LinkedList<>();

        for (int i = 0; i < arr.length; i++) {
            TreeNode node = new TreeNode(i);
            queue.add(node);
        }

        return res;
    }

    private TreeNode buildTree(TreeNode[] nodes) {

        if (nodes.length == 2) {
            TreeNode root = new TreeNode(Integer.MAX_VALUE);
            if (nodes[0].val > nodes[1].val) {
                root.val = nodes[1].val;
//                root.from =
            }
        }

        int parentNodesLen = nodes.length / 2 + nodes.length % 2;
        TreeNode[] parentNodes = new TreeNode[parentNodesLen];
        for (int i = 0; i < nodes.length; i++) {

        }
    }



    private int selectMin(Queue<TreeNode> queue) {
        Queue<TreeNode> parentQueue = new LinkedList<>();

        if (queue.size() == 2) {
            TreeNode first = queue.poll();
            TreeNode second = queue.poll();
            return first.val > second.val ? second.val : first.val;
        }

        if (queue.size() % 2 == 1) {
            queue.add(new TreeNode(Integer.MIN_VALUE));
        }

        while (!queue.isEmpty() && queue.size() % 2 == 0) {
            TreeNode first = queue.poll();
            TreeNode second = queue.poll();
            if (first.val > second.val) {
                parentQueue.add(second);
            } else {
                parentQueue.add(first);
            }
        }

        if (queue.isEmpty()) {
            return selectMin(parentQueue);
        } else {
            return queue.poll().val;
        }
    }

}

好吧，我承认我没写出来呢！网上相关实现也不多，就看到一哥们的 c++ 实现：http://blog.youkuaiyun.com/caroline_wendy/article/details/30038115。这种算法思路虽然很简单，但是代码实现起来确实有点复杂，以后有时间了再来写下实现吧！

堆排序

堆排序是在树形选择排序的基础上进行了优化，比树形选择排序稍微难理解一点，但是空间效率确实提高了的。真的要写其实现的话还是有点难度的，所以我抄写了这个老哥的代码：https://www.geeksforgeeks.org/heap-sort/:

import java.util.Arrays;

/**
 * Created by clearbug on 2018/2/27.
 */
public class Sort {

    public static void main(String[] args) {
        int[] arr = new int[]{49, 38, 65, 97, 76, 13, 27, 49};

        Sort sort = new Sort();
        sort.heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 堆排序（Heap Sort），是对树形选择排序的一种改进
     *
     * 原理：藉助“选择”操作
     * 时间复杂度：O(nlogn)
     * 空间复杂度：O(1)
     * 是否稳定：不稳定
     * 注意点：暂无
     *
     * @param arr 待排序的数组
     */
    public void heapSort(int[] arr) {
        int n = arr.length;

        // Build heap (rearrange array)
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(arr, n, i);
        }

        // One by one extract an element from heap
        for (int i = n - 1; i >= 0; i--) {
            // Move current root to end
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            // call max heapify on the reduced heap
            heapify(arr, i, 0);
        }


    }

    // To heapify a subtree rooted with node i which is an index in arr[]. n is size of heap
    private void heapify(int[] arr, int n, int i) {
        int largest = i; // Initialize largest as root
        int left = 2 * i + 1; // left = 2*i + 1
        int right = 2 * i + 2; // right = 2*i + 2
        // If left child is larger than root
        if (left < n && arr[left] > arr[largest]) {
            largest = left;
        }
        // If right child is larger than largest so far
        if (right < n && arr[right] > arr[largest]) {
            largest = right;
        }
        // If largest is not root
        if (largest != i) {
            int temp = arr[i];
            arr[i] = arr[largest];
            arr[largest] = temp;

            // Recursively heapify the affected sub-tree
            heapify(arr, n, largest);
        }
    }

}

归并排序

下面实现描述的只是2-路归并排序，还有其他形式的归并排序，但是我手头目前没有介绍其他归并排序的书籍，所以以后遇到用到再说！

import java.util.Arrays;

/**
 * Created by clearbug on 2018/2/27.
 */
public class Sort {

    public static void main(String[] args) {
        int[] arr = new int[]{49, 38, 65, 97, 76, 13, 27, 49};

        Sort sort = new Sort();
        sort.mergeSort2(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 归并排序算法二（迭代法）
     *
     * 时间复杂度：O(nlogn)
     * 空间复杂度：O(n)
     *
     * @param arr
     */
    public void mergeSort2(int[] arr) {
        int len = arr.length;
        int[] result = new int[len];
        int block, start;

        for (block = 1; block < len; block *= 2) {
            for (start = 0; start < len; start += 2 * block) {
                int low = start;
                int mid = (start + block) < len ? (start + block) : len;
                int high = (start + 2 * block) < len ? (start + 2 * block) : len;

                int start1 = low, end1 = mid;
                int start2 = mid, end2 = high;

                while (start1 < end1 && start2 < end2) {
                    result[low++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
                }
                while (start1 < end1) {
                    result[low++] = arr[start1++];
                }
                while (start2 < end2) {
                    result[low++] = arr[start2++];
                }
            }
            int[] temp = arr;
            arr = result;
            result = temp;
        }

        // Java 是传值调用，而 arr 是引用，那么最终的 arr 可能跟入参的 arr 指向同一个地址
        for (int i = 0; i < len; i++) {
            result[i] = arr[i];
        }
    }

    /**
     * 归并排序算法一（递归法）
     *
     * 时间复杂度：O(nlogn)
     * 空间复杂度：O(n)
     *
     * @param arr
     */
    public void mergeSort(int[] arr) {
        int len = arr.length;
        int[] result = new int[len];
        mergeSortRecursive(arr, result, 0, len - 1);
    }

    private void mergeSortRecursive(int[] arr, int[] result, int start, int end) {
        if (start >= end) {
            return;
        }
        int len = end - start, mid = (len >> 1) + start;
        int start1 = start, end1 = mid;
        int start2 = mid + 1, end2 = end;
        mergeSortRecursive(arr, result, start1, end1);
        mergeSortRecursive(arr, result, start2, end2);
        int k = start;
        while (start1 <= end1 && start2 <= end2) {
            result[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
        }
        while (start1 <= end1) {
            result[k++] = arr[start1++];
        }
        while (start2 <= end2) {
            result[k++] = arr[start2++];
        }
        for (int i = start; i <= end; i++) {
            arr[i] = result[i];
        }
    }

}

转载于:https://www.cnblogs.com/optor/p/8480654.html

常用十大排序算法
qq_51664685的博客
04-26 15万+
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。
十大经典排序算法-归并排序算法详解
热门推荐
qq_35344198的博客
06-19 12万+
一、什么是归并排序 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分 序列逐层拆分如下 然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并 创建一个大序列，序列长度为两个小序列长度
程序员那些必须掌握的排序算法(上)
。。。
08-17 8万+
现在的IT行业并不像以前那么好混了，从业人员过多，导致初级程序员过剩，这也间接导致了公司的招聘门槛越来越高，要求程序员掌握的知识也越来越多。 算法也是一个争论了很久的话题，程序员到底该不该掌握算法？不同的人有不同的答案，而事实上，很多公司都对算法有一定的要求，有些公司直接在面试的时候便会要求面试者手写算法题。这就对程序员的技术要求产生了很大的考验，所以面对如今的大环境，我们必须掌握算法，才能在今后...
C语言实现12种排序算法
yishuihanq的博客
02-01 8994
用C语言完整实现12种排序方法
七大排序算法
yahid的博客
06-28 1万+
排序：排序就是对某项数据按照特定的要求，比如大小或字符长短等按照升序或降序排序。排序过程中设计稳定性，稳定性指的是若有两个相同的数字，比如1和1。如果排序前1在1的前面，排完序后1还在1的前面。那么就说这个排序算法是稳定的，相反则说明不稳定。注意：如果本身就是一个稳定的排序，可以将其变成不稳定排序；如果本身就是不稳定排序，不能变成稳定的排序。常见的排序方法 上面是基于比较的排序。下面一个一个的分析一：直接插入排序 直接插入排序指的是将新的数据插入在已经排好序的序列中。比如我们生活中的玩的斗地主，我们需要将新
基于C语言的选择排序算法
m0_71974552的博客
09-02 2094
选择排序的基本思想及c语言的实现
必学排序算法——归并排序
ycs66的博客
10-19 1801
归并排序算法是必须掌握的一种基础算法，在一些比较出名的竞赛acm、蓝桥杯，并且在一些公司面试题中都可能会出现，而且作为简单题我们必须要拿下，所以我们要引起重视，下面让我们来深入了解归并排序算法。归并排序（Merge Sort）是一种经典的分治算法，它采用分治法将一个数组分成若干个子数组，分别对每个子数组进行排序，然后再将已排序的子数组合并成一个完整的排序数组。归并排序的时间复杂度为 O(nlogn)，且它是一个稳定的排序算法。
Java冒泡排序算法详解
weixin_69077250的博客
11-09 2303
综上所述，冒泡排序是一种简单易懂的排序算法，通过相邻元素之间的比较和交换来实现排序。虽然它效率上不如其他排序算法，但在某些特定场景下仍然有其应用价值。
必学的排序算法——冒泡排序
ycs66的博客
10-16 4559
冒泡排序算法是必须掌握的一种基础算法，在一些比较出名的竞赛可能会出现，而且作为简单题我们必须要拿下，所以我们要引起重视，下面让我们来深入了解冒泡排序算法。冒泡排序（Bubble Sort）是一种简单的排序算法，其基本思想是通过多次遍历待排序的数列，比较相邻元素的值，并在必要时交换它们的位置，从而将最大的元素逐步“冒泡”到数列的末尾。这个过程会重复进行，直到整个数列有序为止。
快速排序算法C++实现（超详细解析！！！！）
weixin_45031801的博客
09-21 10万+
快速排序，其实是一种分治算法，那么在了解快速排序之前，我们先来看看什么是分治算法。在算法设计中，我们引入分而治之的策略，称为分治算法，其本质就是将一个大规模的问题分解为若干个规模较小的相同子问题，分而治之。
基于比较的排序算法汇总 选择排序法 插入排序法 归并排序法 快速排序法 堆排序法 冒泡排序法 希尔排序法
01-15
在IT领域，排序算法是计算机科学中的基础但至关重要的概念，尤其在数据处理和算法设计中扮演着核心角色。本文将深入探讨标题中提到的几种基于比较的排序算法：选择排序、插入排序、归并排序、快速排序、堆排序、冒泡...
常见经典排序算法（C语言）1希尔排序 二分插入法 直接插入法 带哨兵的直接排序法 冒泡排序 选择排序 快速排序 堆排序.docx
05-07
常见的经典排序算法有希尔排序、二分插入法、直接插入法、带哨兵的直接排序法、冒泡排序、选择排序、快速排序、堆排序等。 一、希尔排序（Shell 排序法） 希尔排序法，又称宿小增量排序，是 1959 年由 D.L.Shell ...
堆排序算法详解：基于比较排序法的高效数据排列方法及其Java实现
01-06
内容概要：本文档全面解析了堆排序这一基于比较的经典排序算法。文中详细解释了堆的概念及其特性，阐述了堆排序算法的两个关键步骤——建堆（Heapify）与排序，并提供了具体的 Java 实现代码。在建堆阶段，文档介绍...
排序算法——选择排序法
weixin_64534587的博客
07-13 850
选择排序（Selection Sort）是一种简单直观的排序算法。它的基本思想是：在要排序的一组数中，选出最小（或最大）的一个数与第一个位置的数交换；然后在剩下的数当中再找最小（或最大）的与第二个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。所有过程都是从前向后依次找到最小（或最大）元素，而交换是跳跃式的。
AMD KFD 技术分析 3-1: alloc memory in hsakmt
deeplyMind
09-04 173
本文分析了ROCm HSAKMT库中的核心API hsaKmtAllocMemory 的实现原理。该API为上层应用提供统一的内存分配接口，支持多种内存类型（VRAM、系统内存等）。文章详细解析了其参数校验、标志冲突检查、分配类型选择（系统内存、VRAM或Scratch内存）以及与aperture管理器的交互过程。同时介绍了典型使用场景（如VRAM分配、SVM一致性内存等）和内存管理机制（包括对象追踪、释放流程）。该API通过底层aperture管理和红黑树实现高效的内存分配与安全控制，支持多GPU共享和进
二叉树的前中后序遍历(迭代法)
最新发布
mrjieke6的博客
09-07 658
本文系统介绍了二叉树前序、中序和后序遍历的迭代实现方法。前序遍历采用栈结构，按;根→右→左 ;顺序入栈；中序遍历先全部左子树入栈再访问节点；后序遍历则通过修改前序遍历顺序为"根→右→左 ;后反转结果。三种遍历时间复杂度均为O(n)，空间复杂度最坏O(n)。与递归实现相比，迭代方法避免了栈溢出风险，处理大型树更稳定。每种遍历方式都配有详细代码解析、执行示例和复杂度分析，并讨论了实际应用场景，为掌握树结构操作提供了系统指导。
【链表】2.两两交换链表中的节点（medium）
2402_85428625的博客
09-04 295
给你⼀个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进⾏节点交换）。链表中节点的数⽬在范围 [0, 100] 内。输⼊：head = [1,2,3,4]画图画图画图，重要的事情说三遍~输⼊：head = [1]输出：[2,1,4,3]输⼊：head = []
【牛客刷题-剑指Offer】BM18 二维数组中的查找：一题四解，从暴力到最优
字节卷动
09-06 172
方法时间复杂度空间复杂度优点缺点适用场景暴力遍历On×mOn×mO1O(1)O1简单直接，易实现效率低，不适合大数据量小规模数据二分查找Omlog⁡nOmlognO1O(1)O1利用行有序，效率较高未利用列有序特性行数较少时Z字形查找OnmO(n + m)OnmO1O(1)O1最优解，利用行列有序无各种规模数据递归分治平均优于OnmO(nm)OnmOlog⁡nmOlognm。
机器学习-逻辑回归
爱分享，爱ai，用热爱驱动ai学习方向
09-03 1239
逻辑回归是一种用于二分类问题的统计学习方法，通过Sigmoid函数将线性结果映射为概率值（0~1）。核心原理包括极大似然估计和对数损失函数，采用梯度下降优化参数。应用场景涵盖金融风控、医疗诊断等领域。Python实现需注意参数配置（solver、penalty等），评估指标包括精确率、召回率、F1值和AUC。案例实践表明，月合约和光纤服务用户具有较高流失风险。该模型适用于处理二分类问题，但样本不均衡时需重点关注召回率指标。
C语言实现选择排序法及排序算法详解
选择排序法是一种简单直观的排序算法，常用于C语言中的数组排序实现。它的基本思想是：每次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值