精华内容
下载资源
问答
  • 对数组元素进行排序

    2019-06-12 13:00:00
     就是将数组从第一个元素开始,依次与后面的元素进行比较,再将比较的最值替换。 1 public class Demo{ 2 public static void main(String[] args) { 3 int[] arry= {15,2,0,6,-3,49}; 4 printArray(arry...

    1、选择排序

      就是将数组从第一个元素开始,依次与后面的元素进行比较,再将比较的最值替换。

     1 public class Demo{
     2     public static void main(String[] args) {
     3         int[] arry= {15,2,0,6,-3,49};
     4         printArray(arry);
     5         selectSort(arry);
     6         printArray(arry);
     7     }
     8     
     9     //打印数组
    10     public static void printArray(int[] arr) {
    11         System.out.print("[");
    12         for(int x=0;x<arr.length;x++) {
    13             if(x!=arr.length-1)
    14                 System.out.print(arr[x]+",");
    15             else
    16                 System.out.println(arr[x]+"]");
    17         }
    18     }
    19     //对数组进行选择排序(从小到大)
    20     public static void selectSort(int[] arr) {
    21         for(int x=0;x<arr.length-1;x++) {
    22             for(int y=x+1;y<arr.length;y++) {
    23                 if(arr[x]>arr[y]) {
    24                     int temp=arr[x];
    25                     arr[x]=arr[y];
    26                     arr[y]=temp;
    27                 }
    28             }
    29         }
    30     }
    31     
    32 }

     2、冒泡排序:

      基础太差,智商跟不上,昨天看着代码想了半天^_^

     1 public class Demo
     2 {
     3     public static void main(String[] args)
     4     {
     5         int[] arr= {12,6,0,-9,66,35};
     6         int[] arr1= {222,55,-9,0,103};
     7         mSort1(arr);
     8         mSort2(arr1);
     9         printArry(arr);
    10         System.out.println();
    11         printArry(arr1);
    12     }
    13     public static void printArry(int[] arr) 
    14     {
    15         for(int i=0;i<arr.length;i++)
    16         {
    17             System.out.print(arr[i]+" ");
    18         }
    19     }
    20     //冒泡排序 有两种写法,都是从小到大排序
    21     public static void mSort1(int[] arr) 
    22     {
    23         for(int x=0;x<arr.length-1;x++) 
    24         {
    25             for(int y=0;y<arr.length-1-x;y++) 
    26             {
    27                 if(arr[y]>arr[y+1])
    28                 {
    29                     int temp=arr[y];
    30                     arr[y]=arr[y+1];
    31                     arr[y+1]=temp;
    32                 }
    33             }
    34         }
    35     }
    36     public static void mSort2(int[] arr) 
    37     {
    38         for(int x=arr.length-1;x>0;x--) 
    39         {
    40             for(int y=0;y<x;y++) 
    41             {
    42                 if(arr[y]>arr[y+1]) 
    43                 {
    44                     int temp=arr[y];
    45                     arr[y]=arr[y+1];
    46                     arr[y+1]=temp;
    47                 }
    48             }
    49         }
    50     }
    51 }

     

     1 public class Demo
     2 {
     3     public static void main(String[] args)
     4     {
     5         int[] arr= {12,6,0,-9,66,35};
     6         int[] arr1= {222,55,-9,0,103};
     7         mSort1(arr);
     8         mSort2(arr1);
     9         printArry(arr);
    10         System.out.println();
    11         printArry(arr1);
    12     }
    13     public static void printArry(int[] arr) 
    14     {
    15         for(int i=0;i<arr.length;i++)
    16         {
    17             System.out.print(arr[i]+" ");
    18         }
    19     }
    20     //交换数组中数值的函数
    21     public static void swapArray(int[] arr,int a,int b) //想要改变数组中的值,必须将数组作为参数传过来
    22     {
    23         int temp=arr[a];
    24         arr[a]=arr[b];
    25         arr[b]=temp;
    26     }
    27     //冒泡排序 有两种写法,都是从小到大排序
    28     public static void mSort1(int[] arr) 
    29     {
    30         for(int x=0;x<arr.length-1;x++) 
    31         {
    32             for(int y=0;y<arr.length-1-x;y++) 
    33             {
    34                 if(arr[y]>arr[y+1])
    35                 {
    36                     swapArray(arr,y,y+1);
    37                     /*
    38                     int temp=arr[y];
    39                     arr[y]=arr[y+1];
    40                     arr[y+1]=temp;
    41                     */
    42                 }
    43             }
    44         }
    45     }
    46     public static void mSort2(int[] arr) 
    47     {
    48         for(int x=arr.length-1;x>0;x--) 
    49         {
    50             for(int y=0;y<x;y++) 
    51             {
    52                 if(arr[y]>arr[y+1]) 
    53                 {
    54                     int temp=arr[y];
    55                     arr[y]=arr[y+1];
    56                     arr[y+1]=temp;
    57                 }
    58             }
    59         }
    60     }
    61 }

    上面增加了一个交换数组中函数值的函数。

    转载于:https://www.cnblogs.com/langdao/p/11008967.html

    展开全文
  • 首先,对数组元素进行排序方法总结为以下两类: 一、简单排序算法(时间复杂度O(n*n)) 1.插入排序 2.选择排序 3.交换排序,即冒泡排序 二、先进排序算法(时间复杂度O(n*logn)) 1.快速排序 2.归并...

    首先,对数组元素进行排序方法总结为以下两类:

    一、简单排序算法(时间复杂度O(n*n))

    1.插入排序

    2.选择排序

    3.交换排序,即冒泡排序

     

     二、先进排序算法(时间复杂度O(n*logn))

    1.快速排序

    2.归并排序

    3.堆排序

     

    接下来,分别对其进行讨论:

    1.插入排序

    算法思想:每一步将一个待排序元素按其关键字值的大小插入到已排序序列的适当位置上,直到待排序元素插入完为止。

    算法实现:

    测试结果:

     

    2.选择排序

    算法思想:每次从待排序序列中选择一个关键字最小的元素(当需要按关键字升序排列时),顺序排在已排序序列的最后,直至全部排完。

    算法实现:

     

    测试结果:

     

    3.交换排序(冒泡排序)

    算法思想:两两比较待排序序列中的元素,并交换不满足顺序要求的各对元素,直至全部满足顺序要求为止。

    算法实现:

     

    测试结果:

     

    4.快速排序

    算法思想:

    1:分解,以a[p]为基准元素将a[p:r]划分成3段a[p:q-1],a[q],a[q+1:r],使a[p:q-1]中任何一个元素小于等于a[q],而a[q+1:r]中任何一个元素大于等于a[q]。

    2:递归,通过递归调用快速排序算法分别对a[p:q-1]和a[q+1:r]进行排序

    算法实现:

     

    测试结果:

    转载于:https://www.cnblogs.com/cxmhy/p/4128221.html

    展开全文
  • 在实际开发中,有很多场景需要我们将数组...对数组元素进行排序的方法有很多种,比如冒泡排序、归并排序、选择排序、插入排序、快速排序等,其中最经典最需要掌握的是「冒泡排序」。 以从小到大排序为例,冒泡排序...

    在实际开发中,有很多场景需要我们将数组元素按照从大到小(或者从小到大)的顺序排列,这样在查阅数据时会更加直观,例如:

    • 一个保存了班级学号的数组,排序后更容易分区好学生和坏学生;
    • 一个保存了商品单价的数组,排序后更容易看出它们的性价比。


    对数组元素进行排序的方法有很多种,比如冒泡排序、归并排序、选择排序、插入排序、快速排序等,其中最经典最需要掌握的是「冒泡排序」。

    以从小到大排序为例,冒泡排序的整体思想是这样的:

    • 从数组头部开始,不断比较相邻的两个元素的大小,让较大的元素逐渐往后移动(交换两个元素的值),直到数组的末尾。经过第一轮的比较,就可以找到最大的元素,并将它移动到最后一个位置。
    • 第一轮结束后,继续第二轮。仍然从数组头部开始比较,让较大的元素逐渐往后移动,直到数组的倒数第二个元素为止。经过第二轮的比较,就可以找到次大的元素,并将它放到倒数第二个位置。
    • 以此类推,进行 n-1(n 为数组长度)轮“冒泡”后,就可以将所有的元素都排列好。


    整个排序过程就好像气泡不断从水里冒出来,最大的先出来,次大的第二出来,最小的最后出来,所以将这种排序方式称为冒泡排序(Bubble Sort)。

    下面我们以“3  2  4  1”为例对冒泡排序进行说明。

    第一轮  排序过程
    3  2  4  1    (最初)
    2  3  4  1    (比较3和2,交换)
    2  3  4  1    (比较3和4,不交换)
    2  3  1  4    (比较4和1,交换)
    第一轮结束,最大的数字 4 已经在最后面,因此第二轮排序只需要对前面三个数进行比较。

    第二轮  排序过程
    2  3  1  4 (第一轮排序结果)
    2  3  1  4 (比较2和3,不交换)
    2  1  3  4 (比较3和1,交换)
    第二轮结束,次大的数字 3 已经排在倒数第二个位置,所以第三轮只需要比较前两个元素。

    第三轮  排序过程
    2  1  3  4  (第二轮排序结果)
    1  2  3  4  (比较2和1,交换)

    至此,排序结束。

    算法总结及实现

    对拥有 n 个元素的数组 R[n] 进行 n-1 轮比较。

    第一轮,逐个比较 (R[1], R[2]),  (R[2], R[3]),  (R[3], R[4]),  …….  (R[N-1], R[N]),最大的元素被移动到 R[n] 上。

    第二轮,逐个比较 (R[1], R[2]),  (R[2], R[3]),  (R[3], R[4]),  …….  (R[N-2], R[N-1]),次大的元素被移动到 R[n-1] 上。
    。。。。。。
    以此类推,直到整个数组从小到大排序。

    具体的代码实现如下所示:

    #include <stdio.h>
    int main(){
        int nums[10] = {4, 5, 2, 10, 7, 1, 8, 3, 6, 9};
        int i, j, temp;
    
        //冒泡排序算法:进行 n-1 轮比较
        for(i=0; i<10-1; i++){
            //每一轮比较前 n-1-i 个,也就是说,已经排序好的最后 i 个不用比较
            for(j=0; j<10-1-i; j++){
                if(nums[j] > nums[j+1]){
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
       
        //输出排序后的数组
        for(i=0; i<10; i++){
            printf("%d ", nums[i]);
        }
        printf("\n");
       
        return 0;
    }

    运行结果:
    1 2 3 4 5 6 7 8 9 10

     

    展开全文
  • 对数组元素进行排序的方法有很多种,比如冒泡排序、归并排序、选择排序、插入排序、快速排序等,其中最经典最需要掌握的是「冒泡排序」。 以从小到大排序为例,冒泡排序的整体思想是这样的: 从数组头部开始,不断...

    一、冒泡排序

    在实际开发中,有很多场景需要我们将数组元素按照从大到小(或者从小到大)的顺序排列,这样在查阅数据时会更加直观,例如:

    • 一个保存了班级学号的数组,排序后更容易分区好学生和坏学生;
    • 一个保存了商品单价的数组,排序后更容易看出它们的性价比。

    对数组元素进行排序的方法有很多种,比如冒泡排序、归并排序、选择排序、插入排序、快速排序等,其中最经典最需要掌握的是「冒泡排序」

    以从小到大排序为例,冒泡排序的整体思想是这样的:

    • 从数组头部开始,不断比较相邻的两个元素的大小,让较大的元素逐渐往后移动(交换两个元素的值),直到数组的末尾。经过第一轮的比较,就可以找到最大的元素,并将它移动到最后一个位置。
    • 第一轮结束后,继续第二轮。仍然从数组头部开始比较,让较大的元素逐渐往后移动,直到数组的倒数第二个元素为止。经过第二轮的比较,就可以找到次大的元素,并将它放到倒数第二个位置。
    • 以此类推,进行 n-1(n 为数组长度)轮“冒泡”后,就可以将所有的元素都排列好。


    整个排序过程就好像气泡不断从水里冒出来,最大的先出来,次大的第二出来,最小的最后出来,所以将这种排序方式称为冒泡排序(Bubble Sort)。

    下面我们以“3  2  4  1”为例对冒泡排序进行说明。

    第一轮  排序过程
    3  2  4  1    (最初)
    2  3  4  1    (比较3和2,交换)
    2  3  4  1    (比较3和4,不交换)
    2  3  1  4    (比较4和1,交换)
    第一轮结束,最大的数字 4 已经在最后面,因此第二轮排序只需要对前面三个数进行比较。

    第二轮  排序过程
    2  3  1  4 (第一轮排序结果)
    2  3  1  4 (比较2和3,不交换)
    2  1  3  4 (比较3和1,交换)
    第二轮结束,次大的数字 3 已经排在倒数第二个位置,所以第三轮只需要比较前两个元素。

    第三轮  排序过程
    2  1  3  4  (第二轮排序结果)
    1  2  3  4  (比较2和1,交换)


    至此,排序结束。


    二、算法总结及实现

    对拥有 n 个元素的数组 R[n] 进行 n-1 轮比较。

    第一轮,逐个比较 (R[1], R[2]),  (R[2], R[3]),  (R[3], R[4]),  …….  (R[N-1], R[N]),最大的元素被移动到 R[n] 上。

    第二轮,逐个比较 (R[1], R[2]),  (R[2], R[3]),  (R[3], R[4]),  …….  (R[N-2], R[N-1]),次大的元素被移动到 R[n-1] 上。
    。。。。。。
    以此类推,直到整个数组从小到大排序。


    具体的代码实现如下所示:

    #include <stdio.h>
    
    int main()
    {
        int nums[10] = {4, 5, 2, 10, 7, 1, 8, 3, 6, 9};
        int i, j, temp;
    
        //冒泡排序算法:进行 n-1 轮比较
        for(i=0; i<10-1; i++){
            //每一轮比较前 n-1-i 个,也就是说,已经排序好的最后 i 个不用比较
            for(j=0; j<10-1-i; j++){
                if(nums[j] > nums[j+1]){
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
       
        //输出排序后的数组
        for(i=0; i<10; i++){
            printf("%d ", nums[i]);
        }
        printf("\n");
       
        return 0;
    }

    运行结果:

    1 2 3 4 5 6 7 8 9 10

    三、优化算法

    上面的算法是大部分教材中提供的算法,其中有一点是可以优化的:当比较到第 i 轮的时候,如果剩下的元素已经排序好了,那么就不用再继续比较了,跳出循环即可,这样就减少了比较的次数,提高了执行效率。

    未经优化的算法一定会进行 n-1 轮比较,经过优化的算法最多进行 n-1 轮比较,高下立判。

    优化后的算法实现如下所示:

    #include <stdio.h>
    
    int main()
    {
        int nums[10] = {4, 5, 2, 10, 7, 1, 8, 3, 6, 9};
        int i, j, temp, isSorted;
       
        //优化算法:最多进行 n-1 轮比较
        for(i=0; i<10-1; i++){
            isSorted = 1;  //假设剩下的元素已经排序好
            for(j=0; j<10-1-i; j++){
                if(nums[j] > nums[j+1]){
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                    isSorted = 0;  //一旦需要交换数组元素,就说明剩下的元素没有排序好
                }
            }
            if(isSorted) break; //如果没有发生交换,说明剩下的元素已经排序好
        }
    
        for(i=0; i<10; i++){
            printf("%d ", nums[i]);
        }
        printf("\n");
       
        return 0;
    }

    在此额外设置一个变量 isSorted,用它作为标志,值为“真”表示剩下的元素已经排序好了,值为“假”表示剩下的元素还未排序好。

    每一轮比较之前,我们预先假设剩下的元素已经排序好了,并将 isSorted 设置为“真”,一旦在比较过程中需要交换元素,就说明假设是错的,剩下的元素没有排序好,于是将 isSorted 的值更改为“假”。

    每一轮循环结束后,通过检测 isSorted 的值就知道剩下的元素是否排序好。

    展开全文
  • /* * Quiz2 * * 实现冒泡算法,对数组元素进行排序 * * 2008年12月13日 * * (Cason_xu) */import java.util.Scanner;class Quiz2 { public static void main(String[] args){ 
  • 有个问题想请教大家: m=[1,4,7,10,2,5,6,3,9,8,15,12,13,11,18,17,16...m列表中的元素为n列表中的节点号,我想将m列表中的元素按照其对应的Z向坐标值的大小,从小到大进行重新排序,请问大家这个如何实现,非常感谢!
  • JDK提供的java.util.Arrays类包含了常用的数组操作,可以实现数组元素排序、查找、填充、打印等常见操作。 实例: import java.util.Arrays; public class Test { public static void main (String args[]) { ...
  • sort() 方法用于对数组元素进行排序。 注意:数组在原数组上进行排序,不生成副本。即修改原数组 arr.sort(sortNumber); 说明 如果调用该方法时没有使用参数,将按字母顺序对数组中的元素进行排序,说得更精确点...
  • 一个程序,以降序对数组元素进行排序 在此程序中,我们需要按降序对给定数组进行排序,以便将元素从大到小排列。 这可以通过两个循环来实现。 外循环将选择一个元素,而内循环则允许我们将所选元素与其余元素进行...
  • 我正在尝试按升序对数组进行排序.由于某种原因,它仅执行一次for循环.为什么直到一切都整理好之后它才继续前进?它用于分配作业,因此不允许使用现有的排序方法.我应该自己写方法.public class Sudoku {public static ...
  • sort() 方法用于对数组元素进行排序。 排序顺序可以是字母或数字,并按升序或降序。 默认排序顺序为按字母升序。 注意:当数字是按字母顺序排列时"40"将排在"5"前面。 使用数字排序,你必须通过一个函数作为...
  • 在本篇文章里小编给大家整理是一篇关于javascript sort()对数组中的元素进行排序的相关知识点内容,需要的朋友们学习下。
  • sort() 方法用于对数组元素进行排序。 如果调用该方法时没有使用参数,将按字母顺序对数组中的元素进行排序,说得更精确点,是按照字符编码的顺序进行排序。要实现这一点, 首先应把数组的元素都转换成字符串...
  • sort() 方法用于对数组元素进行排序。 语法:arrayObject.sort(sortby) 返回值:对数组的引用。请注意,数组在原数组上进行排序,不生成副本。 如果调用该方法时没有使用参数,将按字母顺序对数组中的元素进行...
  • java:对数组中的元素进行排序

    千次阅读 2019-11-25 15:15:11
    对数组中的元素进行排序相关说明源码运行结果 相关说明 对数组进行排序 import java.util.Arrays; Arrays.sort(这里放数组); sort(将···排序) 对整数型从小到大排序 对字符串类型:字典的编排顺序(数字>...
  • <p>This question already has an answer here: ...<p>I want to sort the elements in the array, descending by the total number of characters of an element ...<p>Please help me to descend the ...
  • 用函数对数组元素进行升序排序 //使用冒泡法进行排序
  • 对数组里的元素进行排序 foreach($infoas$key=>$value) { sort($info[$key][ccnum],SORT_NUMERIC); print_r($info[$key]['ccnum']); } 数组$info是多维数组,主要排序函数是sort函数 sort(array,...
  • 冒泡排序 适合新手,简单易懂,废话不多说,直接上JAVA代码: 首先定义数组,定义两层循环 int arr[] = new int[]{“这里填需要排序的数”}; //对34,5,22,-98,6,-76,0,-3这一...//内层循环读取数组的元素进行比较 for
  • sort()方法用于对数组元素进行排序。 语法:arrayObject.sort(sortby) 返回值:对数组的运用,请注意,数组在原数组上进行排序,不生成副本。 说明:如果调用该方法没有使用参数,按照字母顺序对数组中的元素进行...
  • JavaScript Array sort 方法Array 对象的 sort 方法用于对数组元素进行排序。语法如下:array_object.sort( sortby )参数说明:参数说明array_object要操作的数组(对象)sortby可选。规定排序顺序的函数。注意:sort...
  • 对数组进行冒泡排序

    2021-05-09 10:45:50
    冒泡排序思想: 每两个元素之间进行比较大小,如果前面的元素比后面的元素大则进行交换,这样的话每一轮冒泡排序的结果中最后的哪个元素是整个数组中最大的值,就像水里较大的气泡先冒出来一样,因此得名。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,598
精华内容 1,039
关键字:

对数组元素进行排序