java常用排序算法

1.冒泡排序：

第i趟，第leng-1个元素与前面[length-1,i]个元素相邻两两比较，找到最小值，放到数组最前面，到时间复杂 o(n2)

public class DubboSort {    public static void main(String[] args) {        int[] values = {1, 3, 4, 5, 4, 7, 2, 1};        dubboSort(values);        for (int i = 0; i < values.length; ++i) {            System.out.println(values[i]);        }    }    private static void dubboSort(int[] values) {        int length = values.length;        for (int i = 0; i < length - 1; ++i) {            for (int j = length - 1; j > i; j--) {                if (values[j] < values[j - 1]) {                    int temp = values[j];                    values[j] = values[j - 1];                    values[j - 1] = temp;                }            }        }    }}

2.选择排序：每趟排序，第i(大于等于1)到第length-1-i个位置的元素与第0个元素比较，如果大于第0个元素，则第0个元素下标移动，直到找到最大值，以及最大值下标，将最大值存放到length-1-i位置上

package com.jd.app.server.soa.ware.web;/** * Created with IntelliJ IDEA. * User: yfliujin * Date: 14-4-4 * Time: 上午10:09 * To change this template use File | Settings | File Templates. */public class SelectSort {    public static void main(String[] args) {        int[] values = {1, 3, 5, 2, 4, 2, 3,0,0};        selectSort(values);        for (int i = 0; i < values.length; ++i) {            System.out.println(values[i]);        }    }    //第i趟排序将最大的数放在数组的第length-1-i个位置上    //每趟排序，第i(大于等于1)到第length-1-i个位置的元素与第0个元素比较，如果大于第0个元素，则第0个元素下标移动，直到找到最大值，以及最大值下标    private static void selectSort(int[] values) {        int index;        int length = values.length;        for (int i = 0; i < length - 1; ++i) {            index = 0;            for (int j = 1; j < length - i; j++) {                if (values[j] > values[index]) {                    index = j;                }            }            //将最大值values[index]与values[length-1-i]交换            int temp = values[index];            values[index] = values[length - 1 - i];            values[length - i - 1] = temp;        }    }}

3.快速排序: 通过一趟排序将要排序的数据分割成独立的两部分， 其中一部分的所有数据都比另外一部分的所有数据都要小，

  然后再按此方法对这两部分数据分别进行快速排序， 整个排序过程可以递归进行，以此达到整个数据变成有序序列。

两个索引i和j分别指向数组第一个和最后一个元素，key为数组第一个元素，i向右边移动，找到比key大的元素，j向左移动，找到比key小的元素

 public class QuickSort {    public static void main(String[] args) {      int[] values={3,4,5,1,2,1,2,3};        quickSort(values,0,values.length-1);        for(int i=0;i<values.length;++i){            System.out.println(values[i]+"");        }    }    private static void quickSort(int[] values,int start,int end){        try {            if(start<end){                int middle = getMiddle(values,start,end);                quickSort(values,start,middle-1);                quickSort(values,middle+1,end);            }        } catch (Exception e) {            e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.            System.out.println(e);;        }    }    private static int getMiddle(int[] values, int start, int end) {        int key= values[start];        while(start<end){            //从右边开始查找比key小的数，            while(values[end]>=key && end>start){                end--;            }            values[start]=values[end];            //从左边开始查找比key大的数            while (values[start]<=key && start<end){                start++;            }            values[end]=values[start];        }        values[start]=key;        return start;  //To change body of created methods use File | Settings | File Templates.    }}

 4直接插入排序
 从第2个元素开始，直到最后一个元素，如果第i个元素比，比前面的第j个元素小，则第j个元素后移，否则，第j+1个元素就是第i个元素的位置

  算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。

 public static void sort(int[] values) {        for (int i = 1; i < values.length; ++i) {            int j = i - 1;            int temp =values[i];            while (j >= 0) {                if(temp<values[j]){                    values[j+1]=values[j];                } else {                    break;                }                j--;            }            values[j+1]=temp;        }    }