时间复杂度

第一节讲解的是时间复杂度问题，所以在这里简单说明一下时间复杂度问题，时间复杂度为代码运行的基于单步时间的长度，时间复杂度在数学层面上为基于极限的一种思考，由于无法得知数据量本身的大小情况，因此算法运算的时间复杂度为当数据趋于无穷的时候需要花费的时间长度。在这里由于趋于无穷，因此将系数不再进行考虑，同时也只考虑最高次项，对其余次项进行忽略。

冒泡排序：

import java.util.Arrays;
public class Code_BubbleSort{ public static void bubbleSort(int arr){if(arr == null ||arr.length<2){return;}for(int end = arr.length-1;end>0;end--){for(int i = 0;i<end;i++){if(arr[i]>arr[i+1]){swap(arr,i,i+1);}}}}public static void swap(int[] arr,int i, int j){int tmp = arr[i];arr[i] = arr[j];arr[j] = tmp;}

对于冒泡排序而言，自身存在的不足是不会将swap转换放到外面单独写一个函数，如果直接在原本的代码中写入转换排序可能导致主体代码过长，反而不容易进行思路的梳理。
冒泡排序中间存在两个循环，两个循环长度N（N-1），在时间复杂度上为o(N^2)。

选择排序

public static void selectionSort(int[] arr){if(arr == null || arr.length<2){return;}for(int i =0;i<arr.length-1;i++){int minIndex = i;for(int j = i+1;j<arr.length;j++){minIndex = arr[j]<arr[minIndex]?j:minIndex;}swap(arr,i,minIndex);}
}
public static void swap(int[] arr,int i,int j){int tmp = arr[i];arr[i] = arr[j];arr[j] = tmp;
}

选择排序跟冒泡排序的区别在于选择排序是寻找最小的数字，将其放在前面顺位依次走，冒泡排序是首先去寻找最大的数值，然后将其放在最后，一个从小到大，一个从大到小，所以两者的时间复杂度相同。

插入排序

public class InsertionSort{public static void insertionSort(int[] arr){if(arr == null || arr.length<2){return;}for(int i=1;i<arr.length;i++){for(int j = i-1;j >=0||arr[j]>arr[j+1];j--){swap(arr,j,j+1);}}
}
public static void swap(int [] arr,int i, int j){int  tmp = arr[i];arr[i] = arr[j];arr[j] = tmp;
}

冒泡排序和选择排序跟数据本身没有任何关系，数据自身的状况不影响时间复杂度，但是插入排序跟数据状况有关系，数据处理实际的时间跟数据有关系，数据自身的是否有序会影响处理时间。因此会有最好情况，最差情况，平均情况。数据最差情况是时间复杂度的表达式。

对数器

随机数组，在笔试阶段需要准备数组的对数器，样本比较器

// test
public static void rightMathod(int [] arr){Arrays.sort(arr);
}
//test
public static int[] generateRandomArray(int size,int value){//math.random()->double[0,1)//(int)((size+1)*Math.random())->[0,size]整数//size = 6,size+1 = 7;//Math.random()->[0,1)*7->[0,7)double//double-> int [0,6] ->int//生成长度随机的数组int[] arr = new int[(int)((size+1)*Math.random());for(int i = 0;i<arr.length;i++){arr[i] = (int)((value+1)*Math.random())-(int)(value*Math.random());}return arr;
}

额外空间复杂度

面对数组中有限几个变量可以将程序跑完，额外空间复杂度为1.
流程跑下去自己申请的空间，跟原来数组长度一样或者为原来数组长度一半那空间复杂度都为N。

递归算法

== 递归时间复杂度计算需要深入理解==
只需要递归复杂度公式满足上面T（N）公式，可以计算出abd三个参数的数值，然后去计算log（b，a）跟d的关系，从而可以计算复杂度。
N为父样本量，N/b为子样本的样本数目，a为拆分发生的次数。后面为除去子过程调用外，剩余的次数。

归并排序

public static void mergeSort(int[] arr){if(arr == null|| arr.length<2){return;}mergeSort(arr,0,arr.length-1);
}
public static void mergeSort(int[] arr,int l,int r){if(l==r){return;}int mid = l+((r-1)>>1);//二进制向右平移，其实本质上相当于与除以2mergeSort(arr,1,mid); //先将左边部分进行内部排序mergeSort(arr,mid+1,r);//再将右边部分进行排序merge(arr,1,mid,r);//最后将左边右边按照下标进行比较，从而实现整体的比较
}
public static void merge(int[] arr,int l,int m,int r){int[] help = new int [r-l+1];int i = 0;int p1 = 1;int p2 = m+1;//下面的判断是主要的分析过程while(p1<=m &&p2<=r){help[i++] = arr[p1] <arr[p2]? arr[p1++]:arr[p2++];}//下面两个其实可以写成if else的形式，两个while循环最终只会执行其中一个 while(p1<m){help[i++] = arr[p1++];}while(p2<=r){help[i++] = arr[p2++];}for(i = 0;i<help.length;i++){arr[l+i] = help[i];}
}

归并排序是在递归排序上延申出来的排序方法，归并排序较冒泡排序等方法简单的地方在于：归并排序将两边数据进行遍历的时候便开始做好排序，提供额外的信息量，从而使得整体算法复杂度降低。冒泡排序等由于排序本身跟数据无关，纯粹根据形式走，数据本身的特点无法利用，因此复杂度较高。
归并排序的时间复杂度为o(N*logN)，空间复杂度为O(N)。（由于在算法执行过程中，创建了一个全新的与原数组长度相同的数组，因此空间复杂度为N）。

小和问题和逆序对问题

public static int smallSum(int[] arr){if(arr == null|| arr.length<2){return 0;}return mergeSort(arr,0,arr.length-1);
}
public static int mergeSort(int[] arr,int l,int r){if(l==r){return 0;}int mid = l+((r-l)>>1);return mergeSort(arr,1,mid)+mergeSort(arr,mid+1,r)+merge(arr,1,mid,r);
}
public static int merge(int[] arr,int l,int m,int r){int[] help = new int[r-l+1];int i = 0;int p1 = 1;int p2 = m+1;int res = 0;while(p1<m && p2<=r){res += arr[p1]<arr[p2]?(r-p2+1)*arr[p1]:0;help[i++] = arr[p1]<arr[p2]?arr[p1++]:arr[p2++];}while(p1<=m){help[i++] = arr[p1++];}while(p2<=r){help[i++] = arr[p2++];}for(i = 0;i<help.length;i++){arr[l+i] = help[i];}return res;
}

对于小和问题的解决方法可以看到，基本依照于归并排列，利用归并排列将数据从小到大进行排列的同时，将左边比右边小的数值可以全部计算出，从而实现结果。

左神算法笔记（一）时间复杂度相关推荐

左神算法笔记01——排序算法
十大排序算法选择排序遍历n次,每次找出i到n-1最小的值,和i位置的值做交换时间复杂度为o(n²) public static void swap(int[] arr,int i,int j){ ...
左神算法（一）下修改版
序言: 此篇内容紧跟在左神算法(一)上修改版之后. 左神算法(一)上修改版左神算法(一)下修改版左神算法(二) 七.二叉树的基本算法 1.二叉树 2.二叉树的先序.中序.后序遍历先序:任何子树的 ...
左神算法中级班第三课[C++代码]
左神算法中级班第三课[C++代码] 第一题:流水线打包问题[阿里原题] 代码第二题代码第三题:打印螺旋矩阵代码第四题代码第五题:判读aim是否在矩阵中代码第七题:topK问题代码 ...
【搞定左神算法初级班】第4节：二叉树及相关常见面试题
目录: 题目1:实现二叉树的先序.中序.后序遍历[递归方式和非递归方式] 题目2:在二叉树中找到一个节点的后继节点题目3:介绍二叉树的序列化和反序列化题目4:折纸问题题目5:判断一棵二叉树是否 ...
左神算法课笔记（一）：时间复杂度、排序、对数器、二分法、异或运算
我们常说,程序=算法+数据结构.结果光搞框架去了,有点说不过去~ 时间复杂度常数时间的操作:如果一个操作的执行时间不以具体样本为转移,每次执行时间都是固定时间.称这样的操作为常数时间操作. 数组的寻 ...
class3 队列、栈和链表（左程云左神算法初级笔记 2018）
class 3 用数组结构实现大小固定的队列和栈 package com.godzuo.java;/*** @author quanquan* @create 2020-04-20-22:36*/ p ...
class4 二叉树（左程云左神算法初级笔记 2018）
class 4 DAY6 实现二叉树的先序.中序.后序遍历,包括递归方式和非递归方式 package com.godzuo.java;import java.util.Stack;/*** @auth ...
左神算法初级班笔记4：二叉树
文章目录 01 | 实现二叉树的先序.中序.后序遍历,包括递归方式和非递归方式 1.递归版本: 2. 非递归版本: 02 | 在二叉树中找到一个节点的后继节点 03 | 介绍二叉树的序列化和反序列化 ...
左神算法课笔记（二）：链表、栈和队列、递归Master公式、哈希表、有序表
单向链表双向链表单链表.双链表最简单的面试题 1.单链表和双链表如何反转 package class02;import java.util.ArrayList;public class Code0 ...

左神算法笔记（一）时间复杂度