Java基础教程04

数组排序方法的实现

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

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

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

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

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

1：自然升序排序

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

以上就是java中的四种排序方法。不同的方法效率不一样，下面是不同的算法的比较和数据交换时的大O表示。

冒泡排序：比较O(N2)　数据交换O(N2)

选择排序：比较O(N2)　数据交换O(N)

插入排序：比较O(N2)　复制数据O(N)

在实际应用中，我们要尽量选择效率高的算法。

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);
   }
}

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

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

2. 反转后排序: [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("\n");
		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]+" ");
		}
	}
}