【诈尸+开新坑】算法笔记—简单排序

前言

  博主又复活了，这边会通过博客的形式去记录算法和数据结构学习过程中的一些笔记，同时粘贴一些自己写的code，主要目的是为了练习打字速度，其次用于记录。如果能对其他人有一点点的影响，那我很欣慰了。大概就说这么多，不废话，直接上笔记！

简单排序

  简单排序里有三大排序算法，分别为：冒泡排序，选择排序，插入排序。三个排序算法的时间复杂度其实都是O(n^2)，如果对算法时间复杂度有了解的话，n^2的时间复杂度算法在随着输入规模n的增大会变得相当耗时，不是一个解决大规模输入的好算法。那问题来了，这算法有啥用？
  当然有用啦，首先你面试，考的基础点，让你手写个简单排序，你不会？OH，GG my friend！所以这三个简单算法直接背会，然后理解三个的区别就好，同时也为后面复杂算法打基础了嘛！

首先先定义一些通用接口和类吧（不要嫌麻烦嘛，这样做也体现了JavaOOP的思想嘛）

• 通用接口Sort

//定义一个通用接口，排序需要用到的一些方法写在这里！
public interface Sort {
    //比较两个元素的大小  a>b = ture
    public boolean bigger(Comparable a,Comparable b);
    //交换 i j两个下标的值
    public void exchange(Comparable[] a,int i,int j);
}

• 抽象类AbstractSort

public abstract class AbstractSort implements Sort{
	//具体算法类需要实现这个方法
    public abstract void sort(Comparable[] a);

    @Override
    public boolean bigger(Comparable a, Comparable b) {
        return a.compareTo(b)>0;
    }

    @Override
    public void exchange(Comparable[] a, int i, int j) {
        Comparable temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

冒泡算法

冒泡嘛，就是从最左开始，那第一个元素和剩下的元素一个个从左到右比较大小，谁大谁往后排（有点像小学排队的规则啊，小时候个子小没参与过，岂可休！），直接贴代码。

public class Bobble extends AbstractSort {
    @Override
    public void sort(Comparable[] a) {
        for (int i = 0;i<a.length;i++){
            for (int j=i+1;j<a.length;j++){
            	//谁大谁换位站后面
                if (bigger(a[i],a[j])){
                    exchange(a,i,j);
                }
            }
        }
    }
}

有人说啦，你你你贴个代码几个意思，谁找不到代码啊？来你这儿就这？就这？就这？
emmm,确实，能理解的也不会来抄个代码，除非你是考场上打开了这文章…啊没事，后期会将思路和图示编辑上来的，最近也是加紧学习，先做个记录，后续会补的。

选择算法

选择嘛，从第一个元素开始和后面的比个头。谁小把流动红旗“最小弟弟”给谁，然后和开头那位换个位置。然后从第二个开始继续和后面的做比较，以此类推…

public class Selection extends AbstractSort {
    @Override
    public void sort(Comparable[] a) {
        for (int i = 0; i < a.length ; i++) {
        	//流动红旗 最小认证嘛
            int minIndex = i;
            for (int j = i + 1; j < a.length; j++) {
                if (bigger(a[minIndex], a[j])) {
                    minIndex = j;
                }
            }
            exchange(a, i, minIndex);
        }
    }
}

插入算法

扑克牌总玩过吧，就是你一张张摸牌的时候，从左到右码牌那个意思。手里的排是排好的，拿一张新牌从后面一张张比，比到比手里牌小的位置后就插入，然后把所有排码好为止。

public class Insertion extends AbstractSort {

    @Override
    public void sort(Comparable[] a) {
        for (int i = 1; i < a.length; i++) {
            for (int j = i; j >= 1; j--) {
                if (bigger(a[j-1],a[j])){
                    exchange(a,j-1,j);
                } else {
                    break;
                }
            }
        }
    }
}

运行试试

三个算法其实都差不多，我加了个时间tag来看看他们的性能，其实数据量太小，没反映出他们的差距，后续写个测试用例来测测！

public class Test {
    public static void main(String[] args) {
        Integer[] ary_booble = {3,6,1,8,5,2,7,4};
        Integer[] ary_select = {3,6,1,8,5,2,7,4};;
        Integer[] ary_insert = {3,6,1,8,5,2,7,4};;
        // [1, 2, 3, 4, 5, 6, 7, 8]
        //冒泡排序 O(n^2)
        Bobble bobble = new Bobble();
        bobble.sort(ary_booble);
        System.out.println("冒泡排序结果："+Arrays.toString(ary_booble));
        //选择排序 O(n^2)
        Selection selection = new Selection();
        selection.sort(ary_select);
        System.out.println("选择排序结果："+Arrays.toString(ary_select));
        //插入排序 O(n^2)
        Insertion insertion = new Insertion();
        insertion.sort(ary_insert);
        System.out.println("插入排序结果："+Arrays.toString(ary_insert));
    }
}

运行结果

冒泡排序结果：[1, 2, 3, 4, 5, 6, 7, 8]
选择排序结果：[1, 2, 3, 4, 5, 6, 7, 8]
插入排序结果：[1, 2, 3, 4, 5, 6, 7, 8]

三个算法得直接默写的程度，太基础了兄弟们！先把code贴上来，后续补图和心得，求个三连，这个真的对我很重…不好意思，串台了。