算法基础篇

一个程序的运行时间(执行每条语句的耗时和频率)：

        ①确定输入模型，定义问题的规模；

        ②识别内循环；

        ③根据内循环的操作确定成本模型；

        ④对于给定的输入，判断这些操作的执行频率；

举个例子：

        数组实现的二分查找：输入模式是a[N]，内循环是while循环中的所有语句，成本模式是

        比较操作。

1.1 找出数组中最大的元素

注：数组也是对象，可用增强for

所有对象都有三大特性：

        ①状态：各个数据类型中的值。

        ②标识：将一个对象区别于另一个对象(内存地址)。

        ③行为：各个数据类型的操作。

1.2 计算数组元素的平均值

1.3 复制元素

1.4 颠倒数组元素的顺序

1.5 矩阵相乘

1.6 判断一个数是否是素数

1.7 计算平方根

1.8  计算调和级数 1+1/2+1/3+1/4+...+1/n

1.9 非递归之二分查找(数组已排好序)

2.0 递归之二分查找(数组已排好序)

2.1 将十进制转成二进制

2.2 判断是否为回文字符串（ABBA）

2.3 判断字符串是否排好序

2.4 背包、队列、栈

背包：先进后出，不支持删除元素的无序集合，只是收集元素并迭代遍历集合中的元素。

栈：先进后出，入栈顺序和初战顺序相反。

队列：先进先出，入列顺序和出列顺序相同。

2.5 双栈解决求算术表达式的值

①将操作数压入操作数栈；

②将运算符压入运算符栈；

③忽略左括号；

④遇到右括号，弹出一个运算符，弹出所需数量的操作数，并将运算符和操作数的运算结果

   压入操作数栈；

⑤处理完最后一个右括号之后，操作数栈上只会有一个值，该值就是表达式的值；

注：为表达式先加上左右括号；

⑥括号的对数 = 数字个数 -  1； 

2.6 下压(LIFO先进后出)栈(动态调整栈的大小，数组实现)

private class ResizeArrayStack<Item> {
    private Item[] a = (Item[]) new Object[1];//栈元素
    private int N = 0;
    public boolean isEmpty() {return N == 0;}
    public int size() {return N;}
    //扩容
    private void resize(int max) {
        //将栈元素移动到一个大小为max的新数组中
        Item[] temp = (Item[]) new Object[max];//栈元素
        for (int i = 0; i < N; i++) {
            temp[i] = a[i];
        }
        a = temp;
    }
    public void push(Item item) {
        //将元素添加到栈顶
        if (N == a.length) {
            resize(2 * a.length);
        }
        a[N++] = item;
    }
    public Item pop() {
        //从栈顶删除元素
        Item item = a[--N];
        a[N] = null;//避免对象游离，null会被垃圾回收器回收
        //缩容
        if (N > 0 && N == (a.length / 4)) {
            resize(a.length / 2);
        }
        return item;
    }
    public Iterable<Item> iterator() {
        return (Iterable<Item>) new ReverseArrayIterator();
    }
    private class ReverseArrayIterator {
        private int i = N;
        public boolean hasNext() {
            return i > 0;
        }
        public Item next() {
            return a[--i];
        }
    }
}

2.7 栈或背包(LIFO先进后出)(链表实现)

public class MyStack<Item> {
    private class Node {
        Item item;
        Node next;
    }
    private Node first;//栈顶（最近添加的元素）
    private int N;//元素数量
    public boolean isEmpty() {
        return N == 0;
    }
    public int size() {
        return N;
    }
    public void push(Item item) {
        //向栈顶添加元素
        Node oldFirst = first;
        first = new Node();
        first.item = item;
        first.next = oldFirst;
        N++;
    }
    public Item pop() {
        //从栈顶删除元素
        Item item = first.item;
        first = first.next;
        N--;
        return item;
    }
}

2.8 实现队列（先进先出）

public class MyQueue<Item> {
    private class Node {
        Item item;
        Node next;
    }
    private Node first;//指向最早添加的结点的链接
    private Node last;//指向最近添加的结点的连接
    private int N;//队列中的元素数量
    public boolean isEmpty() {
        return N == 0;
    }
    public int size() {
        return N;
    }
    public void enqueue(Item 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() {
        //从表头中删除元素
        Item item = first.item;
        //本身直接等于本身指向的下一个元素
        first = first.next;
        if (isEmpty()) {
            last = null;
        }
        N--;
        return item;
    }
}

2.9 2-sum问题-->线性对数级别的解法

①如果二分查找不成功则返回 -1，不增加计算器的值；

②如果二分查找返回的下标索引 j > i，则 a[i] + a[j] = 0，计数器加1；

③如果二分查找返回的下标索引 j 在 0 和 i 之间，则 a[i] + a[j] = 0，但是计数器已经加过了，

    不需要再累加了；

注：基于所有整数均不相同，归并排序所需时间是NlogN成正比，二分查找所需时间和logN

        成正比。该算法可计算100万个整数对。

3.0 3-sum问题-->N²logN级别的解决

当且仅当 -( a[i] + a[j] ) 在数组中时，整数对( a[i] + a[j] )为某个和为 0 的三元组的一部分。

注：基于所有整数均不相同。该算法可计算100万个整数对。

3.1 union-find算法-->加权quick_union实现：

动态连通性

        给定N对整数对(即P和Q是相连)，这些整数对具有传递性(即P和Q相连，Q和R相连，则P和Q相连)，编写一个程序过滤掉原来无意义的整数对(即它们不相连)，和判断一对新对象是否相连。这就是动态连通性问题。

public class union_find {
    //父链接数组(每一个点为触点索引)
    private int[] id;
    //(由触点索引的)各个根节点所对应的分量的大小
    private int[] sz;
    //连通分量数量(单独存在的一个或多个连接触点)
    private int count;
    public union_find(int n) {
        //初始化id数组和连通分量
        count = n; id = new int[n]; sz = new int[n];
        for (int i = 0; i < n; i++) {
            id[i] = i;
            sz[i] = 1;
        }
    }
    public boolean connected(int p, int q) {
        return find(p) == find(q);
    }
    //加权quick-union算法实现
    public int find(int p) {
        if (p != id[p]) {
            //如果原来位置的值变成b，则将当前值变为b
            p = id[p];
        }
        return p;
    }
    //在p和q之间添加一条连接，连通分量数没有减少，则说明pq已经相连
    public void union(int p, int q) {
        int i = find(p); int j = find(q);
        if (i == j) {
            return;
        }
        //将小树的根节点连接到大树的根节点
        if (sz[i] < sz[j]) {
            id[i] = j;
            sz[j] += sz[i];
        } else {
            id[j] = i;
            sz[i] += sz[j];
        }
        count--;
    }
    public static void main(String[] args) {
        union_find union_find = new union_find(11);
        Scanner scanner = new Scanner(System.in);
        while (true) {
            int p = scanner.nextInt(); int q = scanner.nextInt();
            //如果已经连通则忽略，id[p]=id[q]，说明已经被pq(相连了)被归并了
            if (union_find.connected(p, q)) {
                System.out.println("过滤无意义的整数对：" + p + ":" + q);
                continue;
            }
            //归并分量
            union_find.union(p, q);
            System.out.println("连通分量数：" + union_find.count);
        }
    }
}

​​​​​​​        加权quick_union算法时间复杂度为logN，最优算法还得是路径压缩的quick_union加权算法，只需要在find()中添加一个循环判断，将在路径遇到的所有节点都直接链接到根节点，这样得到的结果几乎完全扁平化的树了。

// 查找节点所属的根节点，并进行路径压缩
private int find(int p) {
    if (p != id[p]) {
        // 路径压缩：将直接连接到根节点
        id[p] = find(id[p]);
    }
    return id[p];
}public class Main {
    public static void main(String[] args) {
        int n = 10;  // 假设有10个节点
        union_find​​​​​​​ uf = new union_find(n);
        uf.union(1, 2);
       ​​​​​​​ uf.union(3, 4); 
        ​​​​​​​uf.union(4, 5);
       ​​​​​​​ System.out.println(uf.connected(1, 5));  // 输出：true
    ​​​​​​​}
}