JAVA基础笔记三——几种排序算法

插入排序
直接插入排序：
算法思想：第一次循环时，比较a[0]和a[1]的大小，如果a[0]>a[1],则将a[1]插入到a[1]之前；第二次循环，比较a[2]和a[1]的大小，如果a[1]>a[2]，将a[2]插入到a[1]之前，然后比较a[2]和a[0],如果a[0]>a[2],则将a[2]插入到a[0]之前….依次循环，直到a[n-1]插入完为止，这时数组元素就已经排好了序。

`public static void insertSort(int[] a,int n) {
    int i,j,temp;
    for(i=0;i<n-1;i++) {
        temp = a[i+1];
        j = i;
        while(j>-1 && a[j]>temp) {
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = temp;
    }
}`

希尔排序：
算法思想：将待排序的数据元素分成若干小组，对每个小组内的数据用直接插入排序，小组的个数不断减少。当完成所有数据元素在同一个小组的排序后，排序过程结束。

    public static void hillSort(int[] a,int n,int[] d,int numOfD) {
        int i,j,k,m,temp,span;
        for(i=0;i<numOfD;i++) {
            span = d[i];
            for(j=0;j<span;j++) {      //一共span个小组
                for(k=0;k<n-span;k = k+span) {     //增量是span
                    m = k;
                    temp = a[k+span];
                    while(m>-1 && a[m]>temp) {
                        a[m+span] = a[m];
                        m = m - span;
                    }
                    a[m+span] = temp;

                }
            }
        }
    }

选择排序：
直接选择排序：
算法思想：
选择集合中最小的数据元素，与第一个数据元素进行交换，然后选取不包括第一个数据元素的的最小元素与第二个数据元素进行交换，依次循环，直到集合只剩下一个元素，排序完成。

public static void selectSort(int[] a,int n) {
        int i,j,temp,small;
        for(i=0;i<n-1;i++) {
            small = i;
            for(j=i+1;j<n;j++) {
                if(a[j]<a[small])
                    small = j;  
            }   
            if(small != i) {
                temp = a[i];
                a[i] = a[small];
                a[small] = temp;
            }
        }
    }

堆排序：

交换排序：利用交换元素的位置进行排序的方法
冒泡排序：
算法思想：
循环进行n-1趟排序。第一趟排序，依次比较a[i]和a[i+1]（i=0,1,2…n-2）的大小，如果a[i]>a[i+1],则交换两个元素，这样最大的元素被放在a[n-1]处；进行第二趟排序，数据元素个数减少1，即为n-1，然后做相同的操作，依次循环直到最小的元素放在a[1],a[0]，排序结束。

    public static void bubbleSort(int[] a,int n) {
        int i,j,temp;
        for(i=0;i<n-1;i++) {
            for(j=0;j<n-i-1;j++) {
                if(a[j]>a[j+1]) {
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
    }

快速排序：是一种二叉树结构的交换排序算法
算法思想：
low，high为数组的低高端下标，从数组中任意去一个元素（一般a[low]）作为标准，调整数组中各个元素的位置，使得比标准元素小的数据元素排在标准元素的左边，比标准元素大的数据元素排在标准元素的右边，这样一次过程结束后，将数组分成了两个子数组，在用类同的方法进行递归，递归结束的条件是high>=low。

   public static void quickSort(int[] a,int low,int high) {
        int i = low,j = high,temp;
        temp = a[low];
        while(i<j) {
            while(i<j && temp<=a[j])
                j--;
            if(temp>a[j]) {
                a[i] = a[j];
                i++;
            }
            while(i<j && temp>a[i])
                i++;
            if(temp<=a[i]) {
                a[j] = a[i];
                j--;
            }
        }
        a[i] = temp;
        if(low<i) quickSort(a,low,i);
        if(i<high) quickSort(a, i+1, high);
    }