交换排序算法之冒泡排序和快速排序，java简单实现

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Sorting;

import java.util.Scanner;

/**
 *
 * @author Biaoming
 */
public class ExchangeSort {

    public static void main(String[] args) {
        ExchangeSort mysort = new ExchangeSort();
        Scanner myscan = new Scanner(System.in);
        int listLength = myscan.nextInt();//获取输入数组长度
        int[] unSortedlist = new int[listLength];
        for (int i = 0; i < listLength; i++) {
            unSortedlist[i] = myscan.nextInt();//获取输入数组元素
        }
        //mysort.bubbleSort(unSortedlist);//冒泡排序
        mysort.quickSort(unSortedlist,0,listLength-1);//快速排序
        for (int i = 0; i < listLength; i++) {
            System.out.print(unSortedlist[i] + " ");//输出排序后数组元素
        }
    }

    public void bubbleSort(int[] list) {
        int i, j, tmpInt;
        boolean Exchange;
        for (i = 0; i < list.length - 1; i++) {
            Exchange = false;
            for (j = list.length - 1; j > 0; j--) {
                if (list[j] < list[j - 1]) {
                    tmpInt = list[j];
                    list[j] = list[j - 1];
                    list[j - 1] = tmpInt;
                    Exchange = true;
                }
            }
            if (!Exchange) {
                break;
            }
        }
    }

    private int partition(int[] list, int low, int high) {
        int pivotsvalue = list[low];
        while (low < high) {
            while (low < high && list[high] > pivotsvalue) {
                high--;
            }
            if(low<high){
                list[low++] = list[high];
            }
            while(low<high && list[low] < pivotsvalue){
                low++;
            }
            if(low<high){
                list[high--] = list[low];
            }
        }
        list[low] = pivotsvalue;
        return low;
    }

    public void quickSort(int[] list, int low, int high) {
        int pivotspos;
        if (low < high) {
            pivotspos = partition(list, low, high);
            quickSort(list, low, pivotspos - 1);
            quickSort(list, pivotspos + 1, high);
        }
    }
}

冒泡排序算法的时间复杂度最好是O(n)，最坏是O(n²)。

快速排序算法的时间复杂度最好是O(nlgn)，最坏是O(n²)。

快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；

但快速排序是不稳定的，而冒泡排序算法是稳定的

总体而言，存在不相邻交换的排序算法一般是不稳定的，相邻交换的排序算法一般是稳定的，对于相邻交换的稳定排序算法，通过控制交换条件可以转换成不稳定排序算法如希尔排序。

在写博文的时候，发现冒泡排序还可以对内循环进行优化，冒泡排序算法的外循环每循环一次就会将无序的数组元素中的最小值，上浮到数组第一位，但是第二次外循环的时候，按照上面的代码还会执行数组第二位元素和第一位元素的比较，其实这一步是多余的，就是说外循环循环一次时候，数组已经形成了有序区和无序区，比如第一次外循环后，数组元素的第一位就是有序区，第二次外循环后，数组元素的一二位组成了有序区，其余为无序区，优化就是再外循环次数I的时候，内循环不必比较有序区，所以就是修改内循环的条件，如下

public void bubbleSort(int[] list) {
        int i, j, tmpInt;
        boolean Exchange;
        for (i = 0; i < list.length - 1; i++) {
            Exchange = false;
            for (j = list.length - 1; j > i; j--) {//这里内循环的条件改为i
                if (list[j] < list[j - 1]) {
                    tmpInt = list[j];
                    list[j] = list[j - 1];
                    list[j - 1] = tmpInt;
                    Exchange = true;
                }
            }
            if (!Exchange) {
                break;
            }
        }
    }