读书笔记-算法

Posted 2020-06-24 Mosthink

几个对数组的算法

1， 找出数组中的最大值：

1 2 3 4 5

double max = a[0]; for(int i = 1; i < a.length; i++) if(a[i] > max) max = a[i];

//把最大值马上设定为数组的第一个元素，然后遍历数组，如果有别当前这个最大值更大的元素，则把最大值更新，直到遍历结束；

2， 计算数组的平均值：

1 2 3 4 5 6 7

double sum = 0.0; for(int i = 0; i < a.length; i++) sum += a[i]; double average = sum / a.length;

//算出总值，然后除以数组的元素数；

3，复制数组：

1 2 3 4 5 6 7

double[] b = new double[a.length]; for(int i = 0; i < a.length; i++) b[i] = a[i]; //new 一个和原数组同length同类型的数组，然后遍历赋值每个元素；

4，颠倒数组元素的顺序：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

double [] b = new double[a.length]; for(int i = a.length - 1, j = 0; i > -1 && j < b.length ; i--, j++) b[j] = a[i]; //这是个直观低效率算法，时间消耗(a.length)，空间消耗(2 * a.length)，并且有两个循环指数i, j； for(int i =0; i < a.length / 2; i++) { double temp = a[i]; a[i] = a[a.length - 1 - i]; a[a.length - 1 - i] = temp; }

偶数个元素的交换过程：

< 2 1, 2, 3, 4

0 4, 2, 3, 1

1 4, 3, 2, 1

奇数个元素的交换过程：

< 2 1, 2, 3, 4, 5

0 5, 2, 3, 4, 1

1 5, 4, 3, 2, 1

//可见，无论是偶数个还是奇数个元素，交换的次数都一样，都是a.length/2，偶数个的时候是全交换，奇数个的时候，是以中间的那个元素为中心点，其他元素都交换，中间元素并不在a.length/2的遍历范围内；这个算法，时间(a.length/2)，空间(a.length)；

5，a[][] * b[][] = c[][]， 矩阵相乘（方阵）：

1 2 3 4 5 6 7 8 9 10 11 12 13

int n = a.length; double[][] c = new double[n][n]; for(int i = 0; i < n; i++) for (int j = 0; j < n; j++) { for(int k = 0; k < n; k++) //计算行i和列j的点乘 c[i][j] += a[i][k] * b[k][j]; }

---

典型静态方法的实现

1，计算整数的绝对值：

1 2 3 4 5

public static int abs(int x) { if(x < 0) return -x; else return x; }

//绝对值的规则很简单：不小于零就是本身，反之就返回-x；

2， 计算浮点数的绝对值：

1 2 3 4 5

public static double abs(double x) { if( x < 0.0) return -x; else return x; }

3， 判断一个数是否是素数：

1 2 3 4 5 6 7 8 9

public static boolean isPrime(int n) { if(n < 2) return false; //大于1的自然数，1不是素数 for(int i = 2; i * i <= n; i++) { //i * i <=n if(n % i == 0) return false; return true; }

//素数，就是质数。指在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数。

判断的关键点：

a, 小于2，不是；

b，从2到n遍历，遍历到一个i i > n之前的数就提前结束遍历，因为2到满足i i <= n的i之间的这些数如果能整除n，那么i之后到n的这些数也能；以满足i * i <=n为分界线，1…n之间的数对于整除n来说，是对称的；

判断n能否被i整除：n % i 的值是否为0；

4， 计算平方根（牛顿迭代法）：

1 2 3 4 5 6 7 8 9 10 11 12 13

public static double sqrt(double c) { if(c < 0) return Double.NaN; double err =1e-15; //1乘以10的负15次方 double t = c; while(Math.abs(t - c / t) > err *t) t = (c/t + t) / 2.0; return t; }

//不懂， TODO

5， 计算直角三角形的斜边：

1 2 3 4

public static double hypotenuse(double a, double b) { return Math.sqrt(a * a + b * b); }

6， 计算调和级数：

1 2 3 4 5 6 7 8 9 10

public static double H(int n) { double sum = 0.0; for(int i = 1; i <=n; i++) sum += 1.0 / i; return sum; }

//形如1/1+1/2+1/3+…+1/n+…的级数称为调和级数，它是 p=1 的p级数。 调和级数是发散级数。在n趋于无穷时其部分和没有极限（或部分和为无穷大）。

---

二分查找的递归和循坏实现法

递归总有一个最简单的情况-方法的第一条语句总是包含return的条件语句；

递归调用总是去尝试解决一个规模更小的子问题，这样递归才能收敛到最简单的情况;

递归调用的父问题和尝试解决的子问题之间不应该有交集；

二分查找：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

public static int rank(int key, int[] a) { return rank(key, a, 0, a.length - 1); } public static int rank(int key, int[] a, int lo, int hi) { if(lo > hi) return -1; int mid = lo + (hi - lo) / 2; //数组并没有被拆分，所以这里(hi - lo)/2必须再加上lo if(key < a[mid]) return rank(key, a, lo, mid - 1); else if(key > a[mid] return rank(key, a, mid +1, hi); else return mid; }

//如果原始的方法参数不怎么适合递归或者不够递归方法，就另写一个满足要求的递归方法，用原始的调用之；

比如二分查找的时候，并没有给定递归时需要的低坐标和高坐标，如果坚持要在原始方法中使用递归，那么必须对数组进行拆分和复制，效率低下，浪费空间；

在不拆分数组的情况下，“父问题和子问题之间不应该有交集“， 所以mid不是简单的lo + hi /2了；mid不用再被传给子问题，因为== mid的话就是解了已经，低位传lo到mid-1；高位传mid + 1到hi；

---

循环实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

int lo = 0; int hi = a.length - 1; while(lo <= hi) { int mid = lo + (hi - lo) / 2; //不拆分数组的话，始终是这个公式 if(key < a[mi]) hi = mid - 1; if(key > a[mi]) lo = mid + 1; else return mid; } return -1;

---

不用temp实现swap

1 2 3 4 5

a = a + b; b = a - b; a = a - b;

---

Dijkstra双栈算术表达式求值法

双栈：一个操作数栈，一个操作符栈；

从左到有遍历算数表达式：

1， 忽略左括号；

2， 将数字push入操作数栈；

3， 将运算符push入操作符栈；

4， 遇到有括号时，pop一个运算符，pop出所需数量的操作数，并将运算符和操作数的运算结果push入操作数栈。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

public static double calc(String[] equation) { Stack<String> ops = new Stack<String>(); Stack<Double> vals = new Stack<Double>(); for(String s : equation) { if(s.equals("(")) ; else if(s.equals("+")) ops.push(s); else if(s.equals("-")) ops.push(s); else if(s.equals("*")) ops.push(s); else if(s.equals("/")) ops.push(s); else if(s.equals("sqrt")) ops.push(s); else if(s.equals(")")) { String op = ops.pop(); double v = vals.pop(); if(op.equals("+")) v = vals.pop() + v; if(op.equals("-")) v = vals.pop() - v; if(op.equals("*")) v = vals.pop() * v; if(op.equals("/")) v = vals.pop() / v; if(op.equals("sqrt")) v = Math.sqrt(v); vals.push(v); } else vals.push(Double.parseDouble(s)); } return vals.pop(); }

这其实就是编译原理中的解释器。

应该也有其他方法，比如全部push入栈之后再依次出栈，前提是优先级用括号来明示。

---

堆栈的数组和链表实现以及队列的链表实现

堆栈的意义：

堆栈并不是为了迭代的一个容器，虽然它是一个可迭代的容器，但它不应该被应用于静态的数据存储场景；

堆栈应该应用于动态的运算、过滤等场景；

创建泛型类型的数组作为数据存储：

直接创建泛型数组是不可以的：T[] items = new T[2];

只能通过这种方式创建：T[] items = (T[])(new Object[2]);

动态增减数组大小：

动态增减的数组实现：没有高深的方法，就是new一个新的数组，把值拷贝过来，再把引用赋予新的数组对象：

1 2 3 4 5 6 7

T[] temp = (T[]) new Object[newLength]; for(int i = 0; i < N; i++) //如果是减小数组，这里的条件需要修改 temp[i] = a[i]; a = temp;

增：当数组满的时候，直接增加1倍；

减：当数组不满1/4的时候，减少至1/2；

以上是基于内存开销和性能之间的平衡，尤其是缩减数组，不能一个一个减，也不能不满1/2的时候直接减掉1/2，这样数组马上又满了，可能又需要增。

Stack内部使用动态增减的数组后，

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

public void push(T item) { if(N == a.length) resize(2 * a.length) a[N++] = item; } public T pop() { T item = a[--N]; a[N] = null; if(N > 0 && N == a.length / 4) //如果堆栈只满1/4，减为1/2，还能有1/2的空余； resize(a.length / 2); return item; }

pop()方法中要避免内存泄漏：

对象游离： Stack的pop方法写的不好，就有可能导致内存泄漏；

用数组实现堆栈，pop之后，当前对象在堆栈范围内已经无用了，如果客户代码那也用完了这个对象，其该被回收，但是，因为Stack内部的数组还有对这个对象的引用，导致无法被GC，除非再次push，该数组位的引用值被重新指向另一个对象，原来那个对象就被GC了；

如果用API中的List实现堆栈，因为List本身的remove方法已经采取了避免对象游离的措施，所以就没这个问题；

用数组存储和用链表存储：

堆栈本身并不用于遍历，所以操作（push和pop）的用时都跟集合大小无关，不管是用数组还是用链表实现；

用数组存储的明显缺点就在于，push，pop会不定期地引起数组的调整，调整数组的耗时和栈大小成正比，克服这个缺陷就是用链表代替之：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

private Node first = null; //栈顶节点 private Class Node { //描述栈帧的节点内部类定义 T item; Node next; } public void push(T item) { Node oldFirst = first; first = new Node(); first.item = item; first.next = oldFirst; N++; } public T pop() { T item = first.item; first = first.next(); N--; return item; }

不用担心对象游离的问题，first = first.next之后，由于堆栈里并没有数组结构，出栈的对象在栈内不会再被引用，没用就回收掉了；

堆栈也是集合，也要实现迭代器：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Stack<T> implements Iterable<T> public Iterator<T> iterator() { return new Iterator<T> { private int i = N; public boolean hasNext() { return i > 0; } public T next() { return a[--i]; } ... }

链表实现的迭代：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

Stack<T> implements Iterable<T> public Iterator<T> iterator() { return new Iterator<T> { private Node current = first; public boolean hasNext() { return current != null; } public T next() { T item = current.item; current = current.next; return item; } ... }

链表实现的队列就是一种堆栈，仍然从first出队，但是从last入队：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

public boolean isEmpty() { return first === null; } public void enqueue(T item) { Node oldLast = last; last = new Node(); last.item = item; last.next = null; if(isEmpty()) first = last; else oldLast.next = last; N++; } public Item dequeue() { T item = first.item; first = first.next; if(isEmpty()) last = null; N--; return item; }

到底用数组还是链表：

堆栈是LIFO，数组实现的话，总是在数组的末尾进行赋值和置null，这个可以接受；但数组的调整大小问题导致数组实现又不是特别能接受，而链表就完全不存在这个问题；

队列是FIFO，数组实现的话，假如入队末尾，那么出队必然在开头，删除开头元素要引起数组整体挪动；或者反过来，入队在开头，则出队在末尾，入队得在开头添加元素，引起数组整体挪动；所以说，队列一点都不适合用数组实现。

---

常数、对数、线性、线性对数、平方、立方、指数；

一般来说，平方、立方、指数级别的算法对于大规模的问题是不可用的；

logN的底数对算法分析来说相当于一个常数，所以可以忽略底数到底是几；

2-sum问题的平方级算法：

1 2 3 4 5 6 7

for(int i =0; i < N; i++) for(int j = i + 1; j < N; j++) if(a[i] + a[j] == 0) count++;

这个复杂度是(N-1) + (N-2) + … + (N-N) = N的平方 + N的平方/2 =-= N的平方；

改进的算法：

1 2 3 4 5 6 7

sort(a); for(int i = 0; i < N; i++) if(BinarySearch(-a[i], a) > i) count++;

这个算法的思路，单循环数组a，对于每一个a[i]：

1， 如果二分查找找不到-a[i]，计数器不增加；

2， 如果二分查找到的-a[i]是a[j]，如果j > i，计数器增加，反之如果j < i，因为a是排序了的，说明这次查找之前已经用a[j]找到过a[i]了，重复了，计算器不增加；

对于N次单循环，每次都二分查找了，二分查找的复杂度是对数级，所以这个算法的总复杂度是线性对数级；

相应的，原来为N的立方的3-sum问题可被优化为N的平方对数级的；

---

优先队列的二叉堆实现

【优先队列】

堆栈：删除最新元素；

队列：删除最旧元素；

优先队列：删除最大元素和插入元素；

优先队列实现的两个方式：

1， 惰性的，使用无序数据结构，插入元素不做任何操作，删除最大元素时再查找最大元素；

2， 主动的，使用有序数据结构，插入元素时就排到合适的位置，删除最大元素时直接删第一个；

优先队列的初级实现：

                        插入元素                        删除最大元素

有序数组 N 1

无序数组 1 N

栈和队列的操作的复杂度都是个常数；

优先队列用数组初级实现的话，操作的复杂度都是线性的；

我们试图探寻更好性能的优先队列实现；

【二叉堆】

用数组表示完全二叉树：

将二叉树的节点按照层级顺序放入数组中，根节点在位置1，它的子节点在位置2和3，而子节点的子节点则分别在4、5、6、7；

不使用数组的第一个位置；

对于一个节点，它在数组中的是索引是k，那么它的父节点的索引是：下取整(k/2)

子节点的索引分别是2k和2k+1；

堆有序：

当一棵二叉树的每个节点都大于等于它的两个子节点时；

在堆有序的二叉树中，从任意节点向上，都能得到一列非递减的元素；从任意节点向下，都能得到一列非递增的元素；

堆有序化-上浮：

如果堆的有序状态因为某个节点变得比它的父节点更大而打破，就需要交换它和它的父节点；

交换后，这个节点仍然可能比现在的父节点大，所以需要继续往上交换；

1 2 3 4 5 6 7 8

void swim(int k) { while(k > 1 && pq[k/2] < pq[k]) { swap(pq, k/2, k); k = k / 2; }

同理，下沉：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

void sink(int k) { while(2 * k <= N) { int j = 2 * k; if(j < N && pq[j] < pq[j+1]) //选取两个子节点中较大的一个往上交换 j++; if(pq[k] >= pq[j]) //结束下沉，已经比字节点大了 break; swap(pq, k, j); //下沉 k = j; }

在实现二叉堆的数组中，插入一个数据到末尾是上浮；删除第一个数据，这个数据就是最大元素，然后把数组最末尾的元素放到顶端，让其下沉；

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

public class MaxPQ<Key extends Comparable<Key>> { private Key[] pq; private int N = 0; public MaxPQ(int maxN) { pq = (key[]) new Comparable[maxN+1]; } public boolean isEmpty() { return N == 0; } public int size() { return N; } public void insert(Key v) { pq[++N] = v; swim(N); } public Key delMax() { Key max = pq[1]; swap(1, N--); pq[N+1] = null; sink(1); return max; } }

由于插入和删除都最多是一次根节点到叶节点的堆秩序恢复，跟节点到叶节点的最长路径是lgN；所以二叉堆实现的优先队列的插入和删除的复杂度都是lgN（比较次数：lgN+1, 2lgN）；

---

如何检测一个链表中是不是有循环结点？

两个指针，分别表示乌龟和兔子，乌龟每次往下走1步，兔子每次走两步，如果兔子走到了Next为Null的节点，说明没有循环，否则他们一定相遇，表示有循环。