数据结构与算法.02排序基础

排序

排序：将给定的数据按照一定的规则进行排序，比如按照商品的价格，折扣，id号等等。

冒泡排序(bubble)

• 原理：比较相邻的元素，若后一个元素较大，则进行交换

    //冒泡排序(O(n^2))
    public static void sort(Comparable[] a) {
        for (int i = a.length-1; i>0 ;i--) {
            for (int j = 0; j < i ; j++) {
                //比较索引j和j+1处的值
                if (greater(a[j],a[j+1])) {
                    exchange(a,j,j+1);
                }
            }
        }
    }
    //比较v元素是否大于w元素
    public static boolean greater(Comparable v,Comparable w) {
        return v.compareTo(w)>0;
    }
    //交换元素
    private static void exchange(Comparable[] a,int i,int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

选择排序(select)

每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引处的值位最小值，最后可以找到最小值所在的索引。
交换第一个索引处和最小值所在索引处的值。

代码实现：

package DataStructure.sort.Select;
public class SelectSort {
    //sort
    public static void sort(Comparable[] a) {
        for (int i = 0; i <= a.length-2; i++) {
            //定义一个变量，记录最小元素所在索引，默认为首位
            int minIndex = i;
            for (int j = i+1; j <a.length ; j++) {
                //需要比较最小索引minIndex与j索引处的值
                if (greater(a[minIndex],a[j])) {
                    minIndex = j;
                }
            }
            //交换最小元素所在索引minIndex处的值和i处的值
            exchange(a,i,minIndex);
        }
    }
    //compare
    private static boolean greater(Comparable v,Comparable w) {
        return v.compareTo(w)>0;
    }
    //exchange
    private static void exchange(Comparable[] a,int i,int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}
//test
package DataStructure.sort.Select;
import java.util.Arrays;
public class SelectSortTest {
    public static void main(String[] args) {
        Integer[] a1 = {12,13,1,15,34,89,0};
        SelectSort.sort(a1);
        System.out.println(Arrays.toString(a1));
    }
}

时间复杂度分析

选择排序使用了双层for循环，外层循环完成了数据交换，内层循环完成了数据比较。

• 数据比较次数：(N-1)+(N-2)+…+2+1 = N^2/2-N/2
• 数据交换次数：N-1
• 时间复杂度N^2/2-N/2 ≈ O(N^2)，当排序元素少时，可以使用。

插入排序(insert)

插入排序是将所有元素分为两组，已经排序的和未排序的；找到未排序的组中的第一个元素，向已经排序的组中进行插入；倒序遍历已经排序的元素，一次和待插入元素进行比较，直到待插入元素可插入，其他的元素后移。
代码实现：

public class InsertSort {
    //sort
    public static void sort(Comparable[] a) {
        for (int i = 1; i < a.length; i++) {
            for (int j = i; j > 0; j--) {
                //比较索引j处的值和索引j-1处的值(x)，x大则交换
                //如果x小则退出循环
                if (greater(a[j-1],a[j])) {
                    exchange(a,j-1,j);
                }else{
                    break;
                }
            }
        }
    }
    //compare
    private static boolean greater(Comparable a,Comparable b) {
        return a.compareTo(b) > 0;
    }
    //exchange
    private static void exchange(Comparable[] a,int i,int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

时间复杂度分析

• 使用双层for循环
• 比较次数：N^2/2-N/2
• 交换次数：N^2/2-N/2
• 时间复杂度为：O(N^2)