排序：簡單排序算法實現：冒泡，選擇，插入

package com.zf.algorithm.sort;

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

public final class Sort
{
	/**
	 * 排序方向，升序或者降序
	 *
	 * @author zf
	 *
	 */
	public enum ORDER
	{
		ascend(1), descend(-1);

		private ORDER(int value)
		{
			this.order = value;
		}

		private int order;

		public int getOrder()
		{
			return order;
		}
	}

	/**
	 * 簡答的冒泡排序。
	 *
	 * @param list
	 *            需要排序的數組
	 * @param order
	 *            順序
	 */
	@SuppressWarnings("unchecked")
	public static <T> void simpleBubbleSort(List<Comparable<T>> list, ORDER order)
	{
		// Check parameter
		if (list == null || list.size() == 0)
			return;

		for (int i = 0; i < list.size() - 1; i++)
		{
			for (int j = i + 1; j < list.size(); j++)
			{
				if (list.get(i).compareTo((T) list.get(j)) * order.getOrder() > 0)
				{
					Comparable<T> temp = list.get(i);
					list.set(i, list.get(j));
					list.set(j, temp);
				}
			}
		}
	}

	/**
	 * 改進的冒泡排序。
	 *
	 * @param list
	 *            需要排序的數組
	 * @param order
	 *            順序
	 */
	@SuppressWarnings("unchecked")
	public static <T> void impovedBubbleSort(List<Comparable<T>> list, ORDER order)
	{
		// Check parameter
		if (list == null || list.size() == 0)
			return;

		for (int i = 0; i < list.size(); i++)
		{
			for (int j = list.size() - 1; j > i; j--)
			{
				if (list.get(j - 1).compareTo((T) list.get(j)) * order.getOrder() > 0)
				{
					Comparable<T> temp = list.get(j);
					list.set(j, list.get(j - 1));
					list.set(j - 1, temp);
				}
			}
		}
	}

	/**
	 * 簡答的選擇排序。
	 *
	 * @param list
	 *            需要排序的數組。
	 * @param order
	 *            順序。
	 */
	@SuppressWarnings("unchecked")
	public static <T> void simpleSelectSort(List<Comparable<T>> list, ORDER order)
	{
		// Check parameter
		if (list == null || list.size() == 0)
			return;

		for (int i = 0; i < list.size() - 1; i++)
		{
			int loc = i;
			for (int j = i + 1; j < list.size(); j++)
			{
				if (list.get(loc).compareTo((T) list.get(j)) * order.getOrder() > 0)
				{
					loc = j;
				}
			}
			Comparable<T> temp = list.get(i);
			list.set(i, list.get(loc));
			list.set(loc, temp);
		}
	}

	/**
	 * 插入排序。
	 * 
	 * @param list
	 *            需要排序的數組。
	 * @param order
	 *            順序。
	 */
	@SuppressWarnings("unchecked")
	public static <T> void insertSort(List<Comparable<T>> list, ORDER order)
	{
		// Check parameter
		if (list == null || list.size() == 0)
			return;

		Object[] arrays = list.toArray();

		for (int i = 1; i < arrays.length; i++)
		{
			Comparable<T> iEle = (Comparable<T>) arrays[i];
			if (iEle.compareTo((T) arrays[i - 1]) * order.getOrder() < 0)
			{
				int j = i - 1;
				for (; j >= 0; j--)
				{
					if (iEle.compareTo((T) arrays[j]) * order.getOrder() < 0)
					{
						arrays[j + 1] = arrays[j];
					} else
					{
						break;
					}
				}
				arrays[j + 1] = iEle;
			}
		}
		list.clear();
		for (Object object : arrays)
			list.add((Comparable<T>) object);
	}

	public static void main(String[] args)
	{
		Integer[] integers =
		{ 4, 3, 7, 1, 6, 2 };
		List<Comparable<Integer>> list = new ArrayList<Comparable<Integer>>();
		list.addAll(Arrays.asList(integers));
		System.out.println("INPUT : " + list);
		// Sort.simpleBubbleSort(list, ORDER.descend);
		// Sort.impovedBubbleSort(list, ORDER.descend);
		// Sort.simpleSelectSort(list, ORDER.descend);
		Sort.insertSort(list, ORDER.ascend);
		System.out.println("OUTPUT : " + list);
	}
}