精华内容
下载资源
问答
  • java数组排序

    2017-09-04 11:39:37
    java数组排序的思想,过程和代码实现。多种数组排序的方法,主要有冒泡排序,堆排序,插入排序, 归并操作(merge), 归并操作(merge),选择排序,希尔排序。
  • Java数组排序

    2019-04-15 20:45:37
    Java数组排序:Java sort()方法 Arrays.sort(scores); Java数组排序:Java冒泡排序(Bubble Sort)法 System.out.println("通过冒泡排序方法对数组进行排序:"); for(int i=0;i<score.length-1;i++) { //...

    Java数组排序:Java sort()方法

    Arrays.sort(scores);

    Java数组排序:Java冒泡排序(Bubble Sort)法

    System.out.println("通过冒泡排序方法对数组进行排序:");
    for(int i=0;i<score.length-1;i++)
    {
        //比较相邻两个元素,较大的数往后冒泡
        for (int j=0;j<score.length-1-i;j++)
        {
            if(score[j]>score[j+1])
            {
                double temp=score[j+1];    //把第一个元素值保存到临时变量中
                score[j+1]=score[j];    //把第二个元素值转移到第一个元素变量中
                score[j]=temp;    //把临时变量(第一个元素的原值)保存到第二个元素中
            }
            System.out.print(score[j]+ " ");    //对排序后的数组元素进行输出
        }
    }

    Java数组排序:Java快速排序(Quicksort)法

    (1) 声明静态的 getMiddle() 方法,该方法需要返回一个 int 类型的参数值,在该方法中传入 3 个参数。代码如下:

    public static int getMiddle(int[] list,int low,int high)
    {
        int tmp=list[low];    //数组的第一个值作为中轴(分界点或关键数据)
        while(low<high)
        {
            while(low<high&&list[high]>tmp)
            {
                high--;
            }
            list[low]=list[high];    //比中轴小的记录移到低端
            while(low<high&&list[low]<tmp)
            {
                low++;
            }
            list[high]=list[low];    //比中轴大的记录移到高端
        }
        list[low]=tmp;    //中轴记录到尾
        return low;    //返回中轴的位置
    }

    (2) 创建静态的 unckSort() 方法,在该方法中判断 low 参数是否小于 high 参数,如果是则调用 getMiddle() 方法,将数组一分为二,并且调用自身的方法进行递归排序。代码如下:

    public static void unckSort(int[] list,int low,int high)
    {
        if(low<high)
        {
            int middle=getMiddle(list,low,high);    //将list数组一分为二
            unckSort(list,low,middle-1);    //对低字表进行递归排序
            unckSort(list,middle+1,high);    //对高字表进行递归排序
        }
    }

    (3) 声明静态的 quick() 方法,在该方法中判断传入的数组是否为空,如果不为空,则调用 unckSort() 方法进行排序。代码如下:

    public static void quick(int[] str)
    {
        if(str.length>0)
        {
            //查看数组是否为空
            unckSort(str,0,str.length-1);
        }
    }

    Java数组排序:Java选择排序法

    for(int i=1;i<number.length;i++)
    {
        index=0;
        for(int j=1;j<=number.length-i;j++)
        {
            if(number[j]>number[index])
            {
                index=j;    //查找最大值
            }
        }
        end=number[index]+" "+end;    //定位已排好的数组元素
        int temp=number[number.length-i];
        number[number.length-1]=number[index];
        number[index]=temp;
        System.out.print("【");
        for(int j=0;j<number.length-i;j++)
        {
            System.out.print(number[j]+" ");
        }
        System.out.print("】"+end);
    }

    Java数组排序:Java直接插入法

     

    public static void main(String[] args)
    {
        int[] number={13,15,24,99,4,1};
        System.out.println("排序前:");
        for(int val:number)
        {    //遍历数组元素
            System.out.print(val+" ");    //输出数组元素
        }
        int temp,j;
        for(int i=1;i<number.length;i++)
        {
            temp=number[i];
            for(j=i-1;j>=0&&number[j]>temp;j--)
            {
                number[j+1]=number[j];
            }
            number[j+1]=temp;
        }
        System.out.println("\n排序后:");
        for(int val:number)
        {    //遍历数组元素
            System.out.print(val+" ");    //输出数组元素
        }
    }

     

    展开全文
  • JAVA数组排序

    2011-10-04 19:45:05
    JAVA数组排序经典之一,冒泡法,最基础也最容易理解的一种排序方法
  • 数组,本身是有序的元素序列,本文我们就来看看Java数组排序的几个方法。一、冒泡排序举 个 栗 子:5 2 0 4 1 3 一个容量为七的数组排升序(降序同理,最大值变最小就ok)①从这组数中找那个冒泡的(最大的),把它踢到...

    数组,其实就是一个给定了大小给定了类型的容器,在这容器中有你设定的元素,你可以对这些元素进行各种升降排列,或者找出其中特殊的元素并进行一系列的运算。数组,本身是有序的元素序列,本文我们就来看看Java数组排序的几个方法。

    一、冒泡排序

    举 个 栗 子:5 2 0 4 1 3 一个容量为七的数组排升序(降序同理,最大值变最小就ok)

    ①从这组数中找那个冒泡的(最大的),把它踢到最后 2 0 4 1 3 5

    ②重复上述行为 2 0 1 3 4 5

    ③重复~~ 2 0 1 3 4 5

    ④~~0 1 2 3 4 5

    ⑤~~0 1 2 3 4 5 完成

    Java代码实例:

    dfd7e45036708fb67d699eaa3491c74a.png

    二、选择排序

    还是刚才那个栗子:5 2 0 4 1 3 升序

    ①找到数组中最小的 放到第一个位置 0 5 2 4 1 3

    ②数组中剩下的找到最小的放在第二个位置 0 1 5 2 4 3

    ③ ~~ 0 1 2 5 4 3

    ④~~ 0 1 2 3 5 4

    ⑤~~0 1 2 3 4 5 完成

    Java代码实例:

    74c997fe675a1eea48e9855848859193.png

    三、插入排序

    个人认为就是在摸扑克牌 桌上的牌堆就是你的数组 一张一张的摸到手上,你的数组排序也就完成了。 这次你的牌堆为 5 2 0 4 1 3

    ,依次向手中加牌

    ①摸一张5 5

    ②摸一张2 放5左边 2 5

    ③~~ 0 2 5

    ④~~ 0 2 4 5

    ⑤~~ 0 1 2 4 5

    ⑥~~ 0 1 2 3 4 5

    Java代码实例:

    e9cc7cc493959fc145dbc3812d19fce2.png

    四、希尔排序

    希尔排序其实就是一种间隔交换,这次用个长点的栗子来让大家了解我的意图 一个拥有十个元素的数组

    43 95 38 30 41 72 60 74 24 32

    ①首先

    我以5为间隔。第一个和第六个比较,第二个和第七个比较,第三个和第八个比较......升序不变,降序则置换位置。(比如第一个43和第六个72升序不变换位置,第二个95和第七个60降序置换位置)

    得到置换结果 43 60 38 24 32 72 95 74 30 41

    ②接着我们采用3为间隔,也就是说类似第一个和第五个比较,方法同上。

    4164b8c47e07ee97ae96f90530bd6c92.png

    得到置换结果 24 32 30 41 60 38 43 74 72 95

    ③接着我们采用2为间隔,得到置换结果 :

    24 32 30 38 43 41 60 74 72 95

    ④最后以1为间隔 结果很简单 24 30 32 38 41 43 60 72 74 95

    大家不难发现我取间隔的方式如同下方代码一般,重复 int

    k/2,间隔选取其实并非唯一确定的,针对不同的数组,你们可以根据自己的经验来采用不同方式的间隔,在这里就不啰嗦了。

    Java代码如下

    a4fe38fc41fc46d83e615202da3793e6.png

    现在方案写完了 随机一个拥有十个元素的数组然后打印出排序如下 :

    28e39154784fcd82d1fd27ae391b41dc.png

    希尔排序虽然针对大多数数组排序有较高的效率但是其稳定性却令人堪忧,建议大家写文件时用插入排序,既有效率又算法稳定。

    以上就是为大家介绍的4种Java数组排序方法,在我们处理数组中的数据时能够为我们快速地对数组数据进行排序。当然,在Java中还有其他的排序算法,感兴趣的小伙伴可以观看本站的Java基础教程,学习其他的Java数组排序算法。

    展开全文
  • import java.lang.*;import java.util.*;public class Main {public static void main(String args[]) {int a[] = new int[]{1, 4, 612, 333, -8, 2, -12, 4534, 0};for (int i = 0; i < a.length; i++) { //直接...

    import java.lang.*;

    import java.util.*;

    public class Main {

    public static void main(String args[]) {

    int a[] = new int[]{1, 4, 612, 333, -8, 2, -12, 4534, 0};

    for (int i = 0; i < a.length; i++) { //直接选择排序(两重for循环排序)

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

    if (a[i] > a[j]) {

    int temp = a[j];

    a[j] = a[i];

    a[i] = temp;

    }

    }

    }

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

    System.out.print(a[i] + "\t");

    System.out.println();

    }

    }

    运行结果

    -12 -8 0 1 2 4 333 612 4534

    2. java数组排序sort排序

    Arrays 是java的util包下的数组工具类,其中提供默认的sort排序.

    public class Main {

    public static void main(String args[]) {

    int[] arr = {1, 4, 612, 333, -8, 2, -12, 4534, 0};

    Arrays.sort(arr); //默认从小到大进行sort()排序

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

    System.out.print(arr[i] + "\t");

    System.out.println();

    }

    }

    结果

    -12 -8 0 1 2 4 333 612 4534

    3. javasort降序排序

    可以将升序的数组倒序输出,即可实现降序排序了。

    或者实现一个自己的数组反转方法.

    public class Main {

    public static void main(String args[]) {

    int[] arr = {1, 4, 612, 333, -8, 2, -12, 4534, 0};

    Arrays.sort(arr); //默认从小到大进行sort()排序

    // 逆序输出

    for (int i = arr.length - 1; i >= 0; i--)

    System.out.print(arr[i] + "\t");

    System.out.println();

    }

    }

    结果

    4534 612 333 4 2 1 0 -8 -12

    展开全文
  • Java 数组排序

    2019-06-23 22:14:55
    package day01; import java.util.*; public class Java_2 { public static void main(String[] args) { Student[] java = new Student[3]; //new一个 Student长度为3的数组 ...
    package day01;
    import java.util.*;
    
    public class Java_2
    {  
       public static void main(String[] args)
       {
          Student[] java = new Student[3];                                //new一个 Student长度为3的数组
          java[0] = new Student("李明", 80);                              //将数据存放在对象java中
          java[1] = new Student("赵冬", 75);                           
          java[2] = new Student("王晓", 98);
          Arrays.sort(java);                                             //调用系统类Arrays.sort对数组java进行排序
          System.out.println("Java 成绩降序排序的结果是:");
          for (int i = 0; i < java.length; i++)
          {
             Student e = java[i];                                        //将排序结果存在e中
             System.out.println("name=" + e.getName()                    //调用方法进行输出
                + ",fenshu=" + e.getFenshu());
          }
       }
    }
    
    class Student implements Comparable                                  //Student 实现接口 Comparable
    {
       public Student(String n, double f)
       {
          name = n;
          fenshu = f;
       }
       public String getName()
       {
          return name;
       }
       public double getFenshu()
       {
          return fenshu;
       }
       public int compareTo(Object otherObject)
       {
          Student other = (Student)otherObject;
          if (fenshu < other.fenshu) return 1;
          if (fenshu > other.fenshu) return -1;
          return 0;
       }
       private String name;
       private double fenshu;
    }
    

    运行结果如下:

    在这里插入图片描述

    总结:

    1. Arrays.sort(java);对数组进行排序。
    2. implements 实现接口,当类实现接口的时候,类要实现接口中所有的方法。否则,类必须声明为抽象的类。
    展开全文
  • java 数组排序

    2013-07-08 16:55:17
    JAVA中在运用数组进行排序功能时,一般有四种方法:快速排序法、冒泡法、选择排序法、插入排序法。 快速排序法主要是运用了Arrays中的一个方法Arrays.sort()实现。 冒泡法是运用遍历数组进行比较,通过不断的比较...
  • import java.lang.reflect.Array;import java.util.Arrays;import java.util.Collections;import java.util.HashSet;...public class SortQuchong {//对一个int数组进行排序,去重public static void main...
  • Java数组排序-选择排序

    千次阅读 2017-07-28 15:37:29
    Java数组排序-选择排序
  • Java数组排序-插入排序

    千次阅读 2017-07-28 16:13:57
    Java数组排序-插入排序

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,926
精华内容 11,170
关键字:

java数组排序

java 订阅