数组排序的实现：自然升序排序，自然降序排序，数组倒置，随机排序

一.自然升序排序

Java语言提供给我们Array.sort(int [] arr)对数组进行升序排列，代码如下：

package song;
 
import java.util.Arrays;
 
 public class Testexample {
    public static void main(String[] args) {
         int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};        
         Arrays.sort(a);
         for(int arr:a) {
              System.out.print(arr + " ");
                 }
      }
  }
  

 

 二 自然降序排序

但是如果我们想要进行降序排序呢?Java提供了很灵活的自定义的方法：

 

利用Collections.reverseOrder()方法：

package song;
 
import java.util.Arrays;
import java.util.Collections;
 
public class Testexample {
    	   public static void main(String[] args) {
    		           int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
    		           Arrays.sort(a,Collections.reverseOrder());
    		           for(int arr:a) {
    		               System.out.print(arr + " ");
    		           }
    		       }
    		   }

　　

实现Comparator接口的复写compare()方法，代码如下:

package song;
 
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
 
public class Testexample {
    	   public static void main(String[] args) {
    		           /*注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）
    		           而要使用它们对应的类*/
    		           Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
    		           //定义一个自定义类MyComparator的对象
    		           Comparator cmp = new MyComparator();
    		           Arrays.sort(a,cmp);
    		           for(int arr:a) {
    		               System.out.print(arr + " ");
    		           }
    		       }
    		   }
    		   //实现Comparator接口
    		   class MyComparator implements Comparator<Integer>{
    		      @Override
    		       public int compare(Integer o1, Integer o2) {
    		        /*如果o1小于o2，我们就返回正值，如果o1大于o2我们就返回负值，
    		         这样颠倒一下，就可以实现降序排序了,反之即可自定义升序排序了*/
    		       return o2-o1;    
       }
    	

　　

三.随机排序

有时我们需要随机的排列数组中的元素，随机排列数组，目前常用的有两种方法，第一种就是元素A[i]对应一个优先级P[i],根据优先级作为键值来从新排序数组;第二种方法就是A[i]随机的跟A[i]到A[n]中的任意个元素进行交换,n为数组的长度,下面是用java实现一个简单实现.

import java.util.Date;
import java.util.Random;
/*
 * 随即排列数组，给定一个数组，随即排列其中的元素，目前主要有两种方法
 */
public class RandomSort {
    
    public static void main(String args[]){
        int data[]=new int[]{1,42,51,62,8,94,23,13,40,5};
        //int p[]=getRandom(1,-8,100);
        //show(p);
        show(data);
        permuteBySort(data);
        show(data);
        randomizeInPlace(data);
        show(data);
    }
    
    /*
     * 随机排列数组,使用优先级方式,每个数组元素A[i] 对应一个优先级P[i]，
     * 然后依据优先级对数组进行排序
     */
    private static void permuteBySort(int[] data)
    {
        int len=data.length;
        int len3=len*len*len;
        int P[]=getRandom(1,len3,len);
        
        //冒泡排序
        for(int i=len-1; i>0; i--)
        {
            for(int j=0; j<i ; j++)
            {
                if(P[j]>P[j+1])
                {
                    int temp=data[j];
                    data[j]=data[j+1];
                    data[j+1]=temp;
                    
                    temp=P[j];
                    P[j]=P[j+1];
                    P[j+1]=temp;                    
                }
            }
        }
    }
    /*
     * 元素A[i]是从 元素A[i]到A[n]中随机选取的
     */
    private static void randomizeInPlace(int[] data)
    {
        Date dt=new Date();
        Random random=new Random(dt.getSeconds());
        int len=data.length;
        for(int i=0; i<len; i++)
        {
            int pos=(int)(random.nextDouble()*(len-i+1)+i)-1;
            int temp=data[i];
            data[i]=data[pos];
            data[pos]=temp;
        }
    }
    
    /*
     * 获得在a到b之间的n个随机数
     */
    private static int[] getRandom(int a,int b,int n)
    {
        if(a>b)
        {
            int temp=a;
            a=b;
            b=temp;
        }
        
        Date dt=new Date();
        Random random=new Random(dt.getSeconds());
        int res[]=new int[n];
        for(int i=0; i<n; i++)
        {
                res[i]=(int)(random.nextDouble()*(Math.abs(b-a)+1))+a;
        }
        return res;
    }
    
    
    private static void show(int[] data)
    {
        System.out.println("========================");
        for(int i = 0; i < data.length; i++)
        {
            System.out.print(data[i] + "    ");
        }
        System.out.println();
        System.out.println("========================");
    }
}

 　　

四.数组倒序实例：

public class Test2 {
    public static void main(String[] args){
        int[] test= {1,2,4,5,7};
        for (int i : test) {
            System.out.print(i+" ");
        }
        System.out.println("\n");
        test = Test2.reverse(test);
        for (int i : test) {
            System.out.print(i+" ");
        }
    }
    public static int[] reverse(int[] arr){
        int[] result = new int[arr.length];
　　　　　//new一个堆来装一个数组
for (int i = 0,j=result.length-1; i < arr.length; i++,j--) {
           result[j] = arr[i];
 }
　　　　//遍历数组里的每个数据，并对数据进行倒序
           return result; } 
}

 

转载于:https://www.cnblogs.com/songhuiqiang/p/10631262.html