排序算法---基础算法（冒泡排序，快速排序，选择排序，直接插入排序，桶排序）

一：桶排序部分

使用条件：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 - iif (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) {//位于第一个，例如，3133if (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) {//位于最后一个 ，例如：5234if (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++];elsetemp[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) / 2void 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;}