排序：

冒泡排序：时间O（n2) 额外空间O(1)

选择排序时间0(n2)

原理就是 :在 0-n-1中找最小 -----放在位置0上

在1--n-1中找最小 -------放在位置1上 ......

总结：

选择排序和冒泡排序的排序方法与数据的状况无关无论哪种情况总是O(n2).

插入排序：时间O(n2)

（类似于打扑克牌，你要把新搬入的牌插入到已有的牌中）

原理：

----------------i

------j ( i-1)------i (j+1 ) 即如果前大后小则二者交换刚好就是j 和j+1位置上的元素进行交换

总结：

插入排序时间复杂度与具体数据的情况有关：

最好情况：数组已经有序-----只需要扫描一遍即可 O(n)

最坏情况/平均情况：均需要扫描交换 -------O(n2)

在估计算法好坏时是按照最坏情况下计算的时间复杂度指标。

对数器的准备（样本测试的工具）：

以冒泡排序为例：

其中copyArray操作是新建另一个新的数组，然后将要复制的原数组内容复制到此数组中

递归

求出一个数组的最大值：

归并排序：

时间复杂度：

归并排序涉及到的相关问题：

小和问题和逆序对问题

总结:

为什么归并排序会比一般的冒泡XXX都快？

因为避免了无用的比较。

e.g. 冒泡：扫描了全体就排好一个数字

而归并没有浪费已经排好的小部分就是有序的只需要进行已经排好的小部分之间的外排（就是两个指针比较）

快速排序：

对于小的那端 cur++ 是因为已经考察过所以直接跳过即可

而对于大的那端交换的数字是待定区域所以还需要考察

经典快排的改进（按照荷兰国旗问题思路）--------以及随机快排：：

总结：

经典快排一次只能是搞定一个数不管左边是否有X数依然进行递归而改进版的只要是等于X的数无需再动

经典快排的问题：

容易“搞偏” 每次只搞定一个时间复杂度和数据状况有关可能退化成O(n2)的算法

而选取基准刚好在中间则时间复杂度是最好的O（nlogn)

最终使用随机快排

随机选取一个数----跟最后一个数进行交换---概率事件--即使出现偏离事件--但是最终的时间复杂度也是可以接受的

代码：就是上面加上随机数选取那句代码。

拓展：想要绕开已有的数据状况我们怎么做：

2种方式： 1 类似上面随机选取

2 采用哈希函数进行打乱

随机快排的时间复杂度和空间复杂度：

最好的是O(logn) 因为每回需要去记录断点位置以便分为左右两部分----总共需要O(logn)

最坏的是O（n) 因为每回的基准均是在单侧 -------导致每次都需要记录----总共需要O(n)

无论数据情况如何长期期望就是O(nlogn)

堆：

完全二叉树及节点之间的对应关系：

根据数组如何变成具体的大根堆结构：

1 建立大根堆的时间复杂度：

对应的是heapInsert 函数 -----即加入一个新节点并向上进行调整的过程

只跟其上的父节点有关是完全二叉树的深度

每次加入一个节点都是 ---O（logn)

即 O(log1)+O(logn2)+......O(logn)= O(N) 总的就是O(N)

2 场景（heapify)：如果一个大根堆其中的某一个节点值突然发生变化，需要重新进行调整 ----

------------找到其两个子孩子---取其中子孩子的最大值，如果比现在的这个节点值大----则与之交换-----不断向下调整交换----

heapsize 参数标记堆目前的大小 <=数组的大小

3 堆上如果要把根节点弹出则用最后一个节点和根节点互换-----之后通过heapify向下调整--------大小-1

堆排序原理：

就是每次将根节点和最后一个节点进行交换 -----然后原根节点固定在数组最后并失效----新的节点通过heapify进行调整----

----继续得到根节点---继续和最后一个交换------不断重复上述操作------最终即可得到排序的结果

整个的过程：

比较各种排序算法的稳定性：

稳定性：相同元素在排序前后的相对位置不会发生变化

冒泡排序：只有大或小时才进行交换相等就跳过 -------稳定！

插入排序：在找寻位置的时候，遇到大或小会交换，但相等时就不会有操作，依然保持原有顺序------稳定！

选择排序：一轮下来的极值与第0位交换----可能跨过好多个相等的元素---导致次序被打乱------不稳定！！

归并排序：因为分别比较并拷贝两个子集合中的元素----规定先拷贝左边或右边---则陆续拷贝不破坏顺序-----稳定！

快速排序：因为partiton 函数就无法保证稳定性-------不稳定！！

堆排序：也是不稳定的！不会注意相等值的！

荷兰国旗问题：不稳定！！444 3 交换了3和第一个4 次序已经发生变化

稳定性的意义：

在实际应用中我们追求稳定性：是因为之前的记录可能对我们也有着重要的作用，我们希望在新排序之后依然能够保留原有记录。

例子：学生---班级号----成绩

先按照成绩进行排序如图所示

后按照班级号进行排序：

结果是在1班里的王和李前后顺序同上次，成绩依然按从小到大进行排序，在可读性方面较好，不乱很清晰。

有关排序问题的补充：

实际工程中使用的排序算法：

在数组长度非常短（一般<60) ：用插排 -----因为数据量少---O(n2)不大且常数项很小----速度很快

若数组中存储的是基本数据类型：用快排因为基础类型不用保证稳定性！

若数组中存储的是自己定义的class ，使用某一个字段进行排序：用归并排序因为类似于上面班级成绩的例子，需要保证稳定性！

当数据量较大，用归并或者快排递归，当分解之后数据<60 ，其实里面已经使用了插排 ----所以这是一种综合~~

比较器的使用：

compare 函数中：

return 负数：第一个放在前面---第二个放在后面

正数： 2 1

0 ：相等

在实际程序的书写中，如果排序不是重点时，则直接书写自己的比较器并调用系统排序即可。

堆也可以有比较器：

如果不定义自己的比较器就会按照自然顺序比较，但对于student类，不知如何比较，会报错。

不进行比较的排序：
桶排序：

类似于定义一些容器将同类的东西放入自己归属的桶不进行比较在O(n）时间内可分类完毕（有点像数组元素统计频数）

应用题目：

分析题意：

给定数组中N个元素----准备N+1个桶---数组中的max/min分别放在第一个和最后一个桶 ----其余按照等份去放入

则相邻元素之间的最大差一定出现在空桶左右相邻桶左边的最大值和右边的最小值满足相邻且可能差值最大。

实际操作：

需要 boolean[N+1]数组记录是否有数入桶

max[N+1] min[N+1] 记录每个桶里面的最大值和最小值

代码：

//循环一遍---找出其中的最大值和最小值-----判断是否相等

1 相等 ----则数组中只有一种数

2 不等-----则继续分桶

//创建3个辅助数组并循环原始数组将其中数字分在各个桶里

//之后每个桶里根据新分入的数字进行max/min更新---并记录boolean 为true(桶里有数字）

//分桶完毕--辅助变量记录上一次的最大值lastMax---循环每个桶---不断将上一次最大值和下一个桶的最小值进行差值--比较 ----直到循环桶完毕---res记录了最大差值 ----即为结果。

队列和栈

用数组结构实现大小固定的队列和栈：

实现固定大小的栈：（重新创建一个新的数组）

实现固定大小的队列：（重新创建一个新的数组）

主要有3个指针变量：

size end start

其中 end: 每次用户加入新值的时候如果size未满则加到end指的位置上

start：每次用户想要取出元素的时候只要size!=0 就取start位置上的数字给用户

size : 每次记录已有数据量

在整个数组的运行过程中我们可以看出：数组类似于一个循环 end 到底之后就回到开头

代码：

getmax函数的设计：

第一种：两个栈----同步进行压入----始终比较数据栈和min栈顶元素值的大小

用队列实现栈（用栈实现队列）：

用队列实现栈：

代码：

用栈实现队列：

具体代码见链接：

栈与队列专题

import java.util.Stack;  
  
public class Solution {  
    Stack<Integer> stack1 = new Stack<Integer>();  
    Stack<Integer> stack2 = new Stack<Integer>();  
      
    //队列的压入就是s1的压入数据    
    public void push(int node) {  
        stack1.push(node);  
    }  
      
    //弹出借助于S1/s2 两个   弹出需要考虑队列是否为空  
    public int pop() {  
        if(size()!=0){  
            if(stack2.empty()){                //若s2为空  则需要把s1的元素全部压入s2再输出  
                while(!stack1.empty())  
                    stack2.push(stack1.pop());  
            }  
            return stack2.pop();               //若s2不为空 则直接输出  
        }else{  
            System.out.println("队列为空，不能执行出队操作");  
            return -1;  
        }  
    }  
    //队列的大小  队列为空则说明 s1/s2均为空  
    public int size(){  
        return stack1.size()+stack2.size();  
    }  
}

猫狗队列（工程类型题目）：

思路：

两个队列，一个cat队列，一个dog 队列分别进出，按照正常队列

但是对于要pollAll ，则需要进行标记，对于cat /dog的次序进行记录

则想到新建一个petEnter类，里面含有pet 和 count 属性，作为一个整体的宠物

在之后add队列的时候对每一个宠物进行count标记最终pollAll时比较两者count大小，即说明次序

已有程序结构：

我们书写的程序结构：

队列：

转圈打印矩阵：

不同于剑指offer思路：

这里主要使用左上角一个点和右下角一个点去整体控制

下面代码中4个while循环：

代码：

顺时针旋转矩阵90度：

有一个NxN整数矩阵，请编写一个算法，将矩阵顺时针旋转90度。

给定一个NxN的矩阵，和矩阵的阶数N,请返回旋转后的NxN矩阵,保证N小于等于300。

借助刚才的思路：

分清楚哪些点是一组的从而进行相应的操作

优点：不用辅助数组-----直接原地进行操作

代码：

之字形打印矩阵：

思路：

从第一个点开始设置A ，B ，其中 A 不断向右走---->遇到末尾就向下

B 不断向下走---->遇到末尾就向右

可以发现两个点之间连成的对角线-----刚好就是之字形打印的顺序

问题转化为------>如何打印出A和B形成的对角线问题~并且用boolean变量标记打印顺序（斜向上或者斜向下）

代码：

while条件的理解： A已经向右走完并且也已经向下走完 ----走到最后一行

与B走到最后一列同理~

boolean fromup: 为false时打印的是从下到上即开始的打印1

后来变成true时打印的是从上到下即打印2 5 .。。。。之后以此类推即可

数组问题

在行列均排好序的矩阵中找数：

思路如下：

代码：

private static  boolean arrSearch(int[][] arr, int key) {  
        if(key<0)   
            return false;  
        if(arr==null)  
            return false;  
        int i=0;                       //行数row  
        int j=arr[0].length-1;        //列数column  
        boolean flag=false;           //查找标志  
        while(i<arr.length  && j>=0) {     //从右上角开始查找  
                if(key==arr[i][j]) {     
                    flag=true;  
                    break;  
                }  
                else if(key<arr[i][j])     
                    j--;  
                else   
                    i++;  
        }  
        return flag;  
    }  
}