Data Structure_二叉树_集合_堆_并查集_哈希表

前情提要——二叉树

二叉树之前已经提到过,二叉树这种数据结构只能有两个子数,一左一右。

叶子节点就是左右孩子都是空的,但是并不是每一颗树都像上图所示的那样这么规整,有些树树可以只有左孩子没有右孩子的。二叉树的节点一定会大于左节点的值小于右节点的值,每一个节点都要满足,所有每一个节点下面拿出来的树都可以作为一个二叉树。既然有大于等于了,那么这科树的元素一定要有可比较性才可以。

Create a BST

package Tree.BST;

public class BST<E extends Comparable<E>> {
    /**
     * Binary Search Tree
     */

    private class Node {
        public E e;
        public Node left, right;

        public Node(E e) {
            this.e = e;
            left = right = null;
        }
    }

    private Node root;
    private int size;

    public BST() {
        root = null;
        size = 0;
    }

    public int size(){
        return size;
    }

    public boolean isEmpty(){
        return size == 0;
    }
}

和上面描述的基本一致的。

Insert an element

插入一个元素也很简单,查看当前元素是否是大于或者小于节点元素,如果是大于,那么就右边递归即可,二叉树的插入非递归写法和链表很像。

    public void add(E e) {
        root = add(root, e);
    }

    private Node add(Node node, E e) {
        if (node == null) {
            size++;
            return new Node(e);
        }
        if (e.compareTo(node.e) < 0) {
            node.left = add(node.left, e);
        } else {
            node.right = add(node.right, e);
        }
        return node;
    }

Select an element

判断一个元素和查找一个元素算法基本一致,小于左边找,大于右边找即可。
···
public boolean contains(E e) {
return contains(root, e);
}

public boolean contains(Node node, E e) {
    if (node == null) {
        return false;
    } else if (e.equals(node.e)) {
        return true;
    } else if (e.compareTo(node.e) < 0) {
        return contains(node.left, e);
    } else {
        return contains(node.right, e);
    }
}

···

Traversal

前中后序遍历都很简单,代码和前面C++都都是一样的。对于中序遍历的非递归遍历。非递归遍历可以对比递归来实现,数据结构里面有递归属性的只有栈了,所以可以用栈来实现。先把根元素压进栈,由于前序遍历直接输出第一个遍历到到元素,所以先出栈输出之后再把出栈的元素的子节点压进去,要注意的是右孩子先压,左孩子再压,因为遍历的顺序是先遍历左边再遍历右边,以此类推,只到空为止。
递归处理很简单,几行就好了,主要繁琐到就是非递归遍历到过程,前序遍历的非递归。这个算算比较简单到,因为先遍历到是一开始遍历到到点,再依次是左右子树,没有倒叙过程,都是有顺序性到,所以可以直接用栈处理,先把跟节点扔进去,如果栈不为空,那么就要出栈,直接输出当前元素,在放入左右子树即可,但是放入左右子树需要注意,应当先放入右子树再放入左子树,因为是先遍历左子树再遍历右子树,而栈是反过来的。

public void preOrderNonRecur() {
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            Node node = stack.pop();
            System.out.print(node.e + " ");
            if (node.right != null)
                stack.push(node.right);
            if (node.left != null)
                stack.push(node.left);
        }
        System.out.println();
    }

这就是前序遍历。中序的非递归遍历就有点复杂了,中序遍历是左中右,这个时候顺序就不是都往下了,没有办法一次性就遍历完,栈里面一开始存储都应该是遍历一开始要拿出来输出都元素,所以可以先把左边子树都遍历完存到栈里面,然后以这些存到栈里面的元素为起点遍历下去。每次出来一个元素都要看看这个元素的右子树是否存在,如果存在就要遍历,但其实不必要这样判断,因为算法前面的大循环已经判断了。


    public void inOrderNonRecur() {
        Stack<Node> stack = new Stack<>();
        Node node = root;
        while (node != null || !stack.isEmpty()) {
            while (node != null) {
                stack.push(node);
                node = node.left;
            }
            if (!stack.isEmpty()) {
                Node node1 = stack.pop();
                System.out.print(node1.e + " ");
                node = node1.right;
            }
        }
        System.out.println();

    

对于后序遍历就是最复杂的了,由于后序遍历和前序遍历都是逆的,所以一开始也要先把左子树放到栈里面,出的时候在看看有没有右子树。但是这里有个问题,这里的右子树是先输出再到当前节点的,首先要拿到当前节点,然后再看看右子树有没有,有就遍历,等右子树遍历完之后当前节点还在栈里面,这个时候再拿出来的还是当前节点,这个时候就不知道右子树有没有被遍历过了,这就进入到了一个死循环,所以这里要使用一个标记来看看有没有访问了右子树,如果访问了右子树,就可以放心输出了,因为while循环的时候已经到了最左边的了,这个时候不会再有左子树,只需要考虑右子树即可。

public void lastOrderNonRecur() {
        Stack<Node> stack = new Stack<>();
        Node node = root;
        while (node != null || !stack.isEmpty()) {
            while (node != null) {
                stack.push(node);
                node = node.left;
            }
            if (!stack.isEmpty()) {
                Node node1 = stack.peek();
                if (!node1.isright) {
                    node1.isright = true;
                    node = node1.right;
                } else {
                    node = stack.pop();
                    System.out.print(node.e + " ");
                    node = null;
                }
            }
        }
        System.out.println();
    }

中序遍历和后序遍历都从左边扩散到右边。
最后一个就是层序遍历,层序遍历就是广度优先遍历,实现用队列就好了,事实上大多数的广度优先遍历基本都是要使用队列的。之前的数据结构说过,直接给出代码即可:

levelOrder(){
        Queue<Node> nodes = new LinkedList<>();
        nodes.add(root);
        while (!nodes.isEmpty()){
            Node node = nodes.remove();
            System.out.print(node.e + " ");
            if (node.left != null){
                nodes.add(node.left);
            }
            if (node.right != null){
                nodes.add(node.right);
            }
        }
        System.out.println();
    }

remove an specific element

删除一个元素有点麻烦,如果只有一边有元素,那么就只需要把一边的移动上去替代即可,如果两边都有子树,那么就需要把右子树最小的一个移动上去,当然,其实也可以把左子树最大的移动上去,替代原来的即可。

    private Node remove(Node node, E e) {
        if (node == null) {
            return null;
        } else if (e.compareTo(node.e) < 0) {
            node.left = remove(node.left, e);
            return node;
        } else if (e.compareTo(node.e) > 0) {
            node.right = remove(node.right, e);
            return node;
        } else{
            if (node.left == null){
                Node node1 = node.right;
                node.right = null;
                size--;
                return node1;
            }else if (node.right == null){
                Node node1 = node.left;
                node.left = null;
                size--;
                return node1;
            }else {
                Node successor = new Node(minimum(node.right).e);
                successor.left = node.left;
                successor.right = removeMin(node.right);
                node.left = node.right = null;
                return successor;
            }
        }

    }

集合Set

集合这种数据结构有点像高中数学那种集合,集合有一个特点,就是每一个元素只能有一个,这个性质可以用来做去重工作。再上面实现的二分搜索树是不可以存放重复数据的,所以可以作为集合的一种底层实现方式。二叉树的实现是有要求的,要求一定要是二叉树的结构来实现,而集合只是要求有这么多功能就OK,所以集合属于一种高级数据结构,没有具体实现方法。

集合基本方法

Set创建一个集合,remove移除集合的一个元素,contains查看集合是否包含这个元素,getSize获得集合大小,isEmpty查看集合是否为空,add添加一个元素,不能添加重复的元素。
集合的应用很广,访问量的统计,词汇量的统计等等都可以用到集合去重。首先是基于BST的集合,上面实现的BST完全包含了集合的功能。直接包装一下即可。

Leecode804

Leecode804,摩斯码的判断:



这个题目非常简单,直接替换一下扔到集合里面就好了,这里使用的就是treeSet,是使用的红黑树实现方式:

class Solution {
    public int uniqueMorseRepresentations(String[] words) {
        String [] codes = {".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."};
        TreeSet<String> set = new TreeSet<>();
        for (String word : words){
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < word.length(); i++) {
                stringBuilder.append(codes[word.charAt(i) - 'a']);
            }
            set.add(stringBuilder.toString());
        }
        return set.size();
    }
}

之前所实现的集合,二分搜索树,红黑树这些实现的集合都是有顺序性的,因为这些结构实现的集合是很容易可以排序(中序遍历),找到下一个上一个等等,是属于有序集合,而链表这些就属于无序性的了。

优先队列和堆

堆的基本结构, 这里的堆实现也和树有关系,二叉堆。二叉堆是一个完全二叉树。

package Heap;

import Array.Array;

public class MaxHeap<E extends Comparable<E>> {
    private Array<E> data;

    public MaxHeap(int capacity) {
        data = new Array<E>(capacity);
    }

    public MaxHeap() {
        data = new Array<E>();
    }

    public int size() {
        return data.getSize();
    }

    public boolean isEmpty() {
        return data.isEmpty();
    }

    private int parent(int index) {
        if (index == 0) {
            throw new IllegalArgumentException("No parents when index equal zero!");
        }
        return (index - 1) / 2;
    }

    private int leftChild(int index) {
        return index * 2 + 1;
    }

    private int rightChild(int index) {
        return index * 2 + 2;
    }

    
}

堆的实现之前的C++有写过,对于插入一个元素,插入在数组的最后面,然后再按照规则慢慢的shiftUp上去,如果这个元素是大于它的父母,那么就要浮上去,然后以父母为当前元素继续循环判断:

    private void shiftUp(int index) {
        while (index > 0 && data.get(index).compareTo(data.get(parent(index))) > 0) {
            data.swap(index, parent(index));
            index = parent(index);
        }
    }

输出最大值的元素就只需要把第一个元素输出,把最后一个元素补上,再把新的第一个元素进行shiftDown操作:

    private void shiftDown(int index){
        while (leftChild(index) < data.getSize()){
            int j = leftChild(index);
            if (j + 1 < data.getSize() && data.get(j + 1).compareTo(data.get(j)) > 0){
                j = rightChild(index);
            }
            if (data.get(index).compareTo(data.get(j)) >= 0){
                break;
            }
            data.swap(index, j);
            index = j;
        }
    }

堆还有一个replace操作,取出最大值,用另一个值替代,可以先输出最大值,然后再添加另一个值,但是这样这样复杂度就是2log(n)。可以直接用新的元素替换最大值,然后做shiftDown操作即可。

    public E replace(E e) {
        E max = data.get(0);
        data.set(0, e);
        shiftDown(0);
        return max;
    }

如果存在一个数组,想要直接在数组上操作,使得这个数组直接变成一个堆,那就需要heapify操作了。从最后一个叶子节点开始不断做shiftdown操作即可:

        for (int i = parent(this.data.getSize() - 1); i >= 0; i --){
            shiftDown(i);
        }

基于堆的优先队列就很简单了,出队列的时候就直接extract最大值即可。

优先队列347


给定一个数组,数组元素可以重复,那么数字就会出现重复这个问题,在这种情况下,就需要求出前N个频率最高的元素,这就有点像优先队列了。先用Treemap把频率存储到树里面,然后放到优先队列里面输出即可:

package Queue.Leecode347;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.TreeMap;

class Solution {

    private class Freq implements Comparable<Freq>{

        int e, freq;

        public Freq(int e, int freq){
            this.e = e;
            this.freq = freq;
        }

        @Override
        public int compareTo(Freq another) {
            if (this.freq < another.freq){
                return -1;
            }
            else if (this.freq > another.freq){
                return 1;
            }else {
                return 0;
            }
        }

    }

    public List<Integer> topKFrequent(int[] nums, int k) {
        TreeMap<Integer, Integer> map = new TreeMap<>();
        for (int n : nums) {
            if (map.containsKey(n)) {
                map.put(n, map.get(n) + 1);
            } else {
                map.put(n, 1);
            }
        }

        PriorityQueue<Freq> priorityQueue = new PriorityQueue<>();
        for(int key: map.keySet()){
            if(priorityQueue.size() < k)
                priorityQueue.add(new Freq(key, map.get(key)));
            else if(map.get(key) > priorityQueue.peek().freq){
                priorityQueue.remove();
                priorityQueue.add(new Freq(key, map.get(key)));
            }
        }
        List<Integer> linkedList = new LinkedList<>();
        while (!priorityQueue.isEmpty()){
            linkedList.add(priorityQueue.remove().e);
        }
        return linkedList;
    }

    public static void main(String[] args) {
        int[] nums = {1,1,1,2,2,3};
        Solution solution = new Solution();
        System.out.println(solution.topKFrequent(nums, 2));
    }

}

并查集

之前包括前面博客所讨论的树问题都是树问题,这些树问题都是由父亲指向孩子,而这个并查集是孩子指向树,可以由孩子找到跟节点。并查集可以用来回答连接问题。给出两个点,看看这两个点是否是连接的。前面博客提到的就是找到根然后比较两个根是不是一样的即可。这里的并查集主要实现两个操作,Union和isConnected,连接两个节点和查看两个节点是否是连接的。

并查集Quick Find

每个元素的下标都会有一个标记,如果标记相同那么就是同一个类别,也就是连接在了一起。一开始每一个数字就是一个类别,所以一开始下标都是不一样的。


    private int find(int p) {
        if (p < 0 || p >= parent.length) {
            throw new IllegalArgumentException("p is out of range!");
        }
        while (p != parent[p]) {
            p = parent[p];
        }
        return p;
    }

    @Override
    public int getSize() {
        return parent.length;
    }

    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }

    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);
        if (pRoot == qRoot){
            return;
        }
        parent[pRoot] = qRoot;
    }

这种情况下的的查找复杂度是很快的,但是合并就很慢了,需要O(n)的复杂度。

基于树的Quick union

每一个节点都指向上一个节点,最后指向的就是根,根的parent就是他自己,如果根相同,那么这两个节点就是相同的。


    private int find(int p) {
        if (p < 0 || p >= parent.length) {
            throw new IllegalArgumentException("p is out of range!");
        }
        while (p != parent[p]) {
            p = parent[p];
        }
        return p;
    }

    @Override
    public int getSize() {
        return parent.length;
    }

    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }

    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);
        if (pRoot == qRoot){
            return;
        }
        parent[pRoot] = qRoot;
    }

合并的时候直接把根节点合并就好了。但是这种合并有个弊端,如果合并的时候恰好把大的哪一组数据合并到了小的哪一组数据上,就容易出现类似链表那样长长的数据段,这个时候就可以先做判断,看看哪一边的数据量大就把小数据的合并到大的一边去即可。所以就需要一个记录数量的数组。

    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);
        if (pRoot == qRoot) {
            return;
        }
        if (sz[pRoot] < sz[qRoot]) {
            parent[pRoot] = qRoot;
            sz[qRoot] += sz[pRoot];
        }else {
            parent[qRoot] = pRoot;
            sz[pRoot] += sz[qRoot];
        }
    }

其他都是一样的。这样其实不太严谨,如果数据都是分散开的,那么就应该反着过来,所以应该以高度作为对比的条件:

    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);
        if (pRoot == qRoot) {
            return;
        }
        if (rank[pRoot] < rank[qRoot]){
            parent[pRoot] = qRoot;
        }else if (rank[pRoot] > rank[qRoot]){
            parent[qRoot] = pRoot;
        }else {
            parent[qRoot] = pRoot;
            rank[pRoot] += 1;
        }

路径压缩 Path Compression

如果这个并查集已经被压缩成了长条型,就需要使用路径压缩来优化了:

这种情况下就只需要指向父亲的父亲即可,只要加上一行代码就可以。

    private int find(int p) {
        if (p < 0 || p >= parent.length) {
            throw new IllegalArgumentException("p is out of range!");
        }
        while (p != parent[p]) {
            parent[p] = parent[parent[p]];
            p = parent[p];
        }
        return p;
    }

哈希表HashTable

首先看一个简单的问题:


返回第一个不重复的字符。最简单的处理方式就是使用一个映射,先计算一遍所有字符的频率是多少,然后再遍历一遍所有的字符,看看第一个字符出现次数为一是索引下标是多少即可。
但是这样比较麻烦,我们可以使用一个数组包含了二十六个字母。

class Solution {
    public int firstUniqChar(String s) {
        int[] freq = new int[26];
        for (int i = 0; i < s.length(); i++) {
            freq[s.charAt(i) - 'a']++;
        }
        for (int i = 0; i < s.length(); i++) {
            if (freq[s.charAt(i) - 'a'] == 1) {
                return i;
            }
        }
        return -1;
    }
}

在这个问题就隐藏着哈希表这种数据结构。上面的frequency数组就是一个哈希表,每一个字符都和一个索引对应。数组的查找是支持下表操作的,所有复杂度可以是O(1)的复杂度。哈希其实就是使用一个下标来指示一个数值或者是字符,然后解决哈希冲突。简单的来说,哈希就体现了用空间换时间的思想。
键通过哈希函数得到的索引分布越均匀越好。对于一些特殊的领域,有特殊领域的哈希函数设计方式甚至有专门的论文。
首先是整型哈希函数的设计,小范围整数直接使用,负整数就要进行偏移。对于大整数,就需要对这个大整数进行处理,使得变成一个计算机可以处理的数据。常用的方法就是取模了。但是有时候取模使得分布不会有均匀的分布,所以可以使用素数作为取模数值。
对于字符串的处理,就需要转成整型处理

在Java里面的HashCode是以整型为基准的,他只是给出了hashcode,索引下标还是需要其他的计算。

hash冲突——链地址法

如果没有冲突,那么就按照下标直接存放,如果产生了冲突,也就是一个索引下有两个相同的哈希值,那么就用链表把他们都串起来,如果还是有相同的那么继续接上,所以每一个空间等于是存上了一个链表,也就是一个查找表,既然是查找表那么久不一定是链表了,可以是树结构,红黑树二叉树都可以。在Java8之前,一直都是一个位置对应一个链表,Java8开始如果冲突达到了一定程度,也就是链表里面元素过多了,那么就会把每一个位置自动转成红黑树。因为如果在数据量少的情况下,使用链表查找是更加快的,因为没有红黑树的维护过程,而数据量多的时候就需要使用红黑树了。


public class Hash_Table<K, V> {
    private TreeMap<K, V>[] hashtable;
    private int M;
    private int size;

    public Hash_Table(int M) {
        this.M = M;
        size = 0;
        hashtable = new TreeMap[M];
        for (int i = 0; i < hashtable.length; i++) {
            hashtable[i] = new TreeMap<>();
        }
    }

    public Hash_Table() {
        this(97);
    }

    private int hash(K key) {
        return (key.hashCode() & 0x7fffffff) % M;
    }

    public int getSize() {
        return size;
    }

    public void add(K key, V value) {
        if (hashtable[hash(key)].containsKey(key)) {
            hashtable[hash(key)].put(key, value);
        } else {
            hashtable[hash(key)].put(key, value);
            size++;
        }
    }

    public V remove(K key){
        TreeMap<K, V> treeMap = hashtable[hash(key)];
        V ret = null;
        if (treeMap.containsKey(key)){
            ret = treeMap.remove(key);
            size--;
        }
        return ret;
    }

    public void set(K key, V value){
        TreeMap<K, V> treeMap = hashtable[hash(key)];
        if (!treeMap.containsKey(key)){
            throw new IllegalArgumentException("no element!");
        }else {
            treeMap.put(key, value);
        }
    }

    public boolean contains(K key){
        return hashtable[hash(key)].containsKey(key);
    }

    public V get(K key){
        return hashtable[hash(key)].get(key);
    }
}

每一个位置都使用红黑树,插入的数据带键值和数据,根据键值取哈希值然后求余。过程很简单。如果插入的数据是N个,哈希表大小是M,如果每一个位置是链表的话,那么平均复杂度就是O(N/M),如果是平衡树就是O(log(N/M))。可以看到这个复杂度并没有如期望的那样,因为这是一个静态数组,当N大于M的时候那么就会趋向N了,复杂度就会回到链表的查找。所以可以考虑使用动态数组的方法进行扩展。也就是让M产生变化,当N/M大于一定元素的时候就需要进行扩容,改变M了,当插入数据过少那么久可以缩荣。
首先就是要实现一个resize方法了:

    private void resize(int capacity){
        TreeMap<K, V>[] newHashTable = new TreeMap[capacity];
        for (int i = 0; i < capacity; i++) {
            newHashTable[i] = new TreeMap<>();
        }
        int oldM = this.M;
        this.M = capacity;
        for (int i = 0; i < oldM; i++) {
            TreeMap<K, V> treeMap = hashtable[i];
            for (K key : treeMap.keySet()){
                newHashTable[hash(key)].put(key, treeMap.get(key));
            }
        }

        this.hashtable = newHashTable;
    }

注意到M和新的M之间有一个陷阱,hash中用的是原来的M,而遍历的时候要遍历的是原来的M,所以应该要保存一份。之后就只需要在添加和移除两个操作修改容量即可。
由于均摊复杂度是由O(N/M)决定的,所以复杂度是在O(lowerTol)-O(upperTol)。但事实上这样扩容还有一个问题,乘上两倍之后M就不是素数了,所以动态扩容的时候还需要选取素数的问题。
哈希表的均摊复杂度那么久接近于O(1),很快,但是得到了什么就会失去了什么,这里哈希表久牺牲了顺序性,树结构都是有顺序性的,所以稍微慢一点。哈希表其实也是一个集合,有序集合可以用树结构作为底层数据结构来实现,无序集合可以用哈希表来实现。

hash冲突——开放地址法

如果遇到了冲突,那么就用线性探测的方法,加一看看有没有空的,没有继续加一。但是这样效率有时候是很低的,这里就可以采用类似计算机网络里面的碰撞检测方法,平方探测,一开始是1,又冲突了就4,9,16这样既可。另外还可以使用二次哈希的方法。

最后附上所有GitHub代码:https://github.com/GreenArrow2017/DataStructure_Java

推荐阅读更多精彩内容