常用排序算法简介与java实现（冒泡、插入、选择、希尔、归并、快排）

本文介绍六大常用算法的基本思路，以及相应的java函数实现。

本文的eclipse工程源代码可到以下链接下载：

http://download.csdn.net/detail/nostandby/9639511

下面将按照以下顺序进行介绍：

1、冒泡排序、冒泡排序的两种改进。

2、插入排序。

3、选择排序。

4、希尔排序。

5、归并排序。

6、快速排序。

1、冒泡排序：

相邻两个元素进行比较，如果反序就交换

public void bubbleSort1(List<Integer> nums) {
for (int i = nums.size(); i > 0; i--) {
for (int j = 0; j < i - 1; j++) {
if (nums.get(j).intValue() > nums.get(j + 1).intValue()) {
swap(nums, j, j + 1);
}
}
}
}

冒泡排序改进1：

如果某一轮排序过程中没有发生交换，说明所有数据都已经有序，排序可以停止。

public void bubbleSort2(List<Integer> nums) {
boolean continueflag = true;
for (int i = nums.size(); continueflag && i > 0; i--) {
continueflag = false;
for (int j = 0; j < i - 1; j++) {
if (nums.get(j).intValue() > nums.get(j + 1).intValue()) {
swap(nums, j, j + 1);
continueflag = true;
}
}
}
}

冒泡排序改进2：

在改进1的基础上，记录每一轮停止时的索引，这个索引表明：该索引之后的元素都已排好。

那么下一轮到这一位置停止即可

public void bubbleSort3(List<Integer> nums) {
int flag;
for (int i = nums.size(); i > 0; i = flag) {
flag = 0;

4000
for (int j = 0; j < i - 1; j++) {
if (nums.get(j).intValue() > nums.get(j + 1).intValue()) {
swap(nums, j, j + 1);
flag = j + 1;
}
}
}
}

2、插入排序

思想：将一个元素插入到一个有序序列中。

实现思路是：从索引为1 的位置遍历“数组”，将每个元素插入到它前面的有序序列中。

理解它的关键在于：待插入元素之前的元素都是有序的。

public void insertionSort(List<Integer> nums) {
int length = nums.size();
for (int i = 1; i < length; i++) {
for (int j = i; j > 0 && nums.get(j - 1).intValue() > nums.get(j).intValue(); j--) {
swap(nums, j, j - 1);
}
}
}

3、选择排序

思想：

（1）、从待排序列中先找到最小的元素，放到第一个位置。

（2）、再从剩余元素中找最小的，放到第二个位置。……

（3）、以此类推，直到所有元素都找到了自己的位置。

选择排序是固定位置，找元素；冒泡排序和插入排序是固定元素找位置。

public void selectionSort(List<Integer> nums) {
for (int i = 0; i < nums.size(); i++) {
int lowindex = i;
for (int j = i + 1; j < nums.size(); j++) {
if (nums.get(j).intValue() < nums.get(lowindex).intValue()) {
lowindex = j;
}
}
swap(nums, i, lowindex);
}
}

4、希尔排序（缩小增量排序）

可以认为是插入排序的一种变形。

思路：

先将整个待排元素序列分割成若干子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序

然后依次缩减增量再进行排序

待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序（增量为1）。

其时间复杂度为O(n^3/2),要好于直接插入排序的O(n^2)

public void shellSort(List<Integer> nums) {
int length = nums.size();
for (int i = length / 2; i > 2; i /= 2) {
for (int j = 0; j < i; j++) {
inssort(nums, i);
}
}
inssort(nums, 1);
}

private void inssort(List<Integer> nums, int incr) {
for (int i = incr; i < nums.size(); i += incr) {
for (int j = i; j >= incr && nums.get(j - incr).intValue() > nums.get(j).intValue(); j -= incr) {
swap(nums, j, j - incr);
}
}
}

5、归并排序

分而治之，之后合并

public void mergeSort(List<Integer> nums) {
mergeSort(nums, 0, nums.size() - 1);
}

public void mergeSort(List<Integer> nums, int start, int end) {
if (start == end)
return;
int mid = (start + end) / 2;
mergeSort(nums, start, mid);
mergeSort(nums, mid + 1, end);
List<Integer> temp = new LinkedList<Integer>();
for (int i = start; i <= end; i++) {
temp.add(new Integer(nums.get(i).intValue()));
}
int i1 = 0, i2 = mid - start + 1;
for (int curr = start; curr <= end; curr++) {
if (i1 == mid + 1)
nums.set(curr, temp.get(i2++));
else {
if (i2 > end - start)
nums.set(curr, temp.get(i1++));
else {
if (temp.get(i1).intValue() < temp.get(i2).intValue())
nums.set(curr, temp.get(i1++));
else
nums.set(curr, temp.get(i2++));
}
}
}
}

6、快速排序

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。时间复杂度为O(nlogn)

public void qsort(List<Integer> nums) {
qsort(nums, 0, nums.size() - 1);
}

public void qsort(List<Integer> nums, int start, int end) {
if (start > end)
return;
int q = partition(nums, start, end);
qsort(nums, start, q - 1);
qsort(nums, q + 1, end);
}

private int partition(List<Integer> nums, int start, int end) {
int keyIndex = end;
int left = start, right = end - 1;
while (left < right) {
while (left < right && nums.get(left).intValue() < nums.get(keyIndex).intValue())
left++;
while (left < right && nums.get(right).intValue() > nums.get(keyIndex).intValue())
right--;
swap(nums, left, right);
}
swap(nums, left, keyIndex);
return left;
}

关于堆排序，桶排序，计数排序，基数排序等其他排序，时间问题，笔者目前还没有写出源代码。

以上内容仅代表笔者个人理解。如有错误欢迎交流指正。

参考资料：

1、《数据结构与算法分析(C++版)》

2、《算法导论》

3、http://www.open-open.com/lib/view/open1420372620468.html