排序：简单排序算法实现：冒泡，选择，插入

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);
}
}