算法

最近看了写文章，发现自己的算法了解的比较少，于是开始找教程开始彻底的学习一下算法<<韩顺平-图解java数据结构和算法>>。

1.算法的时间复杂度

1.1.时间频度：一个算法花费的时间与算法中语句执行次数成正比例，那个算法中语句执行次数多，它花费时间就多。一个算法的语句执行次数称为语句频度或者时间频度。记为T(n)

表达式有三个特点：忽略常数项，忽略低次项，忽略系数

1.2时间复杂度

   推算过程：a.一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大的时候，T(n)/f(n)的极限值为不等于0的常数，则称f(n)是T(n)的同数量级函数。记做T(n)=O(f(n)),称O(f(n))为算法的渐进时间复杂度，简称时间读咋读。

   b.T(n)不同，但是时间复杂不到可能相同。如T(n)=n²+7n+6 与 T(n)=3n²+2n+2他们的T(n)不同，但是时间复杂度相同，都是O(n²)

   c.计算时间复杂度的方法：

　　　用常数1代替运行时间中的所有加法常数

　　　修改后的运行次数函数中，只保留最高阶项

　　   去除最高阶项的系数

  常见时间复杂度

　　　常数阶 O(1)

　　　对数阶 O(log₂n)

　　　线性阶O(n)

 　　  线性对数阶O(log₂n)

　　   平方阶 O(n²)

　　   立方阶O(n³)

　　   k次方阶O(n^k)

　　　指数阶O(2^n)

排序算法：

1.冒泡排序 时间复杂度（O(n^2)）：

　　通过对待排序下序列从前往后（从下标娇小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐往上冒。因为排序的过程中，各元素不断的接近自己的位置，如果一趟比较下来没有进行过交换，说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行交换，从而减少不必要的比较。

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {9,-1,22,10,33,45};
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            boolean flag = true; // 优化标识，当一次循环时所有位置没有发生变化，则标识该序列已经时有序的，可以跳出循环
            for (int j = 0; j < arr.length-1-i; j++) {
                if(arr[i]>arr[i+1]){
                    temp = arr[i+1];
                    arr[i+1]=arr[i];
                    arr[i]=temp;
                    flag=false;
                }
                if(flag){
                    break;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

2.选择排序 时间复杂度（O(n^2)）：

　　第一次从arr[0]-arr[n-1]中选择最小值，与arr[0]交换，第二次从arr[1]-arr[n-1]中选择最小值，与arr[1]进行交换，....总共通过n-1次没到一个排序从最小到最大的排序

 public static void selectSott(int[] arr) {
        int min = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            min = arr[i];
            int minIndex = i;
            for (int j = i; j < arr.length - 1; j++) {
                if (min > arr[j + 1]) {
                    min = arr[j+1];
                    minIndex=j+1;
                }
            }
            arr[minIndex]=arr[i];
            arr[i] = min;
        }
    }

3.插入排序

　　插入式排序属于内部排序发，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中包含一个元素，无序表中包含n-1个元素，排序过程中每次从无序表中选取第一个元素，把它与有序表中的每个元素进行比较，将它插入到有序表中适当的位置，使之成为新的有序表

    public static void inertSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int insertIndex = i;
            int insertVal = arr[i + 1];
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            if (insertIndex + 1 != i) {
                arr[insertIndex + 1] = insertVal;
            }
        }

    }

　　

4.希尔算法

　　　在直接插入排序算法中，每次插入一个数，使有序序列只增加1个节点，并且对插入下一个数没有提供任何帮助。如果比较相隔较远距离（称为增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除多个元素交换。D.L.shell于1959年在以他名字命名的排序算法中实现了这一思想。算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。下面的函数是一个希尔排序算法的一个实现，初次取序列的一半为增量，以后每次减半，直到增量为1。希尔排序是不稳定的。

// 希尔排序法一：交换法
　　 // 首先分为5组数据，每组2个数据     9，7  2，8  3，6   4，5   1，0
    // 排序之后在分为2组， 每组5个数据
    public static void shellSort(int[] arr) {
        int temp = 0;
        for (int i = arr.length / 2; i > 0; i = i / 2) {
            for (int j = i; j < arr.length; j++) {
                for (int k = j - i; k >= 0; k = k - i) {
                    if (arr[k] > arr[k + i]) {
                        temp = arr[k];
                        arr[k] = arr[k + i];
                        arr[k + i] = temp;
                    }
                }
            }
        }
    }

// 希尔排序法二  移动插入（效率比一高）
public static void shellSort2(int[] arr) {
    for (int i = arr.length / 2; i > 0; i = i / 2) {
        for (int j = i; j < arr.length; j++) {
            int index = j;
            int indexValue = arr[index];
            while (index - i >= 0 && indexValue < arr[index - i]) {
                arr[index] = arr[index - i];
                index = index - i;
            }
            arr[index] = indexValue;
        }
    }
}

　

5.快速排序

　　是对冒泡排序的改进，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后在按此方法分对两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

 public static void quickSort(int[] arr, int left, int right) {
        int l = left;
        int r = right;
        int pivot = arr[(left + right) / 2];
        int temp = 0;
        while (l < r) {
            while (arr[l] < pivot) {
                l++;
            }
            while (arr[r] > pivot) {
                r--;
            }
            if (l >= r) {
                break;
            }
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            if (arr[l] == pivot) {
                r--;
            }
            if (arr[r] == pivot) {
                l++;
            }
        }
        if (l == r) {
            l++;
            r--;
        }
        if (left < r) {
            quickSort(arr, left, r);
        }
        if (right > l) {
            quickSort(arr, l, right);
        }
    }

　　

6.归并排序

　　是利用归并的思想实现排序方法，该算法采用经典的分治策略（将问题分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的各答案修补在一起，即分而治之）

public static void mergeSort(int arr[],int left,int right,int[] temp){
        if(left< right){
            int mid = (left + right) / 2;
            mergeSort(arr,left,mid,temp);
            mergeSort(arr,mid+1,right,temp);
            merge(arr,left,mid,right,temp);
        }
    }


    // 合并
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left; // 初始化i，左边有序序列的初始索引
        int j = mid + 1; // 初始化j，右边有序序列的初始索引
        int t = 0;//指向temp数组的当前索引

        while (i <= mid && j <= right) {
            if (arr[i] < arr[j]) {
                temp[t] = arr[i];
                t += 1;
                i += 1;
            } else {
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }
        }
        while (i <= mid) {
            temp[t] = arr[i];
            t += 1;
            i += 1;
        }
        while (j <= right) {
            temp[t] = arr[j];
            j += 1;
            t += 1;
        }

        t=0;
        int tempLeft = left;
        while (tempLeft<=right){
            arr[tempLeft] = temp[t];
            t+=1;
            tempLeft+=1;
        }
    }

　　

7.基数排序

　　将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。 

 public static void radixSort(int[] arr) {
        //1. 得到数组中最大的数的位数
        int max = arr[0]; //假设第一数就是最大数
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        //得到最大数是几位数
        int maxLength = (max + "").length();
        //定义一个二维数组，表示 10 个桶, 每个桶就是一个一维数组
        //说明
        //1. 二维数组包含 10 个一维数组
        //2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为 arr.length //3. 名明确，基数排序是使用空间换时间的经典算法
        int[][] bucket = new int[10][arr.length];
        //为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数 //可以这里理解
        //比如:bucketElementCounts[0] , 记录的就是 bucket[0] 桶的放入数据个数
        int[] bucketElementCounts = new int[10];
        //这里我们使用循环将代码处理
        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
            //(针对每个元素的对应位进行排序处理)， 第一次是个位，第二次是十位，第三次是百位..
            for (int j = 0; j < arr.length; j++) {
                //取出每个元素的对应位的值
                int digitOfElement = arr[j] / n % 10;
                //放入到对应的桶中
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
                bucketElementCounts[digitOfElement]++;
            } //按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
            int index = 0;
            //遍历每一桶，并将桶中是数据，放入到原数组
            for (int k = 0; k < bucketElementCounts.length; k++) {
                //如果桶中，有数据，我们才放入到原数组
                if (bucketElementCounts[k] != 0) {
                    //循环该桶即第 k 个桶(即第 k 个一维数组), 放入
                    for (int l = 0; l < bucketElementCounts[k]; l++) {
                        //取出元素放入到 arr
                        arr[index++] = bucket[k][l];
                    }
                }
                //第 i+1 轮处理后，需要将每个 bucketElementCounts[k] = 0 !!!!
                bucketElementCounts[k] = 0;
            }
        }
    }

常用算法比较：

1. )  稳定:如果a原本在b前面，而a=b，排序之后a仍然在b的前面;

2. )  不稳定:如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面;

3. )  内排序:所有排序操作都在内存中完成;

4. )  外排序:由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行;

5. )  时间复杂度:一个算法执行所耗费的时间。

6. )  空间复杂度:运行完一个程序所需内存的大小。

7. )  n: 数据规模

8. )  k: “桶”的个数

9. )  In-place: 不占用额外内存

　　10. ) Out-place: 占用额外内存