欢迎Java爱好者品读其他排序算法详解：
冒泡排序： http://blog.csdn.net/ysjian_pingcx/article/details/8653732
选择排序： http://blog.csdn.net/ysjian_pingcx/article/details/8656048
直接插入排序：http://blog.csdn.net/ysjian_pingcx/article/details/8674454
快速排序： http://blog.csdn.net/ysjian_pingcx/article/details/8687444
快速排序优化：http://blog.csdn.net/ysjian_pingcx/article/details/8687444
比较排序<详解>
说起计算机，灵魂莫过于数据结构和算法了，数据结构多种多样，且很多的设计理念很奇特，是程序员需要花时间去了解的和掌握的，虽然现在大部分做软件开发的可以对数据结构和算法一知半解，虽然在工作中达到这种层次的要求的工作对大部分人来说是过分的要求，要想成为一名优秀的程序员，对数据结构和算法的了解和掌握是必不可少的，现在IT行业在国内一些企业中，一个系统一个软件的质量是得不到保证的，甚至是有些企业做出来的系统只是将功能实现了，没有做过良好的设计，对后期的维护和扩展造成了阻碍，轻者让自己后期维护痛苦，重者阻碍了中国IT行业的进步，虽然自己没有那种能力去做到一个十全十美的设计，但是要尽力而为，喜欢这行，就应该进最大的努力去做好，可以的话也为中国的IT行业贡献绵薄之力，我想我会不遗余力，因为我喜欢这个行业。
我自己说实话也对数据结构和算法掌握的不够好，但一直在努力，快要工作了，工作中也要不断的学习这些核心不变的东西，用计算机语言开发只是运用的一种工具，比如说我用的Java，开发一个系统可以用不同的语言来实现，但要是作为一个程序员，能够真正掌握一门语言的核心思想，绝对不是仅仅使用这种工具这么简单，所以，接触Java不久，一直在探索中，现在还只是一个菜鸟，最近校园招聘挺多的，一些大公司考的算法也挺多的，比如说排序，如果你用了快速排序法，而人家用了冒泡，可想而知，谁的亮点更大了...
菜鸟写写对排序算法的一些学习心得和总结，希望路过的高手指正。排序算法中，大家听得比较耳熟的是冒泡排序，还有快速排序，我也在面试碰到过要我用Java写出快速排序算法的人，当时那个：“码在用时方恨少啊”，其实是没有掌握那种思想，后来就研究了一些排序算法，那么从最简单的比较排序算法开始吧：
比较排序算法：
思路：
第一轮：将数组第一个元素与后面的每一个元素进行比较，如果有小于第一个元素的，就交换数组两个元素的值，再j将交换后得到的更小的值继续与后面的元素进行比较，直到一轮比较完毕，最后就将数组中的最小的值交换了最开始的位置；
第二轮：将数组的第二个元素与后面的每一个元素进行比较，重复第一轮的操作。
第三轮：...
......
我想这个再好理解不过了，就是将一个元素逐个比较，最后将最小的元素一道一端。
看看下面这个图：
看了这个图后，更形象了，上面这个图只画出了一轮比较后的结果，一轮下来就将最小值13移动到最上端(数组的0下标)
那么比较算法的核心就是比较了，比较的过程中再去判断，满足条件的就要交换了，比较的核心代码：
/**
* 比较排序算法的核心程序
* @param array
*/
public void compareSort(int... array){
int length = array.length;
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (array[i] > array[j]) {
swap(i, j, array);
}
}
}
}
@注意到上面的那段程序，外部循环是从0下标开始，内部循环是从外部循环的下标加一开始的，也就完成了一个元素和它之后的元素的遍历比较；
@int length = array.length; 是将数组的长度一次性算出来，免得每一次判断都要计算，或许对性能有所提高，当然不明显
@swap(i,j,array)是一个抽取出来的用来交换数组两个元素的函数
代码是：
/**
* 内部实现，用于交换数组的两个引用值
*
* @param beforeIndex
* @param afterIndex
* @param arr
*/
private void swap(int oneIndex, int anotherIndex, int[] array) {
int temp = array[oneIndex];
array[oneIndex] = array[anotherIndex];
array[anotherIndex] = temp;
}
@将这个函数抽取出来，作为内部实现，更符合面向对象的设计
一个最简单的比较排序就实现了，听起来很简单，其实更简单，下面提供完整的代码：
import java.util.Arrays;
/**
* 比较排序算法
* @author PingCX
*
*/
public class CompareSort {
public static void main(String[] args) {
CompareSort compareSort = new CompareSort();
int[] array = { 25, 36, 21, 45, 98, 13};
System.out.println(Arrays.toString(array));
compareSort.compareSort(array);
System.out.println(Arrays.toString(array));
}
/**
* 比较排序算法的核心程序
* @param array
*/
public void compareSort(int... array){
int length = array.length;
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (array[i] > array[j]) {
swap(i, j, array);
}
}
}
}
/**
* 内部实现，用于交换数组的两个引用值
*
* @param beforeIndex
* @param afterIndex
* @param arr
*/
private void swap(int oneIndex, int anotherIndex, int[] array) {
int temp = array[oneIndex];
array[oneIndex] = array[anotherIndex];
array[anotherIndex] = temp;
}
}
当然上面的排序只是针对int类型的数组，在Java这种面向对象语言中，这样的话就存在了局限性了，既然万事万物皆对象，那么是不是所有对象都可以比较呢?
@答案是肯定的，如果不可以，Java还学个什么啊，在JDK中有一个接口Comparable，任何类只要实现了这个接口，都可以用来比较的，跟int类型的数组比起来，要做一些改变
首先 ">" 就要用到Comparable中的 compareTo方法：
/**
* 比较排序算法的核心程序
* @param array
*/
public <T extends Comparable<T>> void compareSort(T[] array){
int length = array.length;
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (array[i].compareTo(array[j]) > 0) {
swap(i, j, array);
}
}
}
}
@<T extends Comparable<T>>这个是JDK1.5之后的泛型，用这个为开发带来了很大的灵活性和规范性，程序员乐此不疲地使用着，反正我喜欢用，呵呵！
/**
* 任意可以比较类型的比较排序算法
* @author PingCX
*
*/
public class CompareSortT {
public static void main(String[] args) {
CompareSortT compareSort = new CompareSortT();
Integer[] array = { 25, 36, 21, 45, 98, 13};
System.out.println(Arrays.toString(array));
compareSort.compareSort(array);
System.out.println(Arrays.toString(array));
}
/**
* 比较排序算法的核心程序
* @param array
*/
public <T extends Comparable<T>> void compareSort(T[] array){
int length = array.length;
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (array[i].compareTo(array[j]) > 0) {
swap(i, j, array);
}
}
}
}
/**
* 内部实现，用于交换数组的两个引用值
*
* @param beforeIndex
* @param afterIndex
* @param arr
*/
private <T extends Comparable<T>> void swap(int oneIndex, int anotherIndex, T[] array) {
T temp = array[oneIndex];
array[oneIndex] = array[anotherIndex];
array[anotherIndex] = temp;
}
}
比较排序算法的时间复杂度：1 + 2 + 3 + ...+ (n - 1) = n(n - 1)/2 ---->O(n²)
算法精妙绝伦，这只是抛砖引玉，继续学习...
欢迎Java爱好者品读其他排序算法详解：
简单比较排序：http://blog.csdn.net/ysjian_pingcx/article/details/8652091
冒泡排序： http://blog.csdn.net/ysjian_pingcx/article/details/8653732
选择排序： http://blog.csdn.net/ysjian_pingcx/article/details/8656048
直接插入排序：http://blog.csdn.net/ysjian_pingcx/article/details/8674454
快速排序： http://blog.csdn.net/ysjian_pingcx/article/details/8687444
快速排序优化：http://blog.csdn.net/ysjian_pingcx/article/details/8687444