排序算法

最近在学习算法的一些知识，发现这些知识并非可有可无，不再做一个只会使用API的程序员，这是一个漫长的学习过程。

 

以下为常用的几个算法的Java实现，写在一个Junit测试类中了，这样方便执行，也不至于文件太多。

 

package alg;

import java.util.Arrays;
import org.junit.Test;

public class Algorithm {

	private static long arr[] = new long[10];

	static {
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (long) (Math.random() * 100);
		}
	}

	private void swap(long[] array, int i, int j) {
		if (i == j) {
			return;
		}

		long temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	@Test
	public void arraysSort() {
		System.out.println("排序前：" + Arrays.toString(arr));

		Arrays.sort(arr);

		System.out.println("排序后：" + Arrays.toString(arr));
	}

	/**
	 * 
	 * 冒泡排序----交换排序的一种 方法：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），
	 * 下一次循环是将其他的数进行类似操作。 性能：比较次数O(n^2),n^2/2；交换次数O(n^2),n^2/4
	 * 
	 */
	@Test
	public void bubbleSort() {
		System.out.println("排序前：" + Arrays.toString(arr));

		for (int i = arr.length - 1; i >= 1; i--) {

			for (int j = 0; j < i; j++) {
				if (arr[j] > arr[j + 1]) {
					swap(arr, j, j + 1);
				}
			}
		}

		System.out.println("排序后：" + Arrays.toString(arr));
	}

	// 换一下泡泡的走向
	@Test
	public void bubbleSort2() {
		System.out.println("排序前：" + Arrays.toString(arr));

		for (int i = arr.length - 1; i >= 1; i--) {

			for (int j = i; j > 0; j--) {
				if (arr[j] < arr[j - 1]) {
					swap(arr, j, j - 1);
				}
			}
		}

		System.out.println("排序后：" + Arrays.toString(arr));
	}

	/**
	 * 
	 * 直接选择排序法----选择排序的一种 方法：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
	 * 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 性能：比较次数O(n^2),n^2/2 交换次数O(n),n
	 * 交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CUP时间多，所以选择排序比冒泡排序快。
	 * 但是N比较大时，比较所需的CPU时间占主要地位，所以这时的性能和冒泡排序差不太多，但毫无疑问肯定要快些。
	 */
	@Test
	public void selectSort() {
		System.out.println("排序前：" + Arrays.toString(arr));

		for (int i = 0; i < arr.length - 1; i++) {

			int index = i;
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[index] > arr[j]) {
					index = j;
				}
			}

			swap(arr, i, index);
		}

		System.out.println("排序后：" + Arrays.toString(arr));
	}

	/**
	 * 插入排序 方法：将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。 性能：比较次数O(n^2),n^2/4
	 * 复制次数O(n),n^2/4 比较次数是前两者的一般，而复制所需的CPU时间较交换少，所以性能上比冒泡排序提高一倍多，而比选择排序也要快。
	 */
	@Test
	public void insertSort() {
		System.out.println("排序前：" + Arrays.toString(arr));

		for (int i = 1; i < arr.length; i++) {
			long temp = arr[i];

			int j;

			for (j = i; j > 0; j--) {
				if (temp < arr[j - 1]) {
					arr[j] = arr[j - 1];
				} else {
					break;
				}

			}
			arr[j] = temp;
		}

		System.out.println("排序后：" + Arrays.toString(arr));
	}

	//来自于java.util.Arrays的源码
	@Test
	public void insertSort2() {
		System.out.println("排序前：" + Arrays.toString(arr));

		for (int i = 0; i < arr.length; i++) {
			
			for (int j = i; j > 0 && arr[j - 1] > arr[j]; j--) {
				swap(arr, j, j - 1);
			}
		}

		System.out.println("排序后：" + Arrays.toString(arr));
	}

	@Test
	public void quickSort() {
		System.out.println("排序前：" + Arrays.toString(arr));

		qSort(arr, 0, arr.length - 1);

		System.out.println("排序后：" + Arrays.toString(arr));
	}

	private void qSort(long[] array, int low, int high) {
		if (low < high) {
			int pivot = partition(array, low, high);

			qSort(arr, low, pivot - 1);

			qSort(arr, pivot + 1, high);
		}
	}

	private int partition(long[] array, int low, int high) {
		long pivot = array[low];
		
		int left = low;
		int right = high;
		
		while (left < right) {
			
			while (array[left] <= pivot && left < right) {
				left++;
			}
			
			while (array[right] > pivot) {
				right--;
			}
			
			if (left < right) {
				swap(array, left, right);
			}
		}
		
		swap(array, low, right);
		
		return right;
	}
}

 

 

找到一个参考网址http://www.cs.princeton.edu/introcs/40algorithms/