一：桶排序部分
使用条件：1.空间明确。2.对时间要求高
例子：一年的全国高考考生人数为500 万，分数使用标准分，最低100 ，最高900 ，没有小数，要求对这500 万元素的数组进行排序。
简介：桶的个数固定，每一桶中统计这个数出现的次数
Code:
package sort;
import java.util.Arrays;
/**
* @author MohnSnow
* @time 2015年6月11日 上午9:40:07
* @title 桶排序
*
*/
public class BucketSort {
/**
* @param argsmengdx
* -fnst
*/
//牺牲空间取代时间，必须知道数据范围
//时间复杂度：O(n2) 空间复杂度:O(m)
public static int[] bucketSort(int[] a) {
int[] b = new int[11];//表示取值范围为0~10 共十一个数字
for (int i = 0; i < a.length; i++) {
b[a[i]]++;
}
int temp = 0;
for (int j = 0; j < b.length; j++) {
if (b[j] > 0) {
for (int m = 0; m < b[j]; m++) {
a[temp++] = j;
}
}
}
return a;
}
public static void main(String[] args) {
int[] a = { 1, 6, 5, 9, 6, 3, 10, 6, 9, 4, 3, 3 };
System.out.println("数组a为：" + Arrays.toString(a));
System.out.println("桶排序：" + Arrays.toString(bucketSort(a)));
}
}
二：冒泡排序部分
使用条件：1.每一次判断出最大的那个。
简介：两两比较，直到最大或最小出现在正确的位置上面
图片：
Code:
package sort;
import java.util.Arrays;
/**
* @author MohnSnow
* @time 2015年6月11日 上午9:04:27
* @title 冒泡排序
*
*/
public class BubbleSort {
/**
* @param argsmengdx
* -fnst
*/
//牺牲时间代替空间，与桶排序是两个极端
//时间复杂度：O(n2) 空间复杂度:O(1)
public static int[] bubbleSort(int[] a) {
int len = a.length;
int temp;
for (int i = 0; i < len; i++) {
for (int j = 0; j < len - 1; j++) {
if (a[j] > a[j + 1]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
return a;
}
public static int[] bubbleSort1(int[] a) {
int len = a.length;
int temp;
for (int i = 0; i < len; i++) {
for (int j = 0; j < len - 1 - i; j++) {//因为一次排序已经有序了，可以省略比较排序好的序列 :j < len - 1 - i
if (a[j] > a[j + 1]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
return a;
}
public static void main(String[] args) {
int[] a = { 1, 6, 5, 9, 6, 3, 10, 6, 9, 4, 3, 3 };
System.out.println("数组a为：" + Arrays.toString(a));
//System.out.println("冒泡排序：" + Arrays.toString(bubbleSort(a)));
System.out.println("冒泡排序1：" + Arrays.toString(bubbleSort1(a)));
}
}
三：选择排序部分
工作原理：是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。
Code:
package sort;
import java.util.Arrays;
/**
* @author MohnSnow
* @time 2015年6月11日 上午11:09:35
* @title 选择排序
*
*/
public class SelectionSort {
/**
* @param argsmengdx
* -fnst
*/
//每次选取最小的数字放到前面
public static int[] selectSort(int[] a) {
int len = a.length;
int temp, k;
for (int i = 0; i < len - 1; i++) {//之所以选取i<len-1是因为最后剩下一个数肯定是最大的。
k = i;
for (int j = i + 1; j < len; j++) {
if (a[j] < a[k]) {
k = j;
}
}
temp = a[i];
a[i] = a[k];
a[k] = temp;
System.out.println("i的值为：" + i + "打印每次排序结果为：" + Arrays.toString(a));
}
return a;
}
public static void main(String[] args) {
int[] a = { 1, 6, 5, 9, 6, 3, 10, 6, 9, 4, 3, 3 };
System.out.println("数组a为：" + Arrays.toString(a));
System.out.println("选择排序为：" + Arrays.toString(selectSort(a)));
}
}
四：直接插入排序算法
简介：把序列分为已排序和未排序部分，假设前面的序列是有序的，然后选择数据有序数列插入。
Code:
package sort;
import java.util.Arrays;
/**
* @author MohnSnow
* @time 2015年6月11日 下午1:58:45
* @title 直接插入排序
*
*/
public class StraightInsertionSort {
/**
* @param argsmengdx
* -fnst
*/
public static int[] straightInsertionSort(int[] a) {
int len = a.length;
int iValue, i, j;
for (i = 1; i < len; i++) {
iValue = a[i];
j = i - 1;
while (j >= 0 && iValue < a[j]) {//a[i] < a[j] 一开始写错了，应该有一个temp去存取这个值
a[j + 1] = a[j];
j--;
}
a[j + 1] = iValue;
System.out.println("打印每次排序结果为：" + Arrays.toString(a));
}
return a;
}
public static void main(String[] args) {
int[] a = { 1, 6, 5, 9, 6, 3, 10, 6, 9, 4, 3, 3, 1 };
int[] b = { 4, 3, 2, 1 };
int[] c = { 1, 2, 3, 4 };
int[] d = { 4, 3, 2 };
System.out.println("数组a为：" + Arrays.toString(a));
System.out.println("数组b为：" + Arrays.toString(b));
System.out.println("数组c为：" + Arrays.toString(c));
System.out.println("数组d为：" + Arrays.toString(d));
System.out.println("直接插入排序：" + Arrays.toString(straightInsertionSort(a)));
}
}
五：快速排序部分
该方法的基本思想是：
1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。
4.注意是先进行减法，后进行加法。
简介：选取一个哨兵
Code:
package sort;
import java.util.Arrays;
/**
* @author MohnSnow
* @time 2015年6月11日 上午9:56:31
*
*/
public class QuickSort {
/**
* @param argsmengdx
* -fnst
*/
//时间复杂度：O(n*logn) 空间复杂度:O(1)
public static int[] quickSort(int[] a) {
subQuickSort(a, 0, a.length - 1);
return a;
}
public static void subQuickSort(int[] a, int begin, int end) {
int temp_begin = begin;
int temp_end = end;
int temp;
if (begin == end || begin < 0 || end > a.length - 1) {
return;
}
if (end - begin == 1) {
if (a[end] < a[begin]) {
temp = a[begin];
a[begin] = a[end];
a[end] = temp;
}
return;
}
int guard = begin++;
while (begin < end) {//找中间点过程单独写个方法去处理
while (a[end] >= a[guard] && end != begin) {
end--;
}
while (a[begin] < a[guard] && end != begin) {
begin++;
}
if (end == begin) {
break;
} else {
temp = a[end];
a[end] = a[begin];
a[begin] = temp;
}
}
if (begin == temp_begin + 1) {//位于第一个，例如，3133
if (a[begin] < a[guard]) {//转换条件可以单独写个方法
temp = a[guard];
a[guard] = a[begin];
a[begin] = temp;
}
subQuickSort(a, temp_begin + 1, temp_end);
} else if (begin == temp_end) {//位于最后一个 ，例如：5234
if (a[begin] < a[guard]) {
temp = a[guard];
a[guard] = a[begin];
a[begin] = temp;
}
subQuickSort(a, temp_begin, temp_end - 1);
} else {//位于中间
if (a[begin] < a[guard]) {
temp = a[guard];
a[guard] = a[begin];
a[begin] = temp;
}
subQuickSort(a, temp_begin, begin - 1);
subQuickSort(a, begin + 1, temp_end);
}
}
public static void main(String[] args) {
int[] a = { 1, 6, 5, 9, 6, 3, 10, 6, 9, 4, 3, 3, 1 };
int[] b = { 4, 3, 2, 1 };
int[] c = { 1, 2, 3, 4 };
System.out.println("数组a为：" + Arrays.toString(a));
System.out.println("数组b为：" + Arrays.toString(b));
System.out.println("数组c为：" + Arrays.toString(c));
//Arrays.sort(b);
//System.out.println("快速排序b：" + Arrays.toString(b));
System.out.println("快速排序：" + Arrays.toString(quickSort(a)));
}
}
五：希尔排序部分
参考：http://blog.csdn.net/morewindows/article/details/6668714
基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。
void shellsort1(int a[], int n)
{
int i, j, gap;
for (gap = n / 2; gap > 0; gap /= 2) //步长
for (i = 0; i < gap; i++) //直接插入排序
{
for (j = i + gap; j < n; j += gap)
if (a[j] < a[j - gap])
{
int temp = a[j];
int k = j - gap;
while (k >= 0 && a[k] > temp)
{
a[k + gap] = a[k];
k -= gap;
}
a[k + gap] = temp;
}
}
}六：归并排序部分（分治法）
参考：http://blog.csdn.net/morewindows/article/details/6678165
算法思想：归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序
//将有二个有序数列a[first...mid]和a[mid...last]合并。
void mergearray(int a[], int first, int mid, int last, int temp[])
{
int i = first, j = mid + 1;
int m = mid, n = last;
int k = 0;
while (i <= m && j <= n)
{
if (a[i] <= a[j])
temp[k++] = a[i++];
else
temp[k++] = a[j++];
}
while (i <= m)
temp[k++] = a[i++];
while (j <= n)
temp[k++] = a[j++];
for (i = 0; i < k; i++)
a[first + i] = temp[i];
}
void mergesort(int a[], int first, int last, int temp[])
{
if (first < last)
{
int mid = (first + last) / 2;
mergesort(a, first, mid, temp); //左边有序
mergesort(a, mid + 1, last, temp); //右边有序
mergearray(a, first, mid, last, temp); //再将二个有序数列合并
}
}
bool MergeSort(int a[], int n)
{
int *p = new int[n];
if (p == NULL)
return false;
mergesort(a, 0, n - 1, p);
delete[] p;
return true;
}七：堆排序部分
参考：http://blog.csdn.net/morewindows/article/details/6709644
二叉堆的定义
二叉堆是完全二叉树或者是近似完全二叉树。
二叉堆满足二个特性：
1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。
2．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。
// 新加入i结点 其父结点为(i - 1) / 2
void MinHeapFixup(int a[], int i)
{
int j, temp;
temp = a[i];
j = (i - 1) / 2; //父结点
while (j >= 0 && i != 0)
{
if (a[j] <= temp)
break;
a[i] = a[j]; //把较大的子结点往下移动,替换它的子结点
i = j;
j = (i - 1) / 2;
}
a[i] = temp;
}