最近在学数据结构，所以还是来做一些笔记吧
我准备这个排序算法写两个，这个是其中之一

这里的话我就讲讲冒泡排序、快速排序、插入排序、希尔排序

冒泡排序法

不得不说这个排序算法是最经典的。

import java.util.Arrays;

public class Bubblesort {
    public static void main(String[] args) {
        //新建一个数组
        int arr[] = new int [] {2,99,4,5,6,22,1,33,66,88};
        System.out.println(Arrays.toString(arr));
        bubblesort(arr);
        System.out.println(Arrays.toString(arr));
    }

    //冒泡排序法
    /**
     * 基本的思路就是控制需要比较的轮数，也就是arr.length-1
     * @param arr
     */
    public static void bubblesort(int arr[]) {
        //总共是需要进行length-1次排序
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

插入排序法

这个排序算法的实现比较简单
主要就是每两个数字的两两进行比较，如果右边的数大于左边的数，那就不替换。反之替换

import java.util.Arrays;

//插入排序
//但是这个排序效率比较慢，就是因为如果前面都是按顺序来着的，后面突然来了一个比较小的数字那么这个工作量就开始大起来了
public class InsertSort {
    public static void main(String[] args) {
        int arr[] = new int [] {1,5,2,9,6,4,8,3,6};
        System.out.println(Arrays.toString(arr));
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void sort(int arr[]) {
        //先从第二个数字遍历所有的数字
        for (int i = 1; i < arr.length; i++) {
            //如果当前的数字小于前面的的那个数字的话
            if (arr[i]<arr[i-1]) {
                //就先保存当前的这个数字
                int temp = arr[i];
                int j;   //这里是一个局部的变量

                //就替换数字把左边大的数字替换右边小的数字
                for(j=i-1;j>=0&&temp<arr[j];j--) {
                    arr[j+1] = arr[j];
                }

                //把temp里的数字替换回来
                arr[j+1] = temp;
            }
        }
    }
}

快速排序

我同学说这个是最效率最高的排序算法
这个排序算法的特点就是有一个基线
实现的方法就是去一个数作为基准的数（一般取第一个），然后遍历数组中所有的数字，如果数字比这个大那么就丢到右边，小的话就丢到左边。
然后就分成了两半，左边一半是比基准数小的，右边一半是比基准数大的。
现在又重新开始排序以左边第一个作为基准数，比这个大的就丢在右边。。。
就是这样不断的被分成了两半，这样的递归方法就是这个算法的思想

代码如下

import java.util.Arrays;

//快速排序
public class QuickSort {
    public static void main(String[] args) {
        int arr[]  = new int [] {4,10,5,2,3,6,7,1,8,9,0,11};
        System.out.println(Arrays.toString(arr));
        sort(arr, 0, arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

    //这里要注意的就是要确定作为基准的数字（一般取第一个），然后就是最后一个数字
    public static void sort(int arr[],int start,int end) {

        if (start<end) {
            //首先要找到一基准数，一般 我们取第一个数字
            int stard  = arr[start];
            //这里就是记录需要排序的下标
            int low = start;
            int high = end;

            //左边的下标low小于右边的下标high的时候就执行这条语句，当low与high重合的时候（low不大于high），也就意味着本次循环的快速排序结束
            while(low<high) {
                //这条循环的意思就是如果arr[high]这个右边的数大于基数的话，那就只要把high这个下标左移一位就可以了
                while(low<high&&stard<=arr[high]) {
                    high--;
                }
                //右边的数字替换左边的数字
                arr[low] = arr[high];

                //这里就是跟上面的情况相反
                while(low<high&&arr[low]<=stard) {
                    low++;
                }
                //如果左边的arr[low]大于stand的时候就是把左边的数字替换到右边的数字
                arr[high] = arr[low];
                //然后就是不要忘记了把基准的数放回来
            }
            arr[low] = stard;
            //处理所有小的数字
            sort(arr, start, low);
            //处理所有大的数字
            sort(arr, low+1, end);
        }

    }
}

希尔排序

据说这是一个人的名字
这个算法就是为了解决上面的插入排序效率低的问题的

原理如下：首先我们要定义一个增量（足长），这个增量是怎么定义的呢
就是数组的长度除以2。也就是 arr.length/2 就是这个样子，取出来的数为整数
不能是小数
第一轮排序：我们把足长进行冒泡排序。相当数粗略的排序
第二轮排序:也就是当足长为1的时候。我们就进行插入排序、可能是因为插入排序的这个算法对相对有序的数组排序的更快一点

import java.util.Arrays;

//希尔排序，这个希尔排序其实就是上面快速排序的优化版本
public class ShellSort {
    public static void main(String[] args) {
        int arr[] = new int [] {4,2,4,1,9,6,0,5};
        System.out.println(Arrays.toString(arr));
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void sort(int arr[]) {
        //遍历所有的增量（步长）
        for(int d=arr.length/2; d>0; d/=2) {
            for (int i = d; i < arr.length; i++) {
                for (int j = i-d; j >=0; j-=d) {
                    if (arr[j]>arr[j+d]) {
                        int temp = arr[j];
                        arr[j] = arr[j+d];
                        arr[j+d] = temp;
                    }
                }
            }
        }
    }
}

这里面感觉还是希尔排序最难理解
其他的其实感觉也不是那么的难

其还是感觉自己很菜

现在我才是来入个门啊，其实也是蛮难的、

好多的大佬就在搞人工智能、卷积神经网络
我就是想问 can i do this？

真的好难好难啊

一个好奇的人