java 实现 冒泡排序、选择排序、插入排序。

package com.j2se;

public class TestSort {
	public static void main(String args[]) {
		int[] a = { 1, 7, 3, 9, 2, 5, 8, 4, 6 };
		// bubbleSort(a); // 冒泡(Bubble Sort)排序
		// selectionSort(a); // 选择排序
		insertSort(a); // 插入排序
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
	}
	/****************************************************************
	 * 
	 * 
	 
	 冒泡排序的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。
	 	即首先比较第1个和第2个数，将小数放前，大数放后。
	 	然后比较第2个数和第3个数，将小数放前，大数放后.
	 	如此继续，直至比较最后两个数，将小数放前，大数放后。
	 		重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再大于第2个数）.
	 	将小数放前，大数放后，一直比较到最小数前的一对相邻数，将小数放前，大数放后，第二趟结束，在倒数第二个数中得到一个新的最小数。
	 	如此下去，直至最终完成排序。
	 	
		由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。
		用二重循环实现，外循环变量设为i，内循环变量设为j。
			外循环重复9次，内循环依次重复9，8，...，1次。
			每次进行比较的两个元素都是与内循环j有关的,
				它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,9，对于每一个i, j的值依次为1,2,...10-i。
				
				public class BubbleSort {  
					    public static void sort(int[] data) {  
					        int temp;  
					        for (int i = 0; i < data.length; i++) {  
					            for (int j = data.length - 1; j > i; j--) {  
					                if (data[i] > data[j]) {  
					                    temp = data[i];  
					                    data[i] = data[j];  
					                    data[j] = temp;  
					                }  
					            }  
					        }  
					    }  
					  
					    public static void main(String[] args) {  
					        int[] a = { 4, 2, 3, 1, 5 };  
					        sort(a);  
					        for (int i = 0; i < a.length; i++)  
					            System.out.print(a[i] + " ");  
					    }  
				}  
		=================================================================================
		
				public class Test {
				  public static void main(String[] args) {
				    int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 };

				    System.out.print("排序前: ");
				
				    for (int i = 0; i < a.length; i++)
				      System.out.printf("%3s", a[i]);
				
				    System.out.println();
				
				    Test test = new Test();
				    test.bubbleSort(a);
				
				    System.out.print("排序后: ");
				
				    for (int i = 0; i < a.length; i++)
				      System.out.printf("%3s", a[i]);
				
				    System.out.println();
				  }
				
				  public void bubbleSort(int[] a) {
				    int len = a.length;
				
				    System.out.println("数组大小是:" + len);
				
				    boolean change = false;
				    int temp;
				    int count = 0;
				
				    for (int i = len; i > 1; i--) {
				      for (int j = 0; j < i - 1; j++) {
				        if (a[j + 1] < a[j]) {
				          temp = a[j + 1];
				          a[j + 1] = a[j];
				          a[j] = temp;
				          change = true;
				          count++;
				        }
				
				      }
				      if (change) {
				        System.out.print("第" + count + "趟交换: ");
				        for (int k = 0; k < len; k++)
				          System.out.print(a[k] + " ");
				
				        System.out.println();
				      }
				    }
				  }
				}
		
		
	 * 
	 * @param a
	 * @return
	 */
	public static int[] bubbleSort(int[] a) {
		int len = a.length;
		for (int i = len - 1; i >= 1; i--) {
			for (int j = 0; j <= i - 1; j++) {
				if (a[j] > a[j + 1]) {
					int temp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = temp;
				}
			}
		}
		return a;
	}
	/****************************************************
	 * 
	 * 
	 
	 选择排序的基本思想是：对待排序的记录序列进行n-1遍的处理.
		 第1遍处理是将L[1..n]中最小者与L[1]交换位置,
		 第2遍处理是将L[2..n]中最小者与L[2]交换位置，......，
		 第i遍处理是将L[i..n]中最小者与L[i]交换位置。
	这样，经过i遍处理之后，前i个记录的位置就已经按从小到大的顺序排列好了。 
　　当然，实际操作时，也可以根据需要，通过从待排序的记录中选择最大者与其首记录交换位置，按从大到小的顺序进行排序处理。 
	 * 
	 * @param a
	 * @return
	 */
	public static int[] selectionSort(int[] a) {
		for (int i = 0; i < a.length; i++) {
			for (int j = i + 1; j < a.length; j++) {
				if (a[i] > a[j]) {
					int temp = a[i];
					a[i] = a[j];
					a[j] = temp;
				}
			}
		}
		return a;
	}

	public static int[] insertSort(int[] a) {
		for (int i = 1; i < a.length; i++) {
			for (int j = i; j > 0; j--) {
				if (a[j] < a[j - 1]) {
					int temp = a[j];
					a[j] = a[j - 1];
					a[j - 1] = temp;
				} else {
					break;
				}
			}
		}
		return a;
	}

}

更多算法参考： http://blog.csdn.net/feixiaoxing/article/details/6993718