基本排序算法

MySort.java

package cn.edu.wtu.sort;

public class MySort {

	/**
	 * 冒泡排序
	 * 
	 * @param a
	 */
	public static void bubble(int a[]) {
		for (int i = 0; i < a.length; ++i) {
			for (int j = 1; j < a.length - i; ++j) {
				if (a[j] < a[j - 1]) {
					a[j] ^= a[j - 1];
					a[j - 1] ^= a[j];
					a[j] ^= a[j - 1];
				}
			}
		}
	}

	/**
	 * 插入排序，认为第一个数是有序的，依次插入其他数 使用插入排序数组第零号最好不要存储数据
	 * 
	 * @param a
	 */
	public static void insertSort(int a[]) {
		for (int i = 1; i < a.length; ++i) {
			int tmp = a[i], j;
			for (j = i; j > 0 && tmp < a[j - 1]; --j) {
				a[j] = a[j - 1];
			}
			a[j] = tmp;
		}
	}

	/**
	 * 插入排序 第零号元素不存数据
	 * 
	 * @param a
	 */
	public static void insertSort1(int a[]) {
		for (int i = 2, j; i < a.length; ++i) {
			a[0] = a[i];
			for (j = i; a[0] < a[j - 1]; --j) {
				a[j] = a[j - 1];
			}
			a[j] = a[0];
		}
	}

	/**
	 * 快速排序
	 * 
	 * @param a
	 */
	public static void QSort(int a[]) {
		QSort(a, 0, a.length - 1);
	}

	private static void QSort(int a[], int low, int high) {
		if (low < high) {
			int pivot = Partation(a, low, high);
			QSort(a, low, pivot - 1);
			QSort(a, pivot + 1, high);
		}
	}

	private static int Partation(int[] a, int low, int high) {
		while (low < high) {
			while (low < high && a[low] <= a[high]) {
				--high;
			}
			/** 交换两数 此处不能使用位运算 因为当low与high相等时a[low]=a[high]=0 */
			int tmp = a[low];
			a[low] = a[high];
			a[high] = tmp;
			while (low < high && a[low] <= a[high]) {
				++low;
			}
			tmp = a[low];
			a[low] = a[high];
			a[high] = tmp;
		}
		return low;
	}

	/**
	 * 希尔排序
	 * 
	 * @param a
	 */
	public static void shellSort(int a[]) {
		int b[] = { 5, 3, 1 };
		for (int i = 0; i < b.length; ++i) {
			shellSort(a, b[i]);
		}
	}

	private static void shellSort(int a[], int dk) {
		int i, j;
		for (i = dk; i < a.length; i += dk) {
			int tmp = a[i];
			for (j = i - dk; j >= 0 && a[j] > tmp; j -= dk) {
				a[j + dk] = a[j];
			}
			a[j + dk] = tmp;
		}
	}

	/**
	 * 堆排序
	 * 
	 * @param a
	 */
	public static void heapSort(int a[]) {
		for (int i = a.length / 2 - 1; i >= 0; --i) {
			// 构造初始堆（构建一个完全二叉树，保证所有的父结点都比它的孩子结点数值大
			heapAdjust(a, i, a.length - 1);
		}
		// 每次交换第一个和最后一个元素，输出最后一个元素（最大值），然后把剩下元素重新调整为大根堆。
		// 当输出完最后一个元素后，这个数组已经是按照从小到大的顺序排列了。
		for (int i = a.length - 1; i > 0; --i) {
			a[0] ^= a[i];
			a[i] ^= a[0];
			a[0] ^= a[i];
			heapAdjust(a, 0, i);
		}
	}

	private static void heapAdjust(int a[], int i, int n) {
		int child = 2 * i + 1;
		int tmp = a[i];
		while (child < n) {
			if (child < n - 1 && a[child] < a[child + 1]) {
				++child;
			}
			if (tmp >= a[child]) {
				break;
			}
			a[i] = a[child];
			i = child;
			child = 2 * child + 1;
		}
		a[i] = tmp;
	}

	/**
	 * 归并排序
	 * 
	 * @param a
	 */
	public static void mergeSort(int a[]) {
		int tmp[] = new int[a.length];
		mergeSort(a, 0, a.length - 1, tmp);
	}

	private static void mergeSort(int a[], int first, int last, int tmp[]) {
		if (first < last) {
			int mid = (first + last) / 2;
			mergeSort(a, first, mid, tmp);
			mergeSort(a, mid + 1, last, tmp);
			mergeArray(a, first, mid, last, tmp);
		}
	}

	/* 数组合并 */
	private static void mergeArray(int a[], int first, int mid, int last, int tmp[]) {
		int i = first;
		int j = mid + 1;
		int k = 0;
		while (i <= mid && j <= last) {
			if (a[i] < a[j]) {
				tmp[k++] = a[i++];
			} else {
				tmp[k++] = a[j++];
			}
		}
		while (i <= mid) {
			tmp[k++] = a[i++];
		}
		while (j <= last) {
			tmp[k++] = a[j++];
		}
		for (i = 0; i < k; ++i) {
			a[first + i] = tmp[i];
		}
	}

	/**
	 * 基数排序
	 * 
	 * @param a
	 */
	public static void radixSort(int a[]) {
		int n = getMaxLength(a);
		int i = 1;
		while (n-- != 0) {
			sortByDigit(a, i);
			i *= 10;
		}
	}

	/* 根据digit位排序，这里使用的是冒泡，可改用其它 */
	private static void sortByDigit(int a[], int digit) {
		for (int i = 0; i < a.length; ++i) {
			for (int j = 1; j < a.length - i; ++j) {
				if (getDigit(a[j - 1], digit) > getDigit(a[j], digit)) {
					a[j - 1] ^= a[j];
					a[j] ^= a[j - 1];
					a[j - 1] ^= a[j];
				}
			}
		}
	}

	/* 得到数组的最大位数 */
	private static int getMaxLength(int a[]) {
		int max = 0;
		for (int i = 0; i < a.length; ++i) {
			if (max < getLength(a[i])) {
				max = getLength(i);
			}
		}
		return max;
	}

	/* 得到位数 一种数学方法得到 一种利用java类型转换得到 */
	private static int getLength(int n) {
		int m = 0;
		while (n % 10 != 0) {
			m++;
			n /= 10;
		}
		return m;
		// return String.valueOf(n).length();
	}

	/* 得到digit位上的数字 */
	private static int getDigit(int n, int digit) {
		return n / digit % 10;
	}
	
	/*
	 * 选择排序
	 */
	public static void selectSort(int a[]){
		for( int i = 0 ; i < a.length; ++i ){
			int min = a[i];
			int index = i ;
			for( int j = i+1 ; j < a.length; ++j){
				if(min >a[j]){
					min = a[j];
					index = j;
				}
			}
			a[index] = a[i];
			a[i] = min;		
		}
		
	}
}

Utils.java

package cn.edu.wtu.utils;

import java.util.Random;

public class Utils {
	//得到一个随机数组，
	public static int [] getArray(int n){
		int a[] = new int[n];
		Random ran=new Random();
		for( int i = 0 ; i < n ; ++i ){
			a[i] = ran.nextInt(100);  //产生100以内的整数
		}	
		return a;
	}
	
	public static void print( int a[] ){
		for( int i=0; i<a.length; ++i){
			System.out.print(a[i]+" ");
		}
		System.out.println(); 
	}
}





Test.java
package cn.edu.wtu.test;

import java.util.Arrays;
import cn.edu.wtu.sort.MySort;
import cn.edu.wtu.utils.Utils;

public class Test {
	
	public static void main(String[] args) {
		
		int n = 20; //产生数组的大小
		int a[] = Utils.getArray(n);
		Utils.print(a);
		//直接调用Arrays的sort方法排序
		Arrays.sort(a);
		//MySort.bubble(a);
		//MySort.insertSort(a);
		//MySort.QSort(a);
		//MySort.shellSort(a);
		//MySort.heapSort(a);
		//MySort.mergeSort(a);
		//MySort.radixSort(a);
		//MySort.selectSort(a);
		Utils.print(a);	
	}
}