算法与数据结构

概述

程序 = 算法 + 数据结构

• 算法是计算机科学的本质，是计算机世界的基石。算法决定了程序如何运行
• 数据结构决定了程序的数据如何被存储

算法的复杂度

时间复杂度

定性描述算法的运行时间

• O(1) => 常数时间 => 运行时间与问题的规模无关 => 哈希桶 | 数组随机寻址 => 数组(Array) | 线性表(Linear Table)
• O(n) => 线性时间 => 运行时间与问题的规模成正比 => 遍历 | 求数组、链表的最大值
• O(log(n)) => 对数时间 => 每次操作其所需要的额外计算时间会变小 => 二分查找 | 二叉树
• O(n*log(n)) => 基于比较的排序算法的下界
• O(n^2) => 解决问题的复杂度和问题规模的平方成正比 => 冒泡排序

1. 时间复杂度计算时忽略常数 => O(n) == O(2n)
2. 时间复杂度的计算中，高阶复杂度会吞并低阶复杂度 => O(n^2) + O(n) == O(n^2) => 对数组进行排序后遍历，复杂度是多少？ => O(n*log(n)) + O(n) == O(n*log(n))

• 最好时间复杂度
• 最坏时间复杂度
• 平均时间复杂度

线性时间复杂度

• 求数组、链表的最大值 | 和
• 寻找数组中的重复元素
• 判断链表是否存在环(快慢指针)
• 求阶乘
• 合并两个链表
• 翻转链表

对数时间复杂度

二叉树

遍历二叉树

1. 深度优先遍历 DFS(Depth First Search) => 递归
   • 前序遍历(根节点 => 左节点 => 右节点)
   • 中序遍历(左节点 => 根节点 => 右节点)
   • 后序遍历(左节点 => 右节点 => 根节点)
2. 广度优先遍历 BFS(Breadth First Search) => 经典的广度优先遍历算法 => 队列(先进先出 FIFO)

递归

1. 将大问题分解成小问题
2. 假设小问题已经解决
3. 对分解的小问题进行求解

空间复杂度

解决问题所需要的辅助空间的大小

• 常数空间复杂度 => O(1) => 只需要固定大小的辅助空间 => 寻找最大值 | 求数组所有元素的和 | 非递归计算阶乘
• 线性空间复杂度 => O(n) => 需要的辅助空间和问题规模成正比 => 递归计算阶乘 | 带缓存(备忘录)的 斐波那契数列 求值

带缓存(备忘录)的 斐波那契数列 求值

斐波那契数列 => 1 1 2 3 5 8 13 21 34 55 89 ...

• F₀ = 0
• F₁ = 1
• F_n = F_n-1 + F_n-2

class Counter {
    HashMap cache = new HashMap<>();

    public int fibonacci(int n) {
        if (n == 0 || n == 1) {
            return 1;
        }
        return fibonacci(n - 1) + fibonacci(n - 2);
    }

    public int fibonacci4Cache(int n) {
        if (cache.containsKey(n)) {
            // 缓存命中 cache hit
            return cache.get(n);
        }

        // cache miss
        if (n == 0 || n == 1) {
            return 1;
        }
        int result = fibonacci4Cache(n - 1) + fibonacci4Cache(n - 2);
        cache.put(n, result);
        return result;
    }
}

数据结构

数组 | 线性表

java.util.ArrayList => 扩容

• 随机寻址 => RandomAccess => 常数时间 => O(1)
• 插入 | 删除 => 线性时间 => O(n)
• 查找
  • 无序数组查找 => 线性时间 => O(n)
  • 有序数组查找 => 对数时间(二分查找[递归 & 非递归]) => O(log(n))

二分查找

应用于有序数组的快速算法

1. 非递归 => 双指针

   public static int binarySearch(int[] array, int key) {
        int low = 0;
        int high = array.length - 1;
   
        while (low <= high) {
            int mid = (low + high) / 2;
            int midVal = array[mid];
   
            if (midVal < key) {
                low = mid + 1;
            } else if (midVal > key) {
                high = mid - 1;
            } else {
                return mid; // key found
            }
        }
        return -(low + 1);  // key not found.
   } 
   

2. 递归

   public static int binarySearchForRecursion(int[] array, int target, int start, int end) {
        int mid = (start + end) >>> 1;
        int midVal = array[mid];
        if (start > end) {
            return -1;
        } else if (target == array[start]) {
            return start;
        } else if (target == midVal) {
            return mid;
        } else if (target == array[end]) {
            return end;
        } else if (array[start] < target && target < midVal) {
            return binarySearchForRecursion(array, target, start + 1, mid - 1);
        } else {
            return binarySearchForRecursion(array, target, mid + 1, end - 1);
        }
    }
   

链表 & 双向链表

java.util.LinkedList => 双向链表(Doubly-linked list) => addAll & get

• 寻址 => 线性时间 => O(n)
• 插入 | 删除 => 常数时间 => O(1)
• 查找 => 线性时间 => O(n)

遍历链表数据

for(Node current = head; current != null; current = current.next) {
    System.out.println(current.value);
}

如果要删除一个数据，需要将前一个数据的 next 指向下一个数据，之后将删除数据的 next 删除

翻转链表

// TODO

判断链表是否成环

// TODO

栈 Stack

java.util.Stack extends java.util.Vector => push & pop

FILO(First In Last Out)

应用：方法栈

手写一个栈的实现

public class Stack {
    private final LinkedList