数组排序

数组排序方法的实现

JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。

快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。

冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。 

选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。

插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。

<1>利用Arrays带有的排序方法快速排序

import java.util.Arrays;
  public class Test2{
          public static void main(String[] args){
                int[] a={5,4,2,4,9,1};
                  Arrays.sort(a);  //进行排序
                  for(int i: a){
                          System.out.print(i);
                 }
          }
 }

<2>冒泡排序算法

public static int[] bubbleSort(int[] args){//冒泡排序算法
                  for(int i=0;i<args.length-1;i++){
                          for(int j=i+1;j<args.length;j++){
                                  if (args[i]>args[j]){
                                          int temp=args[i];
                                          args[i]=args[j];
                                          args[j]=temp;
                                  }
                         }
                 }
                 return args;
         }

<3>选择排序算法

public static int[] selectSort(int[] args){//选择排序算法
                  for (int i=0;i<args.length-1 ;i++ ){
                          int min=i;
                          for (int j=i+1;j<args.length ;j++ ){
                                  if (args[min]>args[j]){
                                          min=j;
                                  }
                          }
                          if (min!=i){
                         int temp=args[i];
                         args[i]=args[min];
                         args[min]=temp;        
                         }
                 }
                 return args;
         }

<4>插入排序算法

public static int[] insertSort(int[] args){//插入排序算法
                  for(int i=1;i<args.length;i++){
                          for(int j=i;j>0;j--){
                                  if (args[j]<args[j-1]){
                                          int temp=args[j-1];
                                          args[j-1]=args[j];
                                          args[j]=temp;        
                                  }else break;
                          }
                 }
                 return args;
         }

1.自然升序排序

package peng;
 
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 + " ");
                 }
      }
  }

2.自然降序排序

利用Collections.reverseOrder()方法：倒叙排列，数组倒置。

package peng;
 
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 peng;
 
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;    
       }
        
  }

3：数组倒置

【方法一】使用集合个工具类： Collections.reverse(ArrayList) 将数组进行反转：

import java.util.ArrayList;import java.util.Collections;
public class Main {
   public static void main(String[] args) {
      ArrayList arrayList = new ArrayList();
      arrayList.add("A");
      arrayList.add("B");
      arrayList.add("C");
      arrayList.add("D");
      arrayList.add("E");
      System.out.println("反转前排序: " + arrayList);
      Collections.reverse(arrayList);
      System.out.println("反转后排序: " + arrayList);
   }
}

以上代码运行输出结果为：

反转前排序: [A, B, C, D, E]

反转后排序: [E, D, C, B, A]

　　

【方法二】使用集合ArrayList实现反转：

 

【方法三】直接使用数组实现反转，即，反转后数组的第一个元素等于源数组的最后一个元素：

方法二和方法三的实现代码如下：

package javatest2;
 
import java.util.ArrayList;
 
public class JavaTest2 {
 
    public static void main(String[] args) {
        String[] Array = { "a", "b", "c", "d", "e" };
        reverseArray1(Array);// 使用集合ArrayList实现反转
        for (int j = 0; j < Array.length; j++) {
            System.out.print(Array[j] + " ");
        }
 
        System.out.print("
");
        String[] temp = reverseArray2(Array);// 直接使用数组实现反转
        for (int j = 0; j < temp.length; j++) {
            System.out.print(Array[j] + " ");
        }
 
    }
 

/*
     * 函数：reverseArray1和reverseArray2 
     * 功能：实现 数组翻转
     * 例如：{'a','b','c','d'}变成{'d','c','b','a'}
     */
    private static void reverseArray1(String[] Array) {
        ArrayList<String> array_list = new ArrayList<String>();
        for (int i = 0; i < Array.length; i++) {
            array_list.add(Array[Array.length - i - 1]);
        }
        Array = array_list.toArray(Array);
    }

private static String[] reverseArray2(String[] Array) {
        String[] new_array = new String[Array.length];
        for (int i = 0; i < Array.length; i++) {
            // 反转后数组的第一个元素等于源数组的最后一个元素：
            new_array[i] = Array[Array.length - i - 1];
        }
        return new_array;
    }
 
}

4：随机排序

1：Java List容器内元素的顺序重新随机排序、洗牌排序

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
 
public class ListShuffle {
    public static void main(String[] args) {
        //假设，list容器中装了一副扑克牌的元素
        String[] strArray = new String[] { "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3", "2" };
        List<String> list = Arrays.asList(strArray);
        System.out.println("List容器中扑克牌元素的排列顺序：" + list);
 
        //打乱List容器的元素排列顺序
        Collections.shuffle(list);
        System.out.println("Shuffle（洗牌、打乱）后List容器中元素的排列顺序：" + list);
 
        //再次打乱List容器的元素排列顺序
        Collections.shuffle(list);
        System.out.println("再次Shuffle（洗牌、打乱）后List容器中元素的排列顺序：" + list);
 
        //再次打乱List容器的元素排列顺序
        Collections.shuffle(list);
        System.out.println("再次Shuffle（洗牌、打乱）后List容器中元素的排列顺序：" + list);
    }
}

执行结果：

List容器中扑克牌元素的排列顺序：[A, K, Q, J, 10, 9, 8, 7, 6, 5, 4, 3, 2]
Shuffle（洗牌、打乱）后List容器中元素的排列顺序：[K, 10, 4, 3, 8, 7, A, J, 9, 6, Q, 5, 2]
再次Shuffle（洗牌、打乱）后List容器中元素的排列顺序：[10, 5, A, K, J, 4, 2, 3, 6, 7, 8, Q, 9]
再次Shuffle（洗牌、打乱）后List容器中元素的排列顺序：[5, 9, 10, 8, A, J, 7, K, 6, Q, 4, 3, 2]

　　

2：数字数组随机生产

public class RandomSortTest {
    private int[]arr = {1,2,3,4,5,6,7,8};
    private static final int SIZE = 8;
    Random random = new Random();
    @Test
    //重新排列
    public void sort(){
        printArr();
        for(int i=0;i<SIZE;i++){
            int p = random.nextInt(i+1);
            System.out.println("i==="+i+"p==="+p);
            int tmp = arr[i];
            arr[i] = arr[p];
            arr[p] = tmp;
        }
        printArr();
        //1 2 4 8 5 3 7 6 
        //4 1 8 7 2 6 5 3 
        //1 8 2 3 5 4 6 7 
        //5 7 8 3 4 2 6 1
    }

@Test
	//打印
	public void printArr(){
		for(int i=0;i<SIZE;i++){
			System.out.print(arr[i]+" ");
		}
	}
}