精华内容
下载资源
问答
  • 计数排序 java实现

    2021-02-12 19:30:39
    典型的用空间换时间的线性算法,本算法要求待排序的数组元素都是非负整数,但是可以修改算法,使其适应浮点和负数的排序代码:/*** 计数排序 排序要求待排序的数组中存储的都是非负整数(0到k),(理论上可以是任意数...

    典型的用空间换时间的线性算法,本算法要求待排序的数组元素都是非负整数,但是可以修改算法,使其适应浮点和负数的排序

    代码:

    /**

    * 计数排序 排序要求待排序的数组中存储的都是非负整数(0到k),(理论上可以是任意数,不过需要

    * 把负数变成正整数,把浮点数变成正整数,需要的时候可以自己修改)

    *

    * @author Hersules

    */

    public class CountingSort {

    public static int[] countingSort(int[] a) {

    int[] b = new int[a.length];

    // 1、先找出数组中的最大值

    int largest = 0;

    for (int i = 0; i < a.length; i++) {

    if (a[i] > largest)

    largest = a[i];

    }

    // 2、初始化计数的数组c

    int[] c = new int[largest + 1];

    for (int i = 0; i < c.length; i++) {

    c[i] = 0;

    }

    // 3、计数待排序数组中每个元素的出现的个数

    for (int i = 0; i < a.length; i++) {

    c[a[i]]++;

    }// 现在c[m]就表示值m出现的次数

    // 4、统计

    for (int i = 1; i < c.length; i++) {

    c[i] += c[i - 1];

    }// 现在c[m]就表示 小于等于m的值 出现的次数

    // 5、排序

    for (int j = a.length - 1; j >= 0; j--) {

    b[c[a[j]] - 1] = a[j];

    c[a[j]]--;

    }

    return b;

    }

    }

    展开全文
  • 计数排序Java

    2021-07-26 20:22:30
    import java.util.Arrays; public class CountSort { public static void main(String[] args) { int[] arr = {3,44,38,5,47,15,36,26,27,2,46,4,19,50,48}; int[] result = sort(arr); System.out.println...
    package data_structure;
    
    import java.util.Arrays;
    
    public class CountSort {
        public static void main(String[] args) {
            int[] arr = {3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
            int[] result = sort(arr);
            System.out.println(Arrays.toString(result));
        }
        private static int[] sort(int[] arr){
            int[] result = new int[arr.length];
            int max = arr[0];
            for (int a: arr) {
                if (max < a){
                    max = a;
                }
            }
            // 注意max + 1,因为长度为max的数组是不包括下标为max的
            int[] count = new int[max + 1];
    
            for (int a:arr) {
                count[a]++;
            }
            System.out.println("计数数组:");
            System.out.println(Arrays.toString(count));
    
            for (int i = 0, j = 0; i < count.length; i++){
                while (count[i]-- > 0)
                    result[j++] = i;
            }
            return result;
        }
    }
    
    
    
    
    展开全文
  • Java实现计数排序算法

    2021-02-23 21:49:42
    计数排序算法 计数排序是一种排序算法,它通过计算数组中每个唯一元素的出现次数来对数组的元素进行排序。将计数存储在辅助数组中,并通过将计数映射为辅助数组的索引来完成排序。 计数排序如何工作? max从...

    计数排序算法

    计数排序是一种排序算法,它通过计算数组中每个唯一元素的出现次数来对数组的元素进行排序。将计数存储在辅助数组中,并通过将计数映射为辅助数组的索引来完成排序。


    计数排序如何工作?

    1. 从给定的数组中找出最大的元素(max)。计算排序步骤

      给定数组

    2. 初始化一个长度max+1为0的所有元素的数组。此数组用于存储数组中元素的数量。计数排序步骤

      计数数组

    3. 将每个元素的计数存储在count数组中它们各自的索引处

      例如:如果元素3的计数为2,则将2存储在元素的第3个位置数数大批。如果数组中不存在元素“ 5”,则在第5个位置存储0。计数排序步骤

      存储的每个元素的计数

    4. 存储计数数组元素的累积和。它有助于将元素放入已排序数组的正确索引中。计数排序步骤

      累计数

    5. 在count数组中找到原始数组的每个元素的索引。这给出了累计计数。将元素放置在计算出的索引处,如下图所示。计算排序步骤

      计数排序

    6. 将每个元素放置在正确位置后,将其数量减少一。

    计数排序算法

    countSort(array,size)
      max <-查找数组中的最大元素
      用全零初始化计数数组
      对于j <-0到大小
        找到每个唯一元素的总数,然后 
        将计数存储在count数组中的第j个索引处
      对于我<-1到最大
        找到累积和并将其存储在count数组本身中
      对于j <-减小到1
        恢复元素到数组
        将还原的每个元素的数量减少1

    Java示例

     
    import java.util.Arrays;
    
    public class CountingSortDemo {
    	public static void main(String[] args) {
    		int[] array = { 4, 2, 2, 8, 3, 3, 1 };
    		// Find the maximum element in the input array
    		int max = findMaxElement(array);
    		System.out.println("Max Value in input array-" + max);
    		System.out.println("Original Array- " + Arrays.toString(array));
    		int[] sortedArr = countingSort(array, max + 1);
    		System.out.println("Sorted array after counting sort- " + Arrays.toString(sortedArr));
    	}
    
    	private static int findMaxElement(int[] array) {
    		int max = array[0];
    		for (int val : array) {
    			if (val > max)
    				max = val;
    		}
    		return max;
    	}
    
    	private static int[] countingSort(int[] array, int range) {
    		int[] output = new int[array.length];
    		int[] count = new int[range];
    		// Calculate frequency of each element, put it in count array
    		for (int i = 0; i < array.length; i++) {
    			count[array[i]]++;
    		}
    		System.out.println("Count array- " + Arrays.toString(count));
    
    		// Modify count array to get the final position of elements
    		for (int i = 1; i < range; i++) {
    			count[i] = count[i] + count[i - 1];
    		}
    		System.out.println("Modified count array- " + Arrays.toString(count));
    
    		// Add elements to output sorted array
    		for (int i = 0; i < array.length; i++) {
    			output[count[array[i]] - 1] = array[i];
    			count[array[i]]--;
    		}
    		return output;
    	}
    }

     

    输出:

    Max Value in input array-8
    Original Array- [4, 2, 2, 8, 3, 3, 1]
    Count array- [0, 1, 2, 2, 1, 0, 0, 0, 1]
    Modified count array- [0, 1, 3, 5, 6, 6, 6, 6, 7]
    Sorted array after counting sort- [1, 2, 2, 3, 3, 4, 8]
     


    复杂

    时间复杂度:

    主要有四个主要循环。(可以在函数外部找到最大值。)

    循环计数时间
    第一O(最大)
    第二名O(大小)
    第三名O(最大)
    第四名O(大小)

    总体复杂度= O(max)+O(size)+O(max)+O(size)=O(max+size)

    • 最坏情况的复杂性: O(n+k)
    • 最佳案例复杂度: O(n+k)
    • 平均案件复杂度: O(n+k)

    在上述所有情况下,复杂度都是相同的,因为无论元素如何放置在数组中,算法都会经历n+k时间。

     

     

    任何元素之间都没有比较,因此它比基于比较的排序技术要好。但是,如果整数很大,那是不好的,因为应该制作该大小的数组。

    空间复杂度:

    计数排序的空间复杂度为O(max)。元素范围越大,空间复杂度越大。


    计算排序应用程序

    在以下情况下使用计数排序:

    • 有多个较小的整数。
    • 线性复杂度是必要的。
    展开全文
  • 计数排序java实现

    2021-11-10 10:41:48
    计数排序java实现 public int[] sortArray(int[] nums){ int min=Integer.MAX_VALUE; int max=Integer.MIN_VALUE; for (int num:nums) { min=Math.min(min,num); max=Math.max(max,num); } int[] cou

    计数排序java实现

        public int[] sortArray(int[] nums){
            int min=Integer.MAX_VALUE;
            int max=Integer.MIN_VALUE;
            for (int num:nums)
            {
                min=Math.min(min,num);
                max=Math.max(max,num);
            }
    
            int[] counts =new int[max-min+1];
            for (int num:nums)
                counts[num-min]++;
    
            int i=0;
            for (int num=min;num<=max;num++)
                while ((counts[num-min]>0)) {
                    nums[i++]=num;
                    counts[num-min]--;
                }
    
            return nums;
        }
    
    展开全文
  • 计数排序(java实现)

    2021-12-07 10:46:16
    计数排序是一个非基于比较的排序算法,该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时,它的复杂度为Ο(n+k)(其中k是整数的范围),快于任何比较排序算法。当然这是一种牺牲空间...
  • 计数排序 原理 计数排序(Counting Sort) 使用了一个额外的数组 C,其中第 i 个元素是待排序数组A 中值等于 i 的元素的个数。然后根据数组 C 来将 A 中的元素排到正确的位置。其实计数排序其实是桶排序的一种特殊情况...
  • JAVA 计数排序

    2021-01-06 11:01:50
    计数排序不同于比较排序,它是以下标记录值的方式。 规则:知道范围的数值(正数,有规律的负数) 大量的文字表达比较抽象,我用例子作解释: 大家看这个数据6,5,4,3,2,1 是一个我们已知范围的数据(最大值为6) ...
  • JAVA计数排序代码

    2021-02-27 20:04:45
    * 计数排序:辅助计数数组auxiliary用来记录每个元素出现的次数,然后挨个取出即可 * 例如: * * 3 2 5 4 4 * * arr[0] arr[1] arr[2] arr[3] arr[4] arr[5] * 0 0 1 1 2 1 * * * * */ public
  • 假设我们需要对一个整数类型的数组进行排序,那么排序的方法有很多种(归并排序啊、快速排序等等),今天主要是讲一下刚学习的计数排序。 假设有下面这样一个数组: 我们要对这样的一个数组进行计数排序,计数...
  • Java实现计数排序

    2021-03-16 20:37:34
    /*** 计数排序假设n个输入元素中的每一个都是介于0到k之间的某个整数,k为某个整数;它* 通过确定小于等于一个数的数的个数来确定这个数应该放在哪个位置* @author yuncong**/public class CountSort {/****...
  • Java计数排序程序

    2021-03-16 20:37:22
    计数排序对具有不同键值的对象数进行计数。让我们看一个例子-注意-以下代码也可以与负数一起使用。示例importjava.util.*;publicclassDemo{staticvoidcount_sort(int[]arr){intmax_val=Arrays.stream(arr).max()....
  • Java实现计数排序详解

    2021-02-12 19:30:38
    /*** 计数排序假设n个输入元素中的每一个都是介于0到k之间的某个整数,k为某个整数;它* 通过确定小于等于一个数的数的个数来确定这个数应该放在哪个位置* @author yuncong**/public class CountSort {/**** @param ...
  • 目录比较和非比较的区别常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里,元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较,才能确定自己的位置。在冒泡排序之类...
  • ## **计数排序**计数排序不是基于比较的排序算法,其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数。## **算法描述**1...
  • 排序数组) https://leetcode-cn.com/problems/sort-an-array/ ## 题目描述 ``` 给你一个整数数组nums,请你将该数组升序排列。 示例 1: 输入:nums = [5,2,3,1] 输出:[1,2,3,5] 示例 2: 输入:nums = ...
  • 转载并修改自:http://www.cnblogs.com/kkun/archive/2011/11/23/2260299.html(文章很生动,很喜欢,原文用vb还是什么实现的,我也不认识,自己有java实现了一遍)计数排序(counting sorting)的过程类似小学选班干部...
  • 计数排序 前言:在博客写这些文章的目的用于记录所学,怕以后忘了,如果哪里写的不对欢迎指正,谢谢!! 学习目标:掌握计数排序算法的原理和思想 一、前提知识   排序算法概念、时间复杂度。可前往此网址 ...
  • 1 计数排序 计数排序是一种非基于比较的排序算法,其空间复杂度和时间复杂度均为 O(n+k),其中 k 是整数的范围。基于比较的排序算法时间复杂度最小是 O(nlogn)的。 计数排序的核心在于将输入的数据值转化为键存储在...
  • java计数排序

    2021-03-22 16:20:47
    介绍: 该算法不基于比较进行排序,时间复杂度O(n + k),很难说与基于比较的排序算法(时间复杂度下限O(nlogn))哪个更优,具体要比较k与nlogn的大小;实现思路:1.以数组originArr中最大值max构建一个长度为max+1的数组...
  • Java实现---计数排序

    2021-09-26 19:08:41
    计数排序是一种非基于比较的排序方法,在某些特定的场景中,使用计数排序的方式可以实现O(n+k)的时间复杂(k表示待排序的数据范围),比任何基于比较的排序方法都要快。 算法分析 1、给每一个数都准备一个存放的空间...
  • 前言声明:参考来源互联网,有任何争议可以留言。站在前人的肩上,我们才能看的更远。本教程纯手打,致力于最实用教程,不需要什么奖励,只希望多多...1.计数排序(Counting Sort)1.1.计数排序(Counting Sort)计数...
  • 计数排序感觉不难,但是细节比较复杂。 一、原理 计数排序实质上是桶排序的特殊情况,对于桶排序,当桶的数量等于元素数量时,可以达到最短的排序时长,这种情况不就是一个桶对应一个元素值吗?比如我们有取值范围为...
  • oj-计数排序-java

    2021-02-06 18:07:55
    实现计数排序,通过多次遍历数组,统计比每一个元素小的其它元素个数,根据该统计量对数据进行排序。 Input 输入的每一行表示一个元素为正整数的数组,所有值用空格隔开,第一个值为数值长度,其余为数组元素值。 ...
  • * 计数排序* 排序流程:1.找出源数组中的最小值;2.找出源数组中的最大值;3.创建=最大值+1长度的新数组;4.在新数组中循环从最小值开始;5.再次循环源数组,直接将值作为新数组的下标;6.相同的数字,出现一次,就...
  • java 实现计数排序和桶排序实例代码目录比较和非比较的区别常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里,元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较,...
  • 二、计数排序: 三、基数排序: 一、桶排序: 1、算法原理: 桶排序的核心思想就是将要排序的数据分到几个有序的桶里,每个桶里的数据再单独进行排序。桶排序完之后,再把每个桶里的数据按照顺序依次取出,组成...
  • 计数排序Java

    2021-11-22 14:34:25
    //计数排序 public class CountingSort { public static void main(String[] args) { int[] array = new int[]{20, 21, 8, 30, 20, 6, 51, 14}; CountingSort(array); System.out.println(Arrays.toString(array...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 58,434
精华内容 23,373
关键字:

计数排序java

java 订阅