四种排序算法实现

目录

冒泡排序

冒泡算法

  1. 比较相邻的元素。如果左边比右边大，就互换位置
  2. 对每一对相邻元素作同样的工作，从第一对到最后一对，完成后，最后元素为最大值

源代码（冒泡排序）

//冒泡排序
public static void bubbleSort(int[] slist) {
//从头开始遍历
    for(int i = 0;i < slist.length-1; i++) {
        //一一对比
        for(int j = i+1;j < slist.length; j++) {
        //如果前面的数大于后边的数，冒泡往后排
        if(slist[i] > slist[j]) {
            //交换两个值
                int temp = slist[i];
                slist[i] = slist[j];
                slist[j] = temp;
            }
        }
//System.out.println(Arrays.toString(slist));
    }
}

选择排序

选择算法

  1. 找到数组中最大或者最小的元素，将它和数组的第一个元素交换位置
  2. 剩下的元素中，最小值与第二个元素交换位置

源代码（选择排序）

//选择排序
public static void selectionSort(int[] slist) {

    //利用循环进行遍历
    for(int i = 0;i < slist.length;i++ ) {
        //假设第一个值为最小值
        int min = i;
        //遍历获取最小值位置
        for(int j = i; j < slist.length;j++) {
            if(slist[min] > slist[j]) {
                min = j;
            }
        }
        //将该位置与小值交换
        int temp = slist[i];
        slist[i] = slist[min];
        slist[min] = temp;
    }
}

插入排序

插入算法

  1. 从第一个元素开始，将此元素视为已排序
  2. 取下一元素，在已经排序的序列中从后向前扫描
  3. 如果已排序序列元素大于待插入元素，将序列元素后移
  4. 重复步骤3，直到找到适合位置
  5. 将新元素插入到该位置后
  6. 重复2~5

源代码（插入排序）

//插入排序
public static void insertSort(int[] slist) {
    //将list[i]插入到list[0]...list[i-1]中
    for(int i = 1; i < slist.length;i++) {
        int temp = slist[i];
        int j = i-1;
        //将值往后移动
        for(;j >= 0 && slist[j] > temp;j--) {
            slist[j+1] = slist[j];
        }
        //在适当位置插入该值
        slist[j+1] = temp;
    }
}

快速排序

快速排序算法

  1. 从序列中挑出一个元素作为“基准”（一般采用中间元素）
  2. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。
  3. 递归地把小于基准值元素的子序列和大于基准值元素的子序列排序。

源代码（快速排序）

public static void quickSort(int[] slist,int head, int tail) {
    //如果该段一第一个下标值等于最后一个下标值，序列为空，序列长度小于等于1，结束
    if(head >= tail || slist == null || slist.length <= 1) {
        return ;
    }
    //head，tail值递归时仍需使用，因此定义i&j，取mid为基准
    int i = head,j = tail, mid = slist[(head+tail)/2];
    //因为i值会慢慢和j值接近，所以当i小于或等于j时保持循环，对比基准两边的值，将大于基准值的移到基准右边，将小于基准值的移到基准值左边
    while(i < j) {
        //在序列左边寻找大于基准的值
        while(slist[i] < mid && i < j) { ++i; }
        //在序列右边寻找小于基准的值
        while(slist[j] > mid && i < j) { --j; }
        //如果i等于j，退出当前循环
        if(i == j) { break; }
        //交换两个位置的值
        int temp = slist[i];
        slist[i] = slist[j];
        slist[j] = temp;
    }
    // 左边子序列递归
    quickSort(slist, head, i-1);
    //右边子序列递归
    quickSort(slist, i+1 , tail);
}

总结

名称 稳定性 时间复杂度 空间复杂度
冒泡排序 稳定 O(n^2) O(1)
选择排序 不稳定 O(n^2) O(1)
插入排序 稳定 O(n^2) O(1)
快速排序 不稳定 O(n log n)(最坏O(n^2)) O(log n)

References

插入排序

排序算法

posted on 2019-03-17 23:12  Kn0w_N0ThInG  阅读(200)  评论(0)  编辑  收藏  举报

导航