十大排序算法实现（模板）

最新推荐文章于 2023-06-01 16:55:13 发布
最新推荐文章于 2023-06-01 16:55:13 发布
阅读量168 收藏
点赞数 1
文章标签： java 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42324579/article/details/118959242
版权

1、冒泡排序

    // 冒泡排序
    private void bubbleSort(int[] nums) {
        int n = nums.length;

        boolean flag = false;
        for(int i=0; i<n; i++) {
            if(flag) break;
            flag = true;
            for(int j=1; i+j<n; j++) {
                if(nums[j-1] > nums[j]) {
                    swap(nums, j-1, j);
                    flag = false;
                }
            }
        }
    }

2、选择排序

    // 选择排序
    private void selectionSort(int[] nums) {
        int n = nums.length;

        for(int i=0; i<n; i++) {
            int t = i;
            for(int j=i+1; j<n; j++) {
                if(nums[t] > nums[j]) {
                    t = j;
                }
            }
            swap(nums, i, t);
        }
    }

3、插入排序

    // 插入排序
    private void insertionSort(int[] nums) {
        int n = nums.length;

        for(int i=1; i<n; i++) {
            int j=i, t=nums[j];
            while(j-1 >= 0 && nums[j-1] > t) {
                nums[j] = nums[j-1];
                j -= 1;
            }
            nums[j] = t;
        }
    }

4、希尔排序

    // 希尔排序
    private void shellSort(int[] nums) {
        int n = nums.length;

        for(int i=n/2; i>0; i/=2) {
            for(int j=i; j<n; j++) {
                int t = nums[j];
                while(j-i >= 0 && nums[j-i] > t) {
                    nums[j] = nums[j-i];
                    j -= i;
                }
                nums[j] = t;
            }
        }
    }

5、归并排序

    // 归并排序
    private void mergeSort(int[] nums) {
        mergeSort(nums, 0, nums.length-1);
    }

    private void mergeSort(int[] nums, int l, int r) {
        if(l >= r) return;

        int mid = (l+r) >> 1;
        mergeSort(nums, l, mid);
        mergeSort(nums, mid+1, r);

        merge(nums, l, mid, r);
    }

    private void merge(int[] nums, int l, int mid, int r) {
        int[] tmp = new int[r-l+1];

        int k=0, i=l, j=mid+1;
        while(i <= mid && j <= r) {
            if(nums[i] > nums[j]) tmp[k++] = nums[j++];
            else tmp[k++] = nums[i++];
        }
        while(i <= mid) {
            tmp[k++] = nums[i++];
        }
        while(j <= r) {
            tmp[k++] = nums[j++];
        }

        System.arraycopy(tmp, 0, nums, l, r + 1 - l);
    }

6、快速排序

    // 快速排序
    private void quickSort(int[] nums) {
        quickSort(nums, 0, nums.length-1);
    }

    private void quickSort(int[] nums, int l, int r) {
        if(l >= r) return;

        int t=nums[l], i=l, j=r;
        while(i < j) {
            while(i < j && nums[j] >= t) j--;
            nums[i] = nums[j];
            while(i < j && nums[i] <= t) i++;
            nums[j] = nums[i];
        }
        nums[i] = t;

        quickSort(nums, l, i-1);
        quickSort(nums, i+1, r);
    }

7、堆排序

    // 堆排序
    private void heapSort(int[] nums) {
        int n = nums.length;
        for(int i=n/2-1; i>=0; i--) {
            adjustHeap(nums, i, n);
        }

        for(int i=n-1; i>0; i--) {
            swap(nums, 0, i);
            adjustHeap(nums, 0, i);
        }
    }

    private void adjustHeap(int[] nums, int k, int n) {
        int t = nums[k];
        for(int i=2*k+1; i<n; i=2*i+1) {
            if(i+1 < n && nums[i+1] > nums[i]) i++;

            if(nums[i] > t) {
                nums[k] = nums[i];
                k = i;
            } else {
                break;
            }
        }
        nums[k] = t;
    }

8、计数排序

    // 计数排序
    private void countingSort(int[] nums) {
        int n = nums.length;

        int maxValue = Integer.MIN_VALUE;
        for (int num : nums) {
            maxValue = Math.max(maxValue, num);
        }
        int[] bucket = new int[maxValue+1];
        for(int num : nums) {
            bucket[num]++;
        }

        int t=0;
        for(int i=0; i<=maxValue; i++) {
            while(bucket[i] > 0) {
                nums[t++] = i;
                bucket[i]--;
            }
        }
    }

9、桶排序

    // 桶排序
    private void bucketSort(int[] nums) {
        int n = nums.length;

        int maxValue = Integer.MIN_VALUE;
        int minValue = Integer.MAX_VALUE;
        for(int num : nums) {
            maxValue = Math.max(maxValue, num);
            minValue = Math.min(minValue, num);
        }

        // 计算桶的数量
        int bucketNum = (maxValue - minValue) / n + 1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
        for(int i = 0; i < bucketNum; i++){
            bucketArr.add(new ArrayList<>());
        }

        // 将每个元素放入桶
        for (int value : nums) {
            int num = (value - minValue) / n;
            bucketArr.get(num).add(value);
        }

        // 对每个桶进行排序
        for (ArrayList<Integer> integers : bucketArr) {
            Collections.sort(integers);
        }

        // 将桶中的元素赋值到原序列
        int index = 0;
        for (ArrayList<Integer> integers : bucketArr) {
            for (Integer integer : integers) {
                nums[index++] = integer;
            }
        }
    }

10、基数排序

    // 基数排序
    private void radixSort(int[] nums) {
        int n = nums.length;

        int maxValue = Integer.MIN_VALUE;
        for(int num : nums) {
            maxValue = Math.max(maxValue, num);
        }
        int maxx = 0;
        while(maxValue > 0) {
            maxValue /= 10;
            maxx++;
        }

        int t = 1;
        for(int i=0; i<maxx; i++) {
            List<List<Integer>> list = new ArrayList<>();
            for(int j=0; j<10; j++) {
                list.add(new ArrayList<>());
            }

            for(int num : nums) {
                list.get((num/t)%10).add(num);
            }

            int tt=0;
            for(int j=0; j<10; j++) {
                for(int k=0; k<list.get(j).size(); k++) {
                    nums[tt++] = list.get(j).get(k);
                }
            }

            t *= 10;
        }
    }

汇总

import javassist.CodeConverter;
import jdk.nashorn.tools.Shell;
import org.springframework.http.converter.xml.MarshallingHttpMessageConverter;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

class Solution {
    // 冒泡排序
    private void bubbleSort(int[] nums) {
        int n = nums.length;

        boolean flag = false;
        for(int i=0; i<n; i++) {
            if(flag) break;
            flag = true;
            for(int j=1; i+j<n; j++) {
                if(nums[j-1] > nums[j]) {
                    swap(nums, j-1, j);
                    flag = false;
                }
            }
        }
    }

    // 选择排序
    private void selectionSort(int[] nums) {
        int n = nums.length;

        for(int i=0; i<n; i++) {
            int t = i;
            for(int j=i+1; j<n; j++) {
                if(nums[t] > nums[j]) {
                    t = j;
                }
            }
            swap(nums, i, t);
        }
    }

    // 插入排序
    private void insertionSort(int[] nums) {
        int n = nums.length;

        for(int i=1; i<n; i++) {
            int j=i, t=nums[j];
            while(j-1 >= 0 && nums[j-1] > t) {
                nums[j] = nums[j-1];
                j -= 1;
            }
            nums[j] = t;
        }
    }

    // 希尔排序
    private void shellSort(int[] nums) {
        int n = nums.length;

        for(int i=n/2; i>0; i/=2) {
            for(int j=i; j<n; j++) {
                int t = nums[j];
                while(j-i >= 0 && nums[j-i] > t) {
                    nums[j] = nums[j-i];
                    j -= i;
                }
                nums[j] = t;
            }
        }
    }

    // 归并排序
    private void mergeSort(int[] nums) {
        mergeSort(nums, 0, nums.length-1);
    }

    private void mergeSort(int[] nums, int l, int r) {
        if(l >= r) return;

        int mid = (l+r) >> 1;
        mergeSort(nums, l, mid);
        mergeSort(nums, mid+1, r);

        merge(nums, l, mid, r);
    }

    private void merge(int[] nums, int l, int mid, int r) {
        int[] tmp = new int[r-l+1];

        int k=0, i=l, j=mid+1;
        while(i <= mid && j <= r) {
            if(nums[i] > nums[j]) tmp[k++] = nums[j++];
            else tmp[k++] = nums[i++];
        }
        while(i <= mid) {
            tmp[k++] = nums[i++];
        }
        while(j <= r) {
            tmp[k++] = nums[j++];
        }

        System.arraycopy(tmp, 0, nums, l, r + 1 - l);
    }

    // 快速排序
    private void quickSort(int[] nums) {
        quickSort(nums, 0, nums.length-1);
    }

    private void quickSort(int[] nums, int l, int r) {
        if(l >= r) return;

        int t=nums[l], i=l, j=r;
        while(i < j) {
            while(i < j && nums[j] >= t) j--;
            nums[i] = nums[j];
            while(i < j && nums[i] <= t) i++;
            nums[j] = nums[i];
        }
        nums[i] = t;

        quickSort(nums, l, i-1);
        quickSort(nums, i+1, r);
    }

    // 堆排序
    private void heapSort(int[] nums) {
        int n = nums.length;
        for(int i=n/2-1; i>=0; i--) {
            adjustHeap(nums, i, n);
        }

        for(int i=n-1; i>0; i--) {
            swap(nums, 0, i);
            adjustHeap(nums, 0, i);
        }
    }

    private void adjustHeap(int[] nums, int k, int n) {
        int t = nums[k];
        for(int i=2*k+1; i<n; i=2*i+1) {
            if(i+1 < n && nums[i+1] > nums[i]) i++;

            if(nums[i] > t) {
                nums[k] = nums[i];
                k = i;
            } else {
                break;
            }
        }
        nums[k] = t;
    }

    // 计数排序
    private void countingSort(int[] nums) {
        int n = nums.length;

        int maxValue = Integer.MIN_VALUE;
        for (int num : nums) {
            maxValue = Math.max(maxValue, num);
        }
        int[] bucket = new int[maxValue+1];
        for(int num : nums) {
            bucket[num]++;
        }

        int t=0;
        for(int i=0; i<=maxValue; i++) {
            while(bucket[i] > 0) {
                nums[t++] = i;
                bucket[i]--;
            }
        }
    }

    // 桶排序
    private void bucketSort(int[] nums) {
        int n = nums.length;

        int maxValue = Integer.MIN_VALUE;
        int minValue = Integer.MAX_VALUE;
        for(int num : nums) {
            maxValue = Math.max(maxValue, num);
            minValue = Math.min(minValue, num);
        }

        // 计算桶的数量
        int bucketNum = (maxValue - minValue) / n + 1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
        for(int i = 0; i < bucketNum; i++){
            bucketArr.add(new ArrayList<>());
        }

        // 将每个元素放入桶
        for (int value : nums) {
            int num = (value - minValue) / n;
            bucketArr.get(num).add(value);
        }

        // 对每个桶进行排序
        for (ArrayList<Integer> integers : bucketArr) {
            Collections.sort(integers);
        }

        // 将桶中的元素赋值到原序列
        int index = 0;
        for (ArrayList<Integer> integers : bucketArr) {
            for (Integer integer : integers) {
                nums[index++] = integer;
            }
        }
    }

    // 基数排序
    private void radixSort(int[] nums) {
        int n = nums.length;

        int maxValue = Integer.MIN_VALUE;
        for(int num : nums) {
            maxValue = Math.max(maxValue, num);
        }
        int maxx = 0;
        while(maxValue > 0) {
            maxValue /= 10;
            maxx++;
        }

        int t = 1;
        for(int i=0; i<maxx; i++) {
            List<List<Integer>> list = new ArrayList<>();
            for(int j=0; j<10; j++) {
                list.add(new ArrayList<>());
            }

            for(int num : nums) {
                list.get((num/t)%10).add(num);
            }

            int tt=0;
            for(int j=0; j<10; j++) {
                for(int k=0; k<list.get(j).size(); k++) {
                    nums[tt++] = list.get(j).get(k);
                }
            }

            t *= 10;
        }
    }

    public static void main(String[] args) {
        Solution test = new Solution();

        int[] nums1 = {9, 1, 2, 5, 8, 7, 6, 3, 4, 0};
        test.bubbleSort(nums1);
        System.out.println("冒泡排序: " + Arrays.toString(nums1));

        int[] nums2 = {9, 1, 2, 5, 8, 7, 6, 3, 4, 0};
        test.selectionSort(nums2);
        System.out.println("选择排序: " + Arrays.toString(nums2));

        int[] nums3 = {9, 1, 2, 5, 8, 7, 6, 3, 4, 0};
        test.insertionSort(nums3);
        System.out.println("插入排序: " + Arrays.toString(nums3));

        int[] nums4 = {9, 1, 2, 5, 8, 7, 6, 3, 4, 0};
        test.shellSort(nums4);
        System.out.println("希尔排序: " + Arrays.toString(nums4));

        int[] nums5 = {9, 1, 2, 5, 8, 7, 6, 3, 4, 0};
        test.mergeSort(nums5);
        System.out.println("归并排序: " + Arrays.toString(nums5));

        int[] nums6 = {9, 1, 2, 5, 8, 7, 6, 3, 4, 0};
        test.quickSort(nums6);
        System.out.println("快速排序: " + Arrays.toString(nums6));

        int[] nums7 = {9, 1, 2, 5, 8, 7, 6, 3, 4, 0};
        test.heapSort(nums7);
        System.out.println("堆排序: " + Arrays.toString(nums7));

        int[] nums8 = {9, 1, 2, 5, 8, 7, 6, 3, 4, 0};
        test.countingSort(nums8);
        System.out.println("计数排序: " + Arrays.toString(nums8));

        int[] nums9 = {9, 1, 2, 5, 8, 7, 6, 3, 4, 0};
        test.bucketSort(nums9);
        System.out.println("桶排序: " + Arrays.toString(nums9));

        int[] nums10 = {9, 1, 2, 5, 8, 7, 6, 3, 4, 0};
        test.radixSort(nums10);
        System.out.println("基数排序: " + Arrays.toString(nums10));

    }

    private void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

输出:

能力有限，如有误，欢迎指正。。。 

Pitiless-invader
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
八种排序算法模板
laocooon的博客
12-21 156
【代码】八种排序算法模板。
排序算法模板
orz_include的博客
07-28 173
排序算法
八种排序算法（c++模板实现）------详细注释版
weixin_48617416的博客
03-21 2093
八种排序算法（c++模板实现）------详细注释版 前言 排序算法基本上学过数据结构都是有所学习的，本篇博客不再详细介绍每种算法的基础思想，会直接通过代码及注释的方式展示出算法，方便自己及已经入门同学日常回顾！ 概述 排序 种类 内部排序 使用内存 外部排序 内存不够使用需要访问外存，常见算法有：多路归并排序、外分配排序等 内部排序算法种类 排序方式 排序种类 插入排序 直接插入排序、希尔排序 选择排序 简单选择排序、堆排序 交换排序 冒泡排序、快速排序
十个常用排序算法的原理及python模板
Kayla_Smith的博客
06-01 368
原理：希尔排序，也称缩小增量排序，是插入排序的一种高效改进式版本。与插入排序不同的是，希尔排序是对元素间隔固定的多个子序列分别进行插入排序，随着排序轮数的增加，子序列的长度逐渐缩小，最后变成一个整体有序的序列。原理：从第一个元素开始，将相邻的两个元素进行比较，如果前一个元素大于后一个元素就将它们交换，一轮下来最大的元素就会被交换到最后，再对前面的元素进行相同的操作，直到全部排序完成。原理：将未排序序列中的第一个元素插入到已排序序列中合适的位置，对于未排序序列中的其他元素进行相同的操作，直到全部排序完成。
算法之动态规划总结（11种DP类型，70道全部搞懂）
热门推荐
pl0321的博客
04-08 2万+
简介 参考文章，将所有的DP问题分成11大类，本文将这些题目的解法进行探讨。所有题目均来自leetcode。 题目 1、线性 DP 最经典单串： 最长上升子序列 最经典双串： 最长公共子序列 经典问题： 三角形最小路径和 最大子序和 乘积最大子数组 鸡蛋掉落（DP+二分） 俄罗斯套娃信封问题 打家劫舍系列: (打家劫舍3 是树形DP) 打家劫舍 打家劫舍 II 股票系列: 买卖股票的最佳时机 买卖股票的最佳时机 II 买卖股票的最佳时机 III 买卖股票的最佳时机 IV
排序算法模板实现示例分享
01-20
代码如下:#include <cstdlib>#include using namespace std; #define SELECTSORT 1#define INSERTSORT 1#define BUBBLESORT 1#define SHELLSORT 1#define QUICKSORT 1#define MERGESORT 1 ...
十大经典排序算法源码.cpp
05-02
爆肝整理！堪称全网最详细的十大常用经典排序算法总结！！！ C++模板类实现，附带部分测试用例！！！
各种排序算法的C++模板类实现
05-10
各种排序算法的C++模板类实现，完整的代码类，供大家参考。
STl中的排序算法详细解析
09-05
全排序即把所给定范围所有的元素按照大小关系顺序排列。sort采用的是成熟的"快速排序算法"(目前大部分STL版本已经不是采用简单的快速排序，而是结合内插排序算法)
常用排序算法模板
09-27
根据自己写的代码制作的代码模板，主要是排序部分，包括快速排序，归并排序，堆排序，冒泡排序，和插入排序。
Python实现十种排序算法
ArtinCode
11-07 200
#%% 冒泡排序 算法步骤 # # 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 # # 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。 # # 针对所有的元素重复以上的步骤，除了最后一个。 # # 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 def bubbleSort(arr): for i i...
经典排序算法合集——C++模板实现
Skynet的博客
09-04 307
数据结构内部排序C++模板实现如下： #include <iostream> #include <vector> #include <random> #include <ctime> #include <cstdlib> using namespace std; /*直接插入排序 *将第i个记录插入到前面i-1个已经排好序的记录中...
算法——排序算法类模板
zjt980452483的博客
11-15 207
package algorithms.example; /** * @Author: zjtMeng * @Date: 2019/11/14 22:15 * @Version 1.0 */ public class Example { /** * 排序算法的实现 * @param a 待排序的数组 */ public static void...
《算法（第四版）》排序-----模板
kwang0131的博客
04-01 1807
本书对排序类算法有一个模板，包括了以下几种方法： （1）sort（）：这个方法里面实现的就是排序的算法 （2）less（）：这个方法里是利用了Comparable接口里的compareTo方法，其中compareTo方法对于本对象与传入的比较对象小于，等于，大于，分别返回负数，0，正数                              这个方法如果compareTo方法结果为负数就返
十大排序模板
xizi_ghq的博客
12-30 156
#include<bits/stdc++.h> using namespace std; void insertsort(int a[],int n){//插入 int j; for(int i=2;i<=n;i++){ if(a[i]<a[i-1]){ a[0]=a[i]; for(j=i-1;a[j]>a[0];j--) a[j+1]...
各种排序算法模板
hongxue8888的博客
12-01 285
文章目录冒泡排序快速排序插入排序选择排序堆排序归并排序计数排序 冒泡排序 // 冒泡排序，a表示数组，n表示数组大小 public void bubbleSort(int[] a, int n) { if (n <= 1) return; for (int i = 0; i < n; ++i) { // 提前退出冒泡循环的标志位 boolean flag =...
【算法】算法第四版学习笔记 -- 排序算法类模板
chenghan_yang的博客
10-10 509
摘至算法第四版 P153 package sort; public class Example { public static boolean less(Comparable v, Comparable w) { return v.compareTo(w) &amp;amp;amp;lt; 0; } public static void exch(Comparable[] a, int i, int j)...
冒泡算法排序c++模板
最新发布
09-01
当然，我可以为您提供冒泡排序的C语言代码模板。以下是一个简单的冒泡排序示例： ```c #include <stdio.h> void bubbleSort(int array[], int size) { for (int i = 0; i < size - 1; i++) { for (int j = 0; j < size - i - 1; j++) { if (array[j] > array[j + 1]) { // 交换两个元素 int temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; } } } } void printArray(int array[], int size) { for (int i = 0; i < size; i++) { printf("%d ", array[i]); } printf("\n"); } int main() { int array[] = {64, 34, 25, 12, 22, 11, 90}; int size = sizeof(array) / sizeof(array[0]); printf("排序前的数组："); printArray(array, size); bubbleSort(array, size); printf("排序后的数组："); printArray(array, size); return 0; } ``` 这段代码包含了一个 `bubbleSort` 函数，用于对给定整数数组进行冒泡排序。`printArray` 函数用于打印数组内容。在 `main` 函数中，我们创建了一个示例数组，并通过调用 `bubbleSort` 函数进行排序，最后通过调用 `printArray` 函数打印排序后的数组。 请注意，这只是冒泡排序的简单示例，您可以根据需要进行修改和扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值