精华内容
下载资源
问答
  • 现在有一个录取了40名学生分数的int类型的数组,我们要如何将他们的分数进行从大到小的排序? Java提供一个排序方法:Arrays.sort 首先,在java中导入Arrays包 import java.util.Arrays 然后找到我们需要排序的数组...

    现在有一个录取了40名学生分数的int类型的数组,我们要如何将他们的分数进行从大到小的排序?

    Java提供一个排序方法:Arrays.sort
    首先,在java中导入Arrays包

    import java.util.Arrays
    

    然后找到我们需要排序的数组,用Arrays.sort方法排序即可

    int [] score = new int score[40];
    Arrays.sort(score);
    

    这里score数组中我们默认有值。
    这时候利用for循坏输出score数组,

    for(int i =0;i<=score.lenght;i++){
    	Sysout(score[i]+" ");
    }
    

    你会发现数组中的值已经从小到大重新排列了一遍,也就
    是说,此时score[39]的值会是这个成绩数组中的最大值,而score[0]的值则为这个成绩数组中的最小值

    Arrays.sort方法只提供从小到大的升序排列,如果我们需要从大到小|的降序排列,那又该怎么做呢?

    我们new一个新数组来接收这个老数组,

    int [] score2 =new score2[40]; 
    

    利用for循坏,将旧数组的数据循环输入给我们新建的score2数组

    for(int i=0,j=score.length-1;i<=score2.length;i++,j--){
    	score2[i]=score[j];
    }
    

    此时输出新数组

    for(int i =0;i<=score2.lenght;i++){
    	Sysout(score2[i]+" ");
    }
    

    此时我们已经将这个成绩数组进行了从大到小的排列。

    需要注意的是,Java本身并不提供从大到小的降序排列方法,需要程序员自己去想办法。

    关于String类型数组的排序
    int类型的数组可以用Arrays.sort方法进行从小到大的升序排列,那么String可以吗?
    可以的。
    String类型的数组利用Arrays.sort方法排序,它会根据26个英文字母来进行升序排列。
    具体的大家自己去实践,参考上文。

    你好,
    我也是刚开始学习Java的程序猿,点个关注,一起学习!

    展开全文
  • 计数排序

    2017-04-08 23:25:10
    比如100万学生参加高考,我们想对这100万学生的数学成绩(假设分数为0到100)做个排序。我们如何设计一个最高效的排序算法。本文不光出计数排序算法的传统写法,还将一步步深入讨论算法的优化,直到时间复杂度和...

    转自:计数排序

     

    计数排序是一种算法复杂度 O(n) 的排序方法,适合于小范围集合的排序。比如100万学生参加高考,我们想对这100万学生的数学成绩(假设分数为0到100)做个排序。我们如何设计一个最高效的排序算法。本文不光给出计数排序算法的传统写法,还将一步步深入讨论算法的优化,直到时间复杂度和空间复杂度最优。

    先看看计数排序的定义

    Counting sort (sometimes referred to as ultra sort or math sort[1]) is a sorting algorithm which (like bucket sort) takes advantage of knowing the range of the numbers in the array to be sorted (array A). It uses this range to create an array C of this length. Each index i in array C is then used to count how many elements in A have the value i; then counts stored in C can then be used to put the elements in A into their right position in the resulting sorted array. The algorithm was created by Harold H. Seward in 1954.

    计数排序是一个类似于桶排序的排序算法,其优势是对已知数量范围的数组进行排序。它创建一个长度为这个数据范围的数组C,C中每个元素记录要排序数组中对应记录的出现个数。这个算法于1954年由 Harold H. Seward 提出。

    下面以示例来说明这个算法

    假设要排序的数组为 A = {1,0,3,1,0,1,1}

    这里最大值为3,最小值为0,那么我们创建一个数组C,长度为4.

    然后一趟扫描数组A,得到A中各个元素的总数,并保持到数组C的对应单元中。

    比如0 的出现次数为2次,则 C[0] = 2;1 的出现次数为4次,则C[1] = 4

     

    image

    由于C 是以A的元素为下标的,所以这样一做,A中的元素在C中自然就成为有序的了,这里我们可以知道 顺序为 0,1,3 (2 的计数为0)

    然后我们把这个在C中的记录按每个元素的计数展开到输出数组B中,排序就完成了。

    也就是 B[0] 到 B[1] 为0  B[2] 到 B[5] 为1 这样依此类推。

    这种排序算法,依靠一个辅助数组来实现,不基于比较,算法复杂度为 O(n) ,但由于要一个辅助数组C,所以空间复杂度要大一些,由于计算机的内存有限,这种算法不适合范围很大的数的排序。

    注:基于比较的排序算法的最佳平均时间复杂度为 O(nlogn)

     

    Counting sort
    Depends on a key assumption: numbers to be sorted are integers in{0, 1, . . . , k}.
    Input: A[1 . . n], where A[ j ] ∈ {0, 1, . . . , k} for j = 1, 2, . . . , n. Array A and
    values n and k are given as parameters.
    Output: B[1 . . n], sorted. B is assumed to be already allocated and is given as a
    parameter.
    Auxiliary storage: C[0 . . k]
    8-4 Lecture Notes for Chapter 8: Sorting in Linear Time
    COUNTING-SORT(A, B, n, k)
    for i ← 0 to k
    do C[i ] ← 0
    for j ← 1 to n
    do C[A[ j ]] ← C[A[ j ]] + 1
    for i ← 1 to k
    do C[i ] ← C[i ] + C[i − 1]
    for j ← n downto 1
    do B[C[A[ j ]]] ← A[ j ]
    C[A[ j ]] ← C[A[ j ]] − 1
    Do an example for A = 21, 51, 31, 01, 22, 32, 02, 33
    Counting sort is stable (keys with same value appear in same order in output as
    they did in input) because of how the last loop works.

    展开全文
  • 比如100万学生参加高考,我们想对这100万学生的数学成绩(假设分数为0到100)做个排序。我们如何设计一个 最高效的排序算法。本文不光出计数排序算法的传统写法,还将一步步深入讨论算法的优化,直到时间复杂度和...

    计数排序是一种算法复杂度 O(n) 的排序方法,适合于小范围集合的排序。比如100万学生参加高考,我们想对这100万学生的数学成绩(假设分数为0到100)做个排序。我们如何设计一个 最高效的排序算法。本文不光给出计数排序算法的传统写法,还将一步步深入讨论算法的优化,直到时间复杂度和空间复杂度最优。

    先看看计数排序的定义

    Counting sort (sometimes referred to as ultra sort or math sort[1]) is a sorting algorithm which (like bucket sort) takes advantage of knowing the range of the numbers in the array to be sorted (array A). It uses this range to create an array C of this length. Each index i in array C is then used to count how many elements in A have the value i; then counts stored in C can then be used to put the elements in A into their right position in the resulting sorted array. The algorithm was created by Harold H. Seward in 1954.

    计数排序是一个类似于桶排序的排序算法,其优势是对已知数量范围的数组进行排序。它创建一个长度为这个数据范围的数组C,C中每个元素记录要排序数组中对应记录的出现个数。这个算法于1954年由 Harold H. Seward 提出。

    下面以示例来说明这个算法

    假设要排序的数组为 A = {1,0,3,1,0,1,1}

    这里最大值为3,最小值为0,那么我们创建一个数组C,长度为4.

    然后一趟扫描数组A,得到A中各个元素的总数,并保持到数组C的对应单元中。

    比如0 的出现次数为2次,则 C[0] = 2;1 的出现次数为4次,则C[1] = 4

     

    image

    由于C 是以A的元素为下标的,所以这样一做,A中的元素在C中自然就成为有序的了,这里我们可以知道 顺序为 0,1,3 (2 的计数为0)

    然后我们把这个在C中的记录按每个元素的计数展开到输出数组B中,排序就完成了。

    也就是 B[0] 到 B[1] 为0  B[2] 到 B[5] 为1 这样依此类推。

    这种排序算法,依靠一个辅助数组来实现,不基于比较,算法复杂度为 O(n) ,但由于要一个辅助数组C,所以空间复杂度要大一些,由于计算机的内存有限,这种算法不适合范围很大的数的排序。

    注:基于比较的排序算法的最佳平均时间复杂度为 O(nlogn)

     

    Counting sort
    Depends on a key assumption: numbers to be sorted are integers in{0, 1, . . . , k}.
    Input: A[1 . . n], where A[ j ] ∈ {0, 1, . . . , k} for j = 1, 2, . . . , n. Array A and
    values n and k are given as parameters.
    Output: B[1 . . n], sorted. B is assumed to be already allocated and is given as a
    parameter.
    Auxiliary storage: C[0 . . k]
    8-4 Lecture Notes for Chapter 8: Sorting in Linear Time
    COUNTING-SORT(A, B, n, k)
    for i ← 0 to k
    do C[i ] ← 0
    for j ← 1 to n
    do C[A[ j ]] ← C[A[ j ]] + 1
    for i ← 1 to k
    do C[i ] ← C[i ] + C[i − 1]
    for j ← n downto 1
    do B[C[A[ j ]]] ← A[ j ]
    C[A[ j ]] ← C[A[ j ]] − 1
    Do an example for A = 21, 51, 31, 01, 22, 32, 02, 33
    Counting sort is stable (keys with same value appear in same order in output as
    they did in input) because of how the last loop works.

    上面这段引自麻省理工大学计算机算法教材的技术排序部分,我不做翻译了。这个就是这个算法的典型解法,我把它作为方案1.

    这个算法的实际扫描次数为 n+k (不包括写的次数)

    方案1

     

            public static void Sort(int[] A, out int[] B, int k)
            {
                Debug.Assert(k > 0);
                Debug.Assert(A != null);
     
                int[] C = new int[k + 1];
                B = new int[A.Length];
     
                for (int j = 0; j < A.Length; j++)
                {
                    C[A[j]]++;
                }
     
                for (int i = 1; i <= k; i++)
                {
                    C[i] += C[i-1];
                }
     
                for (int j = A.Length - 1; j >= 0; j--)
                {
                    B[C[A[j]]-1] = A[j];
                    C[A[j]]--;
                }
     
            }

    上面代码是方案1 的解法,也是计数排序算法的经典解法,麻省的教材上也是这样解。不过这个解法并不是最优的,因为空间复杂度还应该可以优化,我们完全可以不要那个输出的数组B,直接对A进行排序。在继续看方案2之前,我建议大家先自己思考一下,看看是否有办法省略掉数组B

     

    方案2

    我们对上述代码进行优化

            public static void Sort(int[] A, int k)
            {
                Debug.Assert(k > 0);
                Debug.Assert(A != null);
    
                int[] C = new int[k + 1];
    
                for (int j = 0; j < A.Length; j++)
                {
                    C[A[j]]++;
                }
    
                int z = 0;
    
                for (int i = 0; i <= k; i++)
                {
                    while (C[i]-- > 0)
                    {
                        A[z++] = i;
                    }
                }
            }

    由于C数组下标 i 就是A 的值,所以我们不需要保留A中原来的数了,这个代码减少了一个数组B,而且要比原来的代码简化了很多。

     

    和快速排序的速度比较

    拿本文刚开始那个高考成绩的例子来做

                int[] A = new int[1000000];
                int[] B = new int[1000000];
     
                Random rand = new Random();
     
                for (int i = 0; i < A.Length; i++)
                {
                    A[i] = rand.Next(0, 100);
                }
     
                A.CopyTo(B, 0);
     
                Stopwatch sw = new Stopwatch();
                sw.Start();
                Array.Sort(B);
                sw.Stop();
                Console.WriteLine(sw.ElapsedMilliseconds);
     
                sw.Reset();
                sw.Start();
     
                CountingSort.Sort(A, 100);
                sw.Stop();
                Console.WriteLine(sw.ElapsedMilliseconds);

     

    输出结果

    134 //快速排序
    18   //计数排序

    可见计数排序要比快速排序快将近6倍左右。

    转载于:https://www.cnblogs.com/Simon-xm/p/3985433.html

    展开全文
  • 比如100万学生参加高考,我们想对这100万学生的数学成绩(假设分数为0到100)做个排序。我们如何设计一个最高效的排序算法。本文不光出计数排序算法的传统写法,还将一步步深入讨论算法的优化,直到时间复杂度和...

    计数排序是一种算法复杂度 O(n) 的排序方法,适合于小范围集合的排序。比如100万学生参加高考,我们想对这100万学生的数学成绩(假设分数为0到100)做个排序。我们如何设计一个最高效的排序算法。本文不光给出计数排序算法的传统写法,还将一步步深入讨论算法的优化,直到时间复杂度和空间复杂度最优。

    计数排序是一个类似于桶排序的排序算法,其优势是对已知数量范围的数组进行排序。它创建一个长度为这个数据范围的数组CC中每个元素记录要排序数组中对应记录的出现个数。这个算法于1954年由 Harold H. Seward 提出。

    下面以示例来说明这个算法

    假设要排序的数组为 A ={1,0,3,1,0,1,1}

    这里最大值为3,最小值为0,那么我们创建一个数组C,长度为4.

    然后一趟扫描数组A,得到A中各个元素的总数,并保持到数组C的对应单元中。

    比如0 的出现次数为2次,则 C[0] = 2;1 的出现次数为4次,则C[1] = 4

     

    由于C 是以A的元素为下标的,所以这样一做,A中的元素在C中自然就成为有序的了,这里我们可以知道 顺序为 0,1,3 (2 的计数为0)

    然后我们把这个在C中的记录按每个元素的计数展开到输出数组B中,排序就完成了。

    也就是 B[0] 到 B[1] 为0  B[2] 到 B[5] 为1 这样依此类推。

    这种排序算法,依靠一个辅助数组来实现,不基于比较,算法复杂度为 O(n) ,但由于要一个辅助数组C,所以空间复杂度要大一些,由于计算机的内存有限,这种算法不适合范围很大的数的排序。

    注:基于比较的排序算法的最佳平均时间复杂度为 O(nlogn)

     

    Counting sort
    Depends on a key assumption: numbers to be sorted are integers in{0, 1, . . . ,k}.
    Input: A[1 . . n], where A[ j ] ∈ {0, 1, . . . , k}for j = 1, 2, . . . , n. Array A and
    values n and k are given as parameters.
    Output: B[1 . . n], sorted. B is assumed to be already allocated and is givenas a
    parameter.
    Auxiliary storage: C[0 . . k]
    8-4 Lecture Notes for Chapter 8: Sorting in Linear Time
    COUNTING-SORT(A, B, n, k)
    for i ← 0 to k
    do C[i ] ← 0
    for j ← 1 to n
    do C[A[ j ]] ← C[A[ j ]] + 1
    for i ← 1 to k
    do C[i ] ← C[i ] + C[i − 1]
    for j ← n downto 1
    do B[C[A[ j ]]] ← A[ j ]
    C[A[ j ]] ← C[A[ j ]] − 1
    Do an example for A = 21, 51, 31, 01, 22, 32, 02, 33
    Counting sort is stable (keys with same value appear in same order in output as
    they did in input) because of how the last loop works.

    上面这段引自麻省理工大学计算机算法教材的技术排序部分,我不做翻译了。这个就是这个算法的典型解法,我把它作为方案1.

    这个算法的实际扫描次数为 n+k (不包括写的次数)

    方案1

     

            public static void Sort(int[] A, out int[] B, int k)

            {

                Debug.Assert(k > 0);

                Debug.Assert(A != null);

     

                int[] C = new int[k + 1];

                B = new int[A.Length];

     

                for (int j = 0; j < A.Length; j++)

                {

                    C[A[j]]++;

                }

     

                for (int i = 1; i <= k; i++)

                {

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

                }

     

                for (int j = A.Length - 1; j >= 0; j--)

                {

                    B[C[A[j]]-1] = A[j];

                    C[A[j]]--;

                }

     

            }

    上面代码是方案1 的解法,也是计数排序算法的经典解法,麻省的教材上也是这样解。不过这个解法并不是最优的,因为空间复杂度还应该可以优化,我们完全可以不要那个输出的数组B,直接对A进行排序。在继续看方案2之前,我建议大家先自己思考一下,看看是否有办法省略掉数组B

     

    方案2

    我们对上述代码进行优化

            public static void Sort(int[] A, int k)

            {

                Debug.Assert(k > 0);

                Debug.Assert(A != null);

     

                int[] C = new int[k + 1];

     

                for (int j = 0; j < A.Length; j++)

                {

                    C[A[j]]++;

                }

     

                int z = 0;

     

                for (int i = 0; i <= k; i++)

                {

                    while (C[i]-- > 0)

                    {

                        A[z++] = i;

                    }

                }

            }

    由于C数组下标 i 就是A 的值,所以我们不需要保留A中原来的数了,这个代码减少了一个数组B,而且要比原来的代码简化了很多。

     

    和快速排序的速度比较

    拿本文刚开始那个高考成绩的例子来做

                int[] A = new int[1000000];

                int[] B = new int[1000000];

     

                Random rand = new Random();

     

                for (int i = 0; i < A.Length; i++)

                {

                    A[i] = rand.Next(0, 100);

                }

     

                A.CopyTo(B, 0);

     

                Stopwatch sw = new Stopwatch();

                sw.Start();

                Array.Sort(B);

                sw.Stop();

               Console.WriteLine(sw.ElapsedMilliseconds);

     

                sw.Reset();

                sw.Start();

     

                CountingSort.Sort(A, 100);

                sw.Stop();

               Console.WriteLine(sw.ElapsedMilliseconds);

    输出结果

    134 //快速排序
    18   //计数排序

    可见计数排序要比快速排序快将近6倍左右。

     

    展开全文
  • 计数排序——JAVA实现

    2015-07-30 15:40:50
    比如100万学生参加高考,我们想对这100万学生的数学成绩(假设分数为0到100)做个排序。我们如何设计一个最高效的排序算法。本文不光出计数排序算法的传统写法,还将一步步深入讨论算法的优化,直到时间复杂度和...
  •   计数排序是一种算法复杂度 O...比如100万学生参加高考,我们想对这100万学生的数学成绩(假设分数为0到100)做个排序。我们如何设计一个最高效的排序算法。本文不光出计数排序算法的传统写法,还将一步步深入...
  • 算法系列-计数排序

    2014-11-04 16:46:18
    比如100万学生参加高考,我们想对这100万学生的数学成绩(假设分数为0到100)做个排序。我们如何设计一个最高效的排序算法。本文不光出计数排序算法的传统写法,还将一步步深入讨论算法的优化,直到时间复杂度和...
  • 学生分数排序、每本书籍借阅量排序,甚至身高排序,比比皆是。最基本的场景就是,你一堆数字,让你从大到小,或从小到大,出他们的排序结果。而输入、输出参数我们都已经了解。下面看下我们是如何实现快排的,而...
  • 比如100万学生参加高考,我们想对这100万学生的数学成绩(假设分数为0到100)做个排序。我们如何设计一个最高效的排序算法。本文不光出计数排序算法的传统写法,还将一步步深入讨论算法的优化,直到时间复杂度和...
  • 比如100万学生参加高考,我们想对这100万学生的数学成绩(假设分数为0到100)做个排序。我们如何设计一个最高效的排序算法。本文不光出计数排序算法的传统写法,还将一步步深入讨论算法的优化,直到时间复杂度和...
  • 11.5有10个学生,每个学生的数据包括学号,姓名,3门课的成绩,从键盘输入10个学生的数据,要求打印出3门课的总平均成绩,以及最高分的学生的数据(包括学号,姓名,3门课成绩,平均分数)。 97 11.6编写一个函数new...
  • 数据结构课设

    2013-01-03 02:51:25
    任务 :利用随机函数产生10个样本(其中之一已为正序,之一为倒序),每个样本有20000随机整数,利用直接插入排序、希尔排序,冒泡排序、快速排序、选择排序、堆排序,归并排序(递归和非递归),基数排序八种排序...
  • 164_结构体11_综合应用_学生管理系统(存储,排序,输出) 163_冒泡排序 162_结构体10_结构体变量的运算 161指针优点大总结【重点】 160_结构体9_应该发送内容还是应该发送地址【重点】 159_结构体8_通过函数完成对...
  • 本书在对Excel技术论坛上上百万个提问的分析与提炼的基础上,汇集了用户在使用Excel进行数据处理与分析过程中最常见的需求,通过270多个实例的演示与讲解,将Excel高手的过人技巧手把手教读者,并帮助读者发挥...
  • 备注:803和408的考纲相差不大,803相较于408更注重考查学生的基础,从近几年的考试情况看803难度低于408. 2.1 大纲 2016年803考试大纲 2017年803考试大纲 2018年803考试大纲 2019年803考试大纲 2.2 803/408参考...
  • MySQL网络数据库指南

    2009-03-20 16:03:32
    8.3.1 输入学生分数 263 8.3.2 美国总统测验 269 8.3.3 历史同盟联机成员项的编辑 271 第三部分 MySQL 管理 第9章 MySQL 管理介绍 277 9.1 管理职责概述 277 9.2 常规管理 278 9.3 安全性 279 9.4 数据库修复和维护 ...
  • MYSQL网络数据库PDF学习资源

    热门讨论 2009-08-09 19:56:31
    8.3.1 输入学生分数 263 8.3.2 美国总统测验 269 8.3.3 历史同盟联机成员项的编辑 271 第三部分 MySQL 管理 第9章 MySQL 管理介绍 277 9.1 管理职责概述 277 9.2 常规管理 278 9.3 安全性 279 9.4 数据库修复和维护 ...
  • 8.3.1 输入学生分数 263 8.3.2 美国???统测验 269 8.3.3 历史同盟联机成员项的编辑 271 第三部分 MySQL 管理 第9章 MySQL 管理介绍 277 9.1 管理职责概述 277 9.2 常规管理 278 9.3 安全性 279 9.4 数据库...
  • 列表常用操作 - 连接 / 复制(复制元素和复制数组) / 长度 / 排序 / 倒转 / 查找 生成列表 - 使用range创建数字列表 / 生成表达式 / 生成器 元组的使用 - 定义元组 / 使用元组中的值 / 修改元组变量 / 元组和列表转换...
  • 在C++中,有两种出注释的方法:一种是延用C语言方法,使用"/*"和"*/"括起注释文字。另一种方法是使用"//",从"//"开始,直到它所在行的行尾,所有字符都被作为注释处理。 2-8 什么叫做表达式?x = 5 + 7是一个...

空空如也

空空如也

1 2
收藏数 32
精华内容 12
关键字:

如何给学生分数排序