JAVA：二叉排序、快速排序、冒泡、选择排序的时间对比

40000个随机数的排序时间结果

先贴结果，快排在数组无序的时候确实挺快的，系统的sort函数在更多随机数下表现会更加出色。

数组准备完毕
系统自带排序用的时间：6
选择排序用的时间：3391
结果是否与系统自带sort相同：true
冒泡排序用的时间：3333
结果是否与系统自带sort相同：true
二叉排序用的时间：37
结果是否与系统自带sort相同：true
快速排序用的时间：4
结果是否与系统自带sort相同：true

二叉排序

private static int[] TreeSort(int[] sortTest) {
		// TODO Auto-generated method stub
		Node sortNode = new Node();  //实例化新的Node节点
		for(int number : sortTest)
			sortNode.add(number);  //生成二叉树
		List<Object> sortTreeNumber = sortNode.values();  //调用Node类中values方法，中序遍历二叉树，返回List
		int[] sortedNumber = new int[sortTreeNumber.size()];  //新建int数组，大小等于List
		for(int i = 0;i < sortedNumber.length;i++){
			sortedNumber[i] = Integer.parseInt(sortTreeNumber.get(i).toString());  //将List中的数转为String，再转为Interger
		}
		
		return sortedNumber;	
		
	}

其中Node类：

package collection;

import java.util.ArrayList;
import java.util.List;

public class Node {
	//构造二叉树节点
	public Node leftNode;
	public Node rightNode;
	public Object value;
	//构造二叉树
	public void add(Object v){
		if(null == value)
			value = v;
		else{
			if((Integer)v <= (Integer)value){
				if(null == leftNode)
					leftNode = new Node();
				leftNode.add(v);
			}
			else{
				if(null == rightNode)
					rightNode = new Node();
				rightNode.add(v);
			}
		}
	}
	//中序遍历二叉树
	public List<Object> values(){
		List<Object> values = new ArrayList<>();
		if(null != leftNode)
			values.addAll(leftNode.values());
		values.add(value);
		if(null != rightNode)
			values.addAll(rightNode.values());
		
		return values;
		
	}
}

快速排序

快排的主要问题就是portion方法，每次遍历都需要知道是从哪里开始是下一次排序的左半区的右边界，和右半区的左边界。

	private static int[] QuickSort(int[] sortNumber ,int low,int high){
		int p;
		if(low >= high)  //防止出现边界情况，如 low < p-1
			return sortNumber;
		p = portion(sortNumber,low,high);  //分界点
		QuickSort(sortNumber, low, p-1);  //左半区
		QuickSort(sortNumber, p+1, high);  //右半区
		
		return sortNumber;
	}
	
	public static int portion(int[] sortNumber ,int low,int high) {
		int p = sortNumber[low];  //将初始二分点设为该次遍历的最低点，若该部分为有序，则用该点会是快排的最差情况。在其他优化算法中，p点的取值为主要优化对象
				
		while(low < high){  //采用的方法是挖坑，填坑
			while(low < high && sortNumber[high] >= p)  //此处一定取等，否则出现相同的数会陷入死循环
				high--;
			sortNumber[low] = sortNumber[high];
			while(low < high && sortNumber[low] <= p)  //同理
				low++;
			sortNumber[high] = sortNumber[low];
		}
		sortNumber[low] = p;
		
		return low;
		
	}
	
	private static void swap(int[] a, int i, int j) {
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}

冒泡排序

主要问题在于相邻值俩俩对比、交换，适用于小规模排序

//主要问题在于相邻值俩俩对比、交换，适用于小规模排序
private static int[] BubblingSort(int[] sortNumber) {
		for(int i = 0;i < sortNumber.length-1;i++){
			for(int j = 0;j < sortNumber.length-i-1;j++){
				if(sortNumber[j] > sortNumber[j+1]){
					swap(sortNumber,j,j+1);
				}
			}
		}
		
		return sortNumber;

选择排序

主要问题在于直接遍历俩俩对比、交换，（可能非相邻）适用于小规模排序

//主要问题在于直接遍历俩俩对比、交换，（可能非相邻）适用于小规模排序
private static int[] SelectionSort(int[] sortNumber) {
		for(int i = 0;i < sortNumber.length-1;i++){
			for(int j = i+1;j < sortNumber.length;j++){
				if(sortNumber[i] > sortNumber[j]){
					int temp = sortNumber[j];
					sortNumber[j] = sortNumber[i];
					sortNumber[i] = temp;
				}
			}
		}
		
		return sortNumber;	
	}

主函数

这里的40000可以设个值，不然每次改排序规模都好麻烦，写的时候没在意，有点傻，而且可以写个sort接口就好了，不用这么麻烦的写时间对比，果然没学到精髓

//这里的40000可以设个值，不然每次改排序规模都好麻烦，写的时候没在意，有点傻。
public class SortTest {
	public static void main(String[] args) {
		int[] sortTest = new int[40000];
		for(int i = 0;i < 40000;i++){
			sortTest[i] = (int)(Math.random()*100000);
		}
		
		System.out.println("数组准备完毕");
		//复制相同的数组，运行完数组就已经有序了
		
		int[] useArray1 = Arrays.copyOf(sortTest, sortTest.length);
		long strTime = System.currentTimeMillis();
	    Arrays.sort(useArray1);//系统排序
	    long endTime = System.currentTimeMillis();
	    System.out.println("系统自带排序用的时间：" + (endTime-strTime));
		
		int[] useArray = Arrays.copyOf(sortTest, sortTest.length);
		strTime = System.currentTimeMillis();
	    int[] SelectionResult = SelectionSort(useArray);//选择排序
	    endTime = System.currentTimeMillis();
	    System.out.println("选择排序用的时间：" + (endTime-strTime));
	    System.out.println("结果是否与系统自带sort相同：" + Arrays.equals(useArray1, SelectionResult));
	    
	    
	    useArray = Arrays.copyOf(sortTest, sortTest.length);
		strTime = System.currentTimeMillis();
		int[] BubResult = BubblingSort(useArray);//冒泡
	    endTime = System.currentTimeMillis();
	    System.out.println("冒泡排序用的时间：" + (endTime-strTime));
	    System.out.println("结果是否与系统自带sort相同：" + Arrays.equals(useArray1, BubResult));
	    
	    useArray = Arrays.copyOf(sortTest, sortTest.length);
		strTime = System.currentTimeMillis();
		int[] TreeResult = TreeSort(useArray);//
	    endTime = System.currentTimeMillis();
	    System.out.println("二叉排序用的时间：" + (endTime-strTime));
	    System.out.println("结果是否与系统自带sort相同：" + Arrays.equals(useArray1, TreeResult));
	    
	    
	    useArray = Arrays.copyOf(sortTest, sortTest.length);
		strTime = System.currentTimeMillis();
		int[] QuickResult = QuickSort(useArray, 0, useArray.length-1);//
	    endTime = System.currentTimeMillis();
	    System.out.println("快速排序用的时间：" + (endTime-strTime));
	    System.out.println("结果是否与系统自带sort相同：" + Arrays.equals(useArray1, QuickResult));	    
		
	}