快速排序java实现

package com.xuji;

import java.util.Random;

public class FastSortDemo {

	public static void main(String[] args) {
		int[] arr = createArr();
		for (int i : arr) {
			System.out.println(i);
		}
		System.out.println("---------------------------------------------");
		long startTime = System.currentTimeMillis();
		int right = arr.length - 1;
		int left = 0;
		fastSort(arr, left, right);
		long endTime = System.currentTimeMillis();
		for (int i : arr) {
			System.out.println(i);
		}
		System.out.println("用时为" + (endTime - startTime));
	}
	public static void fastSort(int[] arr, int left, int right) {
		if(left >= right) {
			return ;
		}
		int base = arr[left];
		int baseIndex = left;
		for(int i = left; i <= right; i++) {
			if(arr[i] < base) {
				int temp = arr[i];
				for(int j = i ; j > baseIndex; j--) {
					arr[j] = arr[j-1];
				}
				arr[baseIndex] = temp;
				baseIndex ++;
			}
		}
		fastSort(arr, left, baseIndex - 1);
		fastSort(arr, baseIndex + 1, right);
	}
	public static int[] createArr() {
		Random r = new Random(System.currentTimeMillis());
		int[] arr = new int[100000];
		for(int i = 0; i < 100000; i++) {
			arr[i] = r.nextInt(10000000);
		}
		return arr;
	}
}

createArr()创建随机数数组；

fastSort()迭代快排的方法，取最左边的数为基准值，比基准值小的数分到左边，比基准值大的分到右边，然后对这两个子数组继续快速排序，直到数组只有一个元素。

测试0-1000000之间的100000个随机数进行排序，需要大约1s

 

这个实现有可以优化的地方，每趟排序的时候，移动数组的次数过多，可以优化

package com.xuji;

import java.util.Arrays;
import java.util.Random;

public class FastSortDemo {

	public static void main(String[] args) {
		int[] arr = createArr();
		int[] arr1 = Arrays.copyOf(arr, arr.length);
		long startTime = System.currentTimeMillis();
		int right = arr.length - 1;
		int left = 0;
		fastSort(arr, left, right);
		long endTime = System.currentTimeMillis();
		System.out.println("fastSort用时为" + (endTime - startTime));
		startTime = System.currentTimeMillis();
		fasterSort(arr1, 0 , arr1.length -1);
		endTime = System.currentTimeMillis();
		System.out.println("fasterSort用时为：" + (endTime - startTime));
	}
	public static void fastSort(int[] arr, int left, int right) {
		if(left >= right) {
			return ;
		}
		int base = arr[left];
		int baseIndex = left;
		for(int i = left; i <= right; i++) {
			if(arr[i] < base) {
				int temp = arr[i];
				for(int j = i ; j > baseIndex; j--) {
					arr[j] = arr[j-1];
				}
				arr[baseIndex] = temp;
				baseIndex ++;
			}
		}
		fastSort(arr, left, baseIndex - 1);
		fastSort(arr, baseIndex + 1, right);
	}
	
	public static void fasterSort(int[] arr, int left, int right) {
		if(left >= right) {
			return;
		}
		int baseIndex = partition(arr, left, right);
		fasterSort(arr, left, baseIndex -1);
		fasterSort(arr, baseIndex + 1, right);
	}
	
	public static int partition(int[] arr, int left, int right) {
		int base = arr[left];
		while(left < right) {
			while(arr[right] >= base && right > left) {
				right--;
			}
			arr[left] = arr[right];
			while(arr[left] <= base && left < right) {
				left++;
			}
			arr[right] = arr[left];
		}
		arr[right] = base;
		return right;
	}
	
	public static int[] createArr() {
		Random r = new Random(System.currentTimeMillis());
		int[] arr = new int[1000000];
		for(int i = 0; i < 1000000; i++) {
			arr[i] = r.nextInt(100000000);
		}
		return arr;
	}
}

当数组达到100w大小的时候，可以看到改进了移动数组之后的算法速度提高了很多。