冒泡排序、快速排序、插入排序等

一：java冒泡排序

 

1：定义接口：Sorter

 

public interface Sorter{

   //list：待排序的数组

   public <T extends Comparable<T> > void sort(T[ ] list);

   public <T> void sort(T [] list,Comparator<T> compa); 

}

//创建一个排序的工具类

public class SorterUtils implements Sorter{

@Override  
public <T extends Comparable<T>> void sort(T[] list) {  
        boolean swapped = true;  
        for (int i = 1, len = list.length; i < len && swapped; ++i) {  
            swapped = false;  
            for (int j = 0; j < len - i; ++j) {  
                if (list[j].compareTo(list[j + 1]) > 0) {  
                    T temp = list[j];  
                    list[j] = list[j + 1];  
                    list[j + 1] = temp;  
                    swapped = true;  
                }  
            }  
        }  
    }  

@Override  
public <T> void sort(T[] list, Comparator<T> comp) {  
        boolean swapped = true;  
        for (int i = 1, len = list.length; i < len && swapped; ++i) {  
            swapped = false;  
            for (int j = 0; j < len - i; ++j) {  
                if (comp.compare(list[j], list[j + 1]) > 0) {  
                    T temp = list[j];  
                    list[j] = list[j + 1];  
                    list[j + 1] = temp;  
                    swapped = true;  
                }  
            }  
        }  
    }  
}

 

二、冒泡排序（java版本或者叫c语言版本）

  核心思想：拿前一个数跟后一个数做比较大小。寻找到插入位置，通过中间变量交换两个数。

public static void bubbleSort(int[] arr){
        int temp = 0;//临时变量用作交换
        boolean flag = false; // 标识变量，表示是否进行过交换
        for (int i = 0; i < arr.length - 1; i++) {//比长度少一轮
            //每排序完都确定了最左边的是最小值，所以最左边的不用参与排序，所以这里要-1
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]){
                    flag = true;//表示进行了交换
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
            //假如一轮下来都没有交换，则代表已经是有序的了，直接退出循环
            if (!flag){
                break;
            }else {//否则继续循环，同时要把flag重置为false，这个思想经常用到，要熟悉这个思维
                flag = false;
            }
        }
    }

 

 

 

 

三、插入排序

  核心思想：插入排序的主要思想是将一组数据分为有序的一组数据，和一组无序的数据。有序的数据就是指排序好大小的数据，比如第一次初始化数据，就是取第一个数据，作为有序数据的第一个数。第二或者第n-1个数据分别在第一组数据进行比较，得到插入位置，然后对插入位置后面的数据都统统进行向后移动一位下标，直到插入数据。

public static void insertSort(int[] arr){
        int insertVal;//用来临时存储当前值，因为后面代码后移的时候，当前值会被前面的值覆盖掉
        int insertIndex;//用来存放即arr[当前]的前面这个数的下标
        for (int i = 1; i < arr.length; i++) {//从一开始，一开始就把最左边的数，当成有序的了
            insertVal = arr[i];
            insertIndex = i -1;
            while (insertIndex >= 0 &&  insertVal < arr[insertIndex]){
                arr[insertIndex + 1] = arr[insertIndex];//整体往后移动一位
                insertIndex--;//减一是因为要跟上一个数组值比较
            }
            // 当退出while循环时，说明插入的位置找到, insertIndex + 1
            //这里我们判断是否需要赋值
            if (insertIndex + 1 != i){
                arr[insertIndex + 1] = insertVal;//因为前面多减了一次才退出循环，所以这里是insertIndex + 1
            }
        }
    }

 

 

 

 

四、快速排序

 核心思想：快速排序也叫快排。其实现原理主要是：将一组数据分为两组数据，但是这两组数据（比如：A、B），A的数据一定比B组数据小。然后分别进行控制low和high的下标进行递归，里面涉及两个while循环，一个是A组数据排序，一个是对B组数据进行排序。

public static void quicksort(int[] arr , int start , int end){

        //递归结束条件就是没有数要比较了，意思就是开始的的数等于结束的数就退出递归
        if (start < end){
            int mun = arr[start];//定义参照数，选择最左边的哪个数
            int low = start;//定义左边开始的指针，就是最左边的数
            int high = end;//定义右边开始的指针，就是最右边的数

            //当左边指针小于右边指针开始执行
            while (low < high){
                //当左边low指针小于右边high指针，并且 参照数小于等于右边比较数的时候交换
                //特别注意，是小于等于，不然加入有两个相同的数，循环会卡死！！！！
                while (low < high && mun <= arr[high]){
                    //当参照数小于右边比较数时，不用交换，所以指针前移
                    high--;
                }
                当参照数大于右边比较数时，跟左边指针指向的数交换
                arr[low] = arr[high];

                while (low < high && mun >= arr[low]){
                    //当参照数小于左边比较数时，不用交换，所以指针后移
                    low++;
                }
                //同理
                arr[high] = arr[low];
            }
            //此时，low和high其实都是一样的，当指针重叠时，就结束了此次排序，就把两个指针同时指向的数换成参照数
            //这样就实现了参照数左边都是小的数，右边都是大的数
            arr[low] = mun;
            //进行递归，但不用比较整个数组了，而是本次参照数的左边数组在进行递归比较，右边同理
            //所以左边开始的指针就是数组最左边，左边结束的指针就是本次两个指针重合的地方也就是low或者high
            //右边开始的指针是本次重叠指针的后一个位置，因为重叠指针仔左边会参与比较，结束位置就是数组的最右边
            quicksort(arr,start,low);
            quicksort(arr,low+1,end);
        }
    }

 

 

 

 

注意：资源来自于网上，本人验证算法没问题，分享出来给大伙