排序算法之冒泡-快速-计数-桶-基数-堆Java版

最新推荐文章于 2024-04-21 17:41:25 发布
最新推荐文章于 2024-04-21 17:41:25 发布
阅读量601 收藏 1
点赞数 2
分类专栏： 算法 文章标签： 排序算法 冒泡排序 快速排序 堆排序 桶排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010597819/article/details/104082806
版权

上篇排序算法之插入-希尔-归并Java版：https://blog.csdn.net/u010597819/article/details/86646305

冒泡排序

package org.gallant.algorithm;

import static org.gallant.algorithm.SortUtil.println;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * @author 会灰翔的灰机
 * @date 2020/1/19
 */
public class BubbleSort {

    public static void bubbleSort(int[] data) {
        int size = data.length;
        while (size > 1) {
            for (int i = 0; i < size - 1; i++) {
                int left = data[i];
                int right = data[i + 1];
                if (left > right) {
                    data[i] = right;
                    data[i + 1] = left;
                }
            }
            size--;
        }
    }

    public static void main(String[] args) {
        int[] array = SortUtil.randomArray(9);
        println(array);
        bubbleSort(array);
        println(array);
    }

}

快速排序

package org.gallant.algorithm;

import static org.gallant.algorithm.SortUtil.println;

/**
 * @author 会灰翔的灰机
 * @date 2020/1/19
 */
public class QuickSort {

    public static void quickSort(int[] data, int start, int end) {
        int pivotIndex = partitioning(data, start, end);
        if (pivotIndex > -1) {
            quickSort(data, start, pivotIndex);
            quickSort(data, pivotIndex, end);
        }
    }

    public static int partitioning(int[] data, int start, int end) {
        int pivot = data[start];
        int i = end, j = start + 1;
        while (i >= j) {
            int right = data[i];
            int left = data[j];
            // 相等的值放在右边子序列中
            boolean rightLesserPivot = right < pivot;
            boolean leftGreaterPivot = left >= pivot;
            // 哨兵i大于基准值，继续移动
            if (!rightLesserPivot) {
                i--;
            } else {
                // 哨兵j小于基准值,并且哨兵i已经发现大于基准值的值时，移动哨兵j
                if (!leftGreaterPivot) {
                    j++;
                }
            }
            if (leftGreaterPivot && rightLesserPivot) {
                // 哨兵i与哨兵j相遇前找到了比基准值大，比基准值小的数值，交换他们的位置
                swap(data, left, j, right, i);
                i--;
                j++;
            }
            // 哨兵i与哨兵j相遇
            if (i == j) {
                boolean isLesserPivot = data[i] < pivot;
                if (isLesserPivot) {
                    swap(data, pivot, start, data[i], i);
                }
                println(data);
                return i;
            }
        }
        return -1;
    }

    public static void swap(int[] data, int leftValue, int leftIndex, int rigthValue, int rightIndex){
        data[rightIndex] = leftValue;
        data[leftIndex] = rigthValue;
    }

    public static void main(String[] args) {
        int[] array = SortUtil.randomArray(15);
        println(array);
        // 错误的理解。。。代码有问题，正解见quickSort2方法
        quickSort(array, 0, array.length - 1);
        println(array);
    }

	private static void quickSort2(int[] arr, int low, int high) {

    if (low < high) {
      // 找寻基准数据的正确索引
      int index = getIndex(arr, low, high);

      // 进行迭代对index之前和之后的数组进行相同的操作使整个数组变成有序
      //quickSort(arr, 0, index - 1); 之前的版本，这种姿势有很大的性能问题，谢谢大家的建议
      quickSort2(arr, low, index - 1);
      quickSort2(arr, index + 1, high);
    }

  }

  private static int getIndex(int[] arr, int low, int high) {
    // 基准数据
    int tmp = arr[low];
    while (low < high) {
      // 当队尾的元素大于等于基准数据时,向前挪动high指针
      while (low < high && arr[high] >= tmp) {
        high--;
      }
      // 如果队尾元素小于tmp了,需要将其赋值给low
      arr[low] = arr[high];
      // 当队首元素小于等于tmp时,向前挪动low指针
      while (low < high && arr[low] <= tmp) {
        low++;
      }
      // 当队首元素大于tmp时,需要将其赋值给high
      arr[high] = arr[low];

    }
    // 跳出循环时low和high相等,此时的low或high就是tmp的正确索引位置
    // 由原理部分可以很清楚的知道low位置的值并不是tmp,所以需要将tmp赋值给arr[low]
    arr[low] = tmp;
    return low; // 返回tmp的正确位置
  }

}

计数排序

package org.gallant.algorithm;

import static org.gallant.algorithm.SortUtil.print;
import static org.gallant.algorithm.SortUtil.println;

/**
 * @author 会灰翔的灰机
 * @date 2020/1/20
 */
public class CountingSort {

    public static void countingSort(int[] data) {
        int max = Integer.MIN_VALUE,min = Integer.MAX_VALUE;
        // 1. 查找最大值、最小值
        for (int i = 0; i < data.length; i++) {
            int currentValue = data[i];
            if (currentValue > max) {
                max = currentValue;
            }
            if (currentValue < min) {
                min = currentValue;
            }
        }
        // 2. 将数据根据最小值映射放入对应的桶内（index下标处）
        println("max:"+max+",min:"+min);
        int[] count = new int[max - min + 1];
        for (int i = 0; i < data.length; i++) {
            int currentValue = data[i];
            print(currentValue+",");
            count[currentValue - min] += 1;
        }
        println("");
        println(count);
        // 3. 根据计数桶还原数据到原数据中。计数桶中的数据由于映射的算法可知是有序的
        int currentDataIndex = 0;
        for (int i = 0; i < count.length; i++) {
            int cnt = count[i];
            if (cnt > 0) {
                for (int j = 0; j < cnt; j++) {
                    data[currentDataIndex] = min + i;
                    currentDataIndex++;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] array = SortUtil.randomArray(11);
        println(array);
        countingSort(array);
        println(array);
    }

}

桶排序

package org.gallant.algorithm;

import static org.gallant.algorithm.SortUtil.println;

import java.util.Arrays;
import java.util.Objects;

/**
 * @author 会灰翔的灰机
 * @date 2020/1/20
 */
public class BucketSort {

    public static void bucketSort(int[] array) {
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        // 1. 查找 数字长度 最大值、最小值
        for (int currentValue : array) {
            int len = getIntegerLength(currentValue);
            if (len > max) {
                max = len;
            }
            if (len < min) {
                min = len;
            }
        }
        // 2. 将数据根据数字长度以及最小长度，放入对应的桶中
        println("max:"+max+",min:"+min);
        Integer[][] count = new Integer[max - min + 1][array.length];
        for (int i = 0; i < array.length; i++) {
            int currentValue = array[i];
            Integer[] bucket = count[getIntegerLength(currentValue) - min];
            for (int j = 0; j < bucket.length; j++) {
                if (bucket[j] == null) {
                    bucket[j] = currentValue;
                    break;
                }
            }
        }
        println(count);
        // 3. 根据映射函数可知，桶的下标大的桶中的所有数据大于下标小的桶中的数据
        // 所以将每个桶排序后直接拼接结果便可以得到全局有序的集合
        int currentDataIndex = 0;
        for (int i = 0; i < count.length; i++) {
            Integer[] bucketObj = count[i];
            if (bucketObj.length > 0) {
                int[] bucket = Arrays.stream(bucketObj).filter(Objects::nonNull).mapToInt(Integer::intValue).toArray();
                Sorts.insertSort(bucket);
                for (int j = 0; j < bucket.length; j++) {
                    array[currentDataIndex] = bucket[j];
                    currentDataIndex++;
                }
            }
        }
    }

    public static int getIntegerLength(int value) {
        return Integer.toString(value).length();
    }

    public static void main(String[] args) {
        int[] array = SortUtil.randomArray2(10);
        println(array);
        bucketSort(array);
        println(array);
    }

}

基数排序

  1. 以LSD为例，假设原来有一串数值如下所示：73, 22, 93, 43, 55, 14, 28, 65, 39, 81。首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中
  2. 接下来将这些桶子中的数值重新串接起来，成为以下的数列：81, 22, 73, 93, 43, 14, 55, 65, 28, 39。接着再进行一次分配，这次是根据十位数来分配
  3. 接下来将这些桶子中的数值重新串接起来，成为以下的数列：14, 22, 28, 39, 43, 55, 65, 73, 81, 93。这时候整个数列已经排序完毕；如果排序的对象有三位数以上，则持续进行以上的动作直至最高位数为止
package org.gallant.algorithm;

import static org.gallant.algorithm.SortUtil.println;

/**
 * @author 会灰翔的灰机
 * @date 2020/1/20
 */
public class RadixSort {

    public static void radixSort(int[] array) {
        int maxLen = 0;
        for (int i = 0; i < array.length; i++) {
            int currentValue = array[i];
            int len = Integer.toString(currentValue).length();
            if (len > maxLen) {
                maxLen = len;
            }
        }
        // 1. 从个位数至最高位，按每个位的数字进行分桶，逐个执行桶排序
        for (int i = 0; i < maxLen; i++) {
            Integer[][] buckets = new Integer[10][array.length];
            // 2. 分桶
            for (int j = 0; j < array.length; j++) {
                int currentValue = array[j];
                String currentValueStr = String.valueOf(currentValue);
                // 自右向左的游标
                int cursorIndex = (currentValueStr.length() - 1) - i;
                int index = cursorIndex >= 0 ? Character.getNumericValue(currentValueStr.charAt(cursorIndex)) : 0;
                Integer[] bucket = buckets[index];
                for (int k = 0; k < bucket.length; k++) {
                    if (bucket[k] == null) {
                        bucket[k] = currentValue;
                        break;
                    }
                }
            }
            int j = 0;
            // 2. 分桶后，按照桶顺序重组数组
            for (int i1 = 0; i1 < buckets.length; i1++) {
                Integer[] bucket = buckets[i1];
                System.out.print("当前桶 "+ i1 + " : ");
                for (Integer integer : bucket) {
                    if (integer != null) {
                        System.out.print(integer + ",");
                        array[j++] = integer;
                    }
                }
                System.out.println();
            }
            System.out.println("由低位至高位遍历分桶排序，当前位数：" + (i + 1) + "，重组后数组顺序");
            println(array);
        }
    }

    public static void main(String[] args) {
        int[] array = SortUtil.randomArray2(9);
        println(array);
        radixSort(array);
        println(array);
    }

}

堆排序

package org.gallant.algorithm;

import static org.gallant.algorithm.SortUtil.println;

/**
 * 参考：https://www.geeksforgeeks.org/heap-sort/
 * @author 会灰翔的灰机
 * @date 2020/1/21
 */
public class HeapSort {

    /**
     * 初始数组被看作一个完全二叉树
     * Input data: 4, 10, 3, 5, 1
     *          4(0)
     *         /   \
     *      10(1)   3(2)
     *     /   \
     *  5(3)    1(4)
     *
     * The numbers in bracket represent the indices in the array
     * representation of data.
     *
     * Applying heapify procedure to index 1:
     *          4(0)
     *         /   \
     *     10(1)    3(2)
     *     /   \
     * 5(3)    1(4)
     *
     * Applying heapify procedure to index 0:
     *         10(0)
     *         /  \
     *      5(1)  3(2)
     *     /   \
     *  4(3)    1(4)
     * The heapify procedure calls itself recursively to build heap
     *  in top down manner.
     */
    public static void heapSort(int[] array) {
        int heapSize = array.length;
        // 1. 构建最大堆。最大堆的每个非叶子节点都是左右子树的最大节点。即：构建之后0索引处为整棵树的最大值
        for (int i = heapSize / 2 - 1; i >= 0; i--) {
            heapify(array, heapSize, i);
        }
        for (int i = array.length - 1; i >= 0 ; i--) {
            // 2. 将最大值交换至最后，剩余[0, n - 2]恢复非最大堆状态。n - 1索引处为当前最大堆中的最大值
            swap(array, i, 0);
            // 3. 重复步骤1，2，直至整个堆有序
            heapify(array, i, 0);
        }
    }

    public static void heapify(int[] array, int heapSize, int largestNodeIndex) {
        // 初始化根节点
        int largest = largestNodeIndex;
        // 根节点左子节点索引
        int leftChild = 2 * largestNodeIndex + 1;
        // 根节点右子节点索引
        int rightChild = 2 * largestNodeIndex + 2;
        // 如果左子树大于根节点，更新根节点索引
        if (leftChild < heapSize && array[leftChild] > array[largest]) {
            largest = leftChild;
        }
        // 如果右子树大于根节点，更新根节点索引
        if (rightChild < heapSize && array[rightChild] > array[largest]) {
            largest = rightChild;
        }
        // 根节点索引发生变更，更新根节点
        if (largest != largestNodeIndex) {
            swap(array, largest, largestNodeIndex);
            // 左子树或右子树发生变更，递归更新发生变更的子树
            heapify(array, heapSize, largest);
        }
    }

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

    public static void main(String[] args) {
        int[] array = SortUtil.randomArray(9);
        println(array);
        heapSort(array);
        println(array);
    }

}
太阳伞下的阿呆
关注
专栏目录
新手小白 C语言十大经典算法入门必看理论基础
登山爱好者
11-27 844
算法： 解决问题的方法和步骤(数据结构所具备的功能)。 特征：有穷性、确切性、输入项、输出项、可行性 评定： 时间复杂度：随着输入项的变化，算法运算的次数，一般采用大O表示法。 O(1)<O(logn)<O(n)<O(nlogn)<O(n^2)<O(2^n)<O(n!) 空间复杂度：随着输入项的变化，算法所需要内存的变量，一般采用大O表示法。 O(1)<O(n)<O(2n) 正确性 可读性
排序算法: 冒泡排序，桶排序，计数排序，堆排序，插入排序，合并排序，快速排序，基数排序，选择排序，希尔排序 Python实现
01-15
本文将详细介绍九种常见的排序算法，包括冒泡排序、桶排序、计数排序、堆排序、插入排序、合并排序、快速排序、基数排序和选择排序，并特别关注Python语言的实现。 1. **冒泡排序**：这是一种简单的排序算法，通过...
蓝桥杯 Java 冒泡排序
weixin_46200144的博客
09-27 205
import java.util.Scanner; public class 冒泡排序 { /** * @param args 相邻的进行比较 */ public static void main(String[] args) { // TODO Auto-generated method stub //f1(); // 基本排序 f2(); // 带结构体带姓名分数 } public static void f1() { Sc
Java 排序算法之计数排序
用善良的眼光看世界
12-22 167
一、计数排序（Counting Sort） 计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。 计数排序是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组 A 中值等于i的元素的个数。然后根据数组 C 来将 A 中的元素排到正确的位置。它只能对整数进行排序。 二、算法描述...
十大经典排序(三) —— 计数、桶、基数
qq_45636631的博客
05-08 365
文章目录1、计数排序原理图解代码复杂度稳定性2、桶排序思想图解代码复杂度稳定性3、基数排序思想图解代码复杂度稳定性 1、计数排序 原理 创建一个长度为 k+1 的数组，每个数组的值对应输入数组中数字出现的次数，通过遍历一次输入数组并统计每个元素出现次数，最后遍历输出 图解 代码 void CountSort(int *a, int n) { int i; int k = 0; int minValue = a[0]; int maxValue = a[0]; for
计数&桶&基数排序算法
Charge8的博客
06-21 627
计数&桶&基数排序算法
十大排序算法-快排-希尔-堆排-归并-冒泡-桶排-选择-插入-计数-基数-1
weixin_43580319的博客
05-18 1万+
文章目录1. 排序算法1.1 算法的之间的比较1.2 冒泡排序1.3 选择排序1.4 插入排序1.5 快速排序1.6 堆排序1.7 计数排序1.8 桶排序1.9 基数排序1.10 希尔排序1.11 归并排序 1. 排序算法 1.1 算法的之间的比较 排序算法 平均时间复杂度 最差时间复杂度 空间复杂度 数据对象稳定性 冒泡排序 O(n2) O(n2) O(1) 稳定 选择排序 O(n2) O(n2) O(1) 数组不稳定、链表稳定 插入排序 O() O() O() 稳定 快速排序
十大经典排序算法详解(三)-堆排序,计数排序,桶排序,基数排序
热门推荐
lovely__RR的博客
02-02 4万+
十大经典排序算法-堆排序,计数排序,桶排序,基数排序 1-堆排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: 2-计数排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: 3-桶排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: 4-基数排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: ...
常见排序算法(插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序，计数排序，基数排序，桶排序）
2301_80288511的博客
04-21 2397
常见排序算法(插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序，计数排序，基数排序，桶排序）
排序算法.冒泡排序桶排序.计数排序.堆排序.插入排序.合并排序.快速排序基数排序选择排序希尔排序.zip
最新发布
04-27
直接插入排序（Straight Insertion Sort）是一种简单且古老的排序算法，其基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。12 直接插入排序的算法过程如下： 假设待排序...
计数和桶的收获和思路
Alask_的博客
10-09 127
315.计算右侧小于当前元素的个数 给你`一个整数数组 nums ，按要求返回一个新数组 counts 。数组 counts 有该性质： counts[i] 的值是 nums[i] 右侧小于 nums[i] 的元素的数量。 示例 1： 输入：nums = [5,2,6,1] 输出：[2,1,1,0] 解释： 5 的右侧有 2 个更小的元素 (2 和 1) 2 的右侧仅有 1 个更小的元素 (1) 6 的右侧有 1 个更小的元素 (1) 1 的右侧有 0 个更小的元素 对原数组进行一次映射，首先去重，然后假
聊聊脑裂问题（split brain）
阿呆的专栏
08-16 2398
脑裂问题 HDFS 1.0 架构，图片取自：《Hadoop：The Definitive Guide》 1.0问题 namenode单点问题 随着集群扩展，namenode管理文件元数据存在瓶颈 2.0解决方案 增加协调者（coordinator）管理一主多从的NameNode节点提供高可用的NameNode federation联邦解决方案，可以理解为分片方案类似于分库分表 脑裂问题（分区问题） 正常情况下的协调者 机房1与机房2出现网络故障后，机房2重新选举leader，导致脑裂问题如下。导
RSA加密解密
阿呆的专栏
11-29 2147
需求描述 小件员app端拨打消费者手机号，基于小件员手机号，消费者手机号，绑定一个中间隐私号码，通过拨打隐私小号来建立二者的通话，保护客户隐私。 隐私小号绑定由另外一个公司提供，我们称为公司B。我们公司称为公司A。 公司A将消费者手机号通过私钥加密。公司B将消费者手机号通过公钥加密。 加解密 加密 公司A将加密后的数据转为字符串透传给公司B new String(EncodeDecodeUtil.encryptByPrivateKey(bindVirtualNumberParam.getCalledNum(
Jwt加解密-Java
阿呆的专栏
02-06 1662
工具类 引入依赖包 <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.10.3</version> </dependency> 工具类 package com.gallant.test; import com.auth0.jwt.JWT; import com.auth0.j
Geohash
阿呆的专栏
03-08 1521
定义 Geohash是将一个地理位置编译为一个数字与字母组成的短字符串 算法逻辑 例如：天安门附近经纬度：116.403694,39.911836。我们按照geohash将其转为长度5的geohash 1. 经纬度按照二分法二分，经纬度如果属于二分后的左区间则取0，右区间则取1 绿色背景表示纬度落在区间 bit value 代表转为二进制的取值 mean value 代表二分后选中区间（绿色背景...
TicketLock
阿呆的专栏
09-15 1370
票锁比较直白，可以称为号码锁，叫号锁。是一种自旋锁，之前讲过CLH锁（传送门）也是一种自旋锁。 TicketLock定义 ticket lock就像是平时使用美味不用等一样，自己先通过公众号排队取号，然后不断的会刷新（自旋）当前叫到了第几号，如果叫到自己的号，就说明可以获取锁去吃饭啦。 TicketLock锁流程 假设饭店只有一个位子 初始时位子是空的，叫号0 第一位顾客取号，取号0 匹配号成功...
无限循环小数展示算法题
阿呆的专栏
05-16 1148
题目 给定两个整数，分别表示分数的分子 numerator 和分母 denominator，以字符串形式返回小数。如果小数部分为循环小数，则将循环的部分括在括号内。 示例 1: 输入: numerator = 1, denominator = 2 输出: “0.5” 示例 2: 输入: numerator = 2, denominator = 1 输出: “2” 示例 3: 输入: numerator = 2, denominator = 3 输出: "0.(6)” 实现 package com.galla
JDT之抽象语法树
阿呆的专栏
10-20 1063
问题描述 公司业务迭代通过开关进行风险规避，在开关打开时走新业务逻辑，关闭时走老业务逻辑。这导致有大量的开关代码遗留，每次人工清理开关容易遗漏出错。为了减少出错概率，将清理开关动作进行自动化 解决方案 使用JDT工具解析java源码代码进行针对开关的语义自动替换清理 JDT使用 引入依赖 <dependency> <groupId>org.eclipse.jdt<...
Python3十大排序算法详解及实现：冒泡、快速、归并等
本文主要介绍了10种Python3中常用的排序算法，包括快速排序、冒泡排序、桶排序、基数排序、堆排序、希尔排序、归并排序和计数排序，并给出了冒泡排序和快速排序的实例代码。 排序算法是编程中基础且重要的概念，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值