小波同学
小波同学

数据结构——AVL树

一、平衡二叉树

平衡二叉树 也称平衡二叉搜索树（Self-balancing binary search tree）是一种结构平衡的二分搜索树。

平衡二叉树由二分搜索树发展而来，在二分搜索树的基础上平衡二叉树需要满足两个条件：

  • 1、它的左右两个子树的高度差的绝对值不超过1。
  • 2、左右两个子树都是一棵平衡二叉树

平衡因子

某结点的左子树与右子树的高度(深度)差即为该结点的平衡因子（BF,Balance Factor）。平衡二叉树上所有结点的平衡因子只可能是 -1，0 或 1。如果某一结点的平衡因子绝对值大于1则说明此树不是平衡二叉树。为了方便计算每一结点的平衡因子我们可以为每个节点赋予height这一属性，表示此节点的高度。

常见的平衡二叉搜索树有：

  • AVL树
  • 红黑树
  • Treap

二、AVL树

AVL树 是由 G. M. Adelson- V elsky 和 E. M. Landis于1962年提出。AVL树是最早的平衡二叉树。

AVL树维护自身的平衡涉及到两个概念：

  • 1、节点的高度
  • 2、节点的平衡因子

节点的高度就是从根节点到该节点的边的总和

节点的 平衡因子 是左子树的高度减去它的右子树的高度

带有平衡因子1、0或 -1的节点被认为是平衡的，因为它的左右子树高度差不超过 1。

面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3，而以8为根节点的树的高度是1)。

三、AVL树代码实现

3.1 基础设计

首先我们可以设计出AVL树节点，并且实现一些简单通用的方法供后续操作。

public class AVLTree, V> {

    //AVLTree 树节点类
    private class Node, V>{

        public K key;

        public V value;

        public Node left;

        public Node right;

        //当前节点所处的高度值
        public int height;

        public Node(K key, V value){
            this.key = key;
            this.value = value;
            this.left = null;
            this.right = null;
            //初始化新的节点都是叶子节点，高度都为1
            this.height = 1;
        }

        @Override
        public String toString() {
            return key.toString() +" : " + value.toString();
        }
    }

    // 根节点
    private Node root;

    // 树容量
    private Integer size;

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

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

    public int getSize() {
        return size;
    }

    /**
     * 判断该二叉树是否是一棵平衡二叉树
     * @return
     */
    private boolean isBalanced(){
        return isBalanced(root);
    }

    /**
     * 判断该二叉树是否是一棵平衡二叉树, 递归调用函数
     * @param node
     * @return
     */
    private boolean isBalanced(Node node){
        //node == null 代表该树是一颗平衡二叉树，
        //平衡二叉树左右子树高度相差不超过1
        // 因为空树的左右子树高度相差不超过1
        if(node == null){
            return true;
        }

        //获取平衡因子
        int balanceFactor = getBalanceFactor(node);

        //左右子树高度相差超过1，则不是平衡二叉树
        if(Math.abs(balanceFactor) > 1){
            return false;
        }
        //递归调用该节点的左右子树，判断是否是平衡二叉树
        return isBalanced(node.left) && isBalanced(node.right);
    }


    /**
     * 返回node节点的高度值
     * @param node
     * @return
     */
    private int getHeight(Node node){
        if(node == null){
            return 0;
        }
        return node.height;
    }

    /**
     * 获取节点node的平衡因子
     * @param node
     * @return
     */
    private int getBalanceFactor(Node node){
        if(node == null){
            return 0;
        }
        return getHeight(node.left) - getHeight(node.right);
    }
}

3.2 添加节点

往平衡二叉树中添加节点很可能会导致二叉树失去平衡，所以我们需要在每次插入节点后进行平衡的维护操作。插入节点破坏平衡性有如下四种情况：

3.2.1 LL（右旋）

LL的意思是向左子树（L）的左孩子（L）中插入新节点后导致不平衡，这种情况下需要右旋操作，而不是说LL的意思是右旋，后面的也是一样。

我们将这种情况抽象出来，得到下图：

我们需要对节点y进行平衡的维护。步骤如下图所示：

 * 右旋转
 * // 对节点y进行向右旋转操作，返回旋转后新的根节点x
 * //        y                              x
 * //       / \                           /   \
 * //      x   T4     向右旋转 (y)        z     y
 * //     / \       - - - - - - - ->    / \   / \
 * //    z   T3                       T1  T2 T3 T4
 * //   / \
 * // T1   T2

/**
 * 右旋转
 * // 对节点y进行向右旋转操作，返回旋转后新的根节点x
 * //        y                              x
 * //       / \                           /   \
 * //      x   T4     向右旋转 (y)        z     y
 * //     / \       - - - - - - - ->    / \   / \
 * //    z   T3                       T1  T2 T3 T4
 * //   / \
 * // T1   T2
 * @param y
 * @return
 */
private Node rightRotate(Node y){
    Node x = y.left;
    Node T3 = x.right;
    //向右旋转过程
    x.right = y;
    y.left = T3;

    //更新节点的高度height值
    y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
    x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
    return x;
}

3.2.2 RR（左旋）

我们将这种情况抽象出来，得到下图：

我们需要对节点y进行平衡的维护。步骤如下图所示：

 * 向左旋转
 * // 对节点y进行向左旋转操作，返回旋转后新的根节点x
 * //    y                             x
 * //  /  \                          /   \
 * // T1   x      向左旋转 (y)       y     z
 * //     / \   - - - - - - - ->   / \   / \
 * //   T2  z                     T1 T2 T3 T4
 * //      / \
 * //     T3 T4

/**
 * 向左旋转
 * // 对节点y进行向左旋转操作，返回旋转后新的根节点x
 * //    y                             x
 * //  /  \                          /   \
 * // T1   x      向左旋转 (y)       y     z
 * //     / \   - - - - - - - ->   / \   / \
 * //   T2  z                     T1 T2 T3 T4
 * //      / \
 * //     T3 T4
 * @param y
 * @return
 */
private Node leftRotate(Node y){
    Node x = y.right;
    Node T2 = x.left;
    //向左旋转过程
    x.left = y;
    y.right = T2;

    //更新节点的高度height值
    y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
    x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
    return x;
}

3.2.3 LR

我们将这种情况抽象出来，得到下图：


我们需要对节点y进行平衡的维护。步骤如下图所示：


3.2.4 RL

我们将这种情况抽象出来，得到下图：


我们需要对节点y进行平衡的维护。步骤如下图所示：


添加节点代码

/**
 * 向AVL树添加新的元素(key,value)
 * @param key
 * @param value
 */
public void add(K key, V value){
    //向根节点添加元素e
    root = add(root, key, value);
}

/**
 * 向以node为根的AVL树中插入元素(key,value)，递归算法
 * @param node
 * @param key
 * @param value
 * @return 返回插入新元素的AVL树的根
 */
private Node add(Node node, K key, V value){
    if(node == null){
        size ++;
        return new Node<>(key, value);
    }

    //递归调用，元素添加到node.left
    if(key.compareTo(node.key) < 0){
        node.left = add(node.left, key, value);
    }else if(key.compareTo(node.key) > 0){
        //递归调用，元素添加到node.right
        node.right = add(node.right, key, value);
    }else {
        node.value = value;
    }

    //更新节点的高度height
    node.height = Math.max(getHeight(node.left), getHeight(node.right)) + 1;

    //计算平衡因子
    int balanceFactor = getBalanceFactor(node);

    //平衡维护
    //LL
    // 左子树比右子树高度超过了1，说明当前节点的平衡被打破
    // 且新添加的节点是在左子树的左子树的左侧
    if(balanceFactor > 1 && getBalanceFactor(node.left) >= 0){
        //右旋转
        return rightRotate(node);
    }

    //RR
    // 右子树比左子树高度超过了1，说明当前节点的平衡被打破
    // 且新添加的节点是在右子树的右子树的右侧
    if(balanceFactor < -1 && getBalanceFactor(node.right) <= 0){
        //左旋转
        return leftRotate(node);
    }

    //LR
    // 左子树比右子树高度超过了1，说明当前节点的平衡被打破
    // 且新添加的节点是在左子树的左子树的右侧
    if(balanceFactor > 1 && getBalanceFactor(node.left) < 0){
        //先对node.left进行左旋转
        node.left = leftRotate(node.left);
        //然后对node进行右旋转
        return rightRotate(node);
    }

    //RL
    // 右子树比左子树高度超过了1，说明当前节点的平衡被打破
    // 且新添加的节点是在右子树的右子树的左侧
    if(balanceFactor < -1 && getBalanceFactor(node.right) > 0){
        //先对node.right进行右旋转
        node.right = rightRotate(node.right);
        //然后对node进行左旋转
        return leftRotate(node);
    }

    //返回当前根节点
    return node;
}

3.3 删除节点

在删除AVL树节点前需要知道二分搜索树的节点删除操作，和二分搜索树删除节点不同的是我们删除AVL树的节点后需要进行平衡的维护操作。

/**
 * 返回以node为根的二分搜索树的最小值所在的节点
 * @param node
 * @return
 */
private Node minimum(Node node){
    if(node.left == null){
        return node;
    }
    return minimum(node.left);
}

/**
 * 从二分搜索树中删除元素键为key的节点, 并返回value, 不存在返回null
 * @param key
 * @return
 */
public V remove(K key){
   Node node = getNode(root, key);
    if(node == null){
        //不存在直接返回null
        return null;
    }
    //存在
    root = remove(root, key);
    return node.value;
}

/**
 * 删除以node为根的二分搜索树中键为key的节点，递归递归方式
 * 返回删除节点后新的二分搜索树的根
 * @param node
 * @param key
 * @return
 */
private Node remove(Node node, K key){
    //节点为空，直接返回
    if(node == null){
        return null;
    }

    //声明要返回去的node
    Node retNode;

    if(key.compareTo(node.key) < 0){
        //待删除元素key小于当前节点的键，向左递归寻找
        node.left = remove(node.left, key);
        retNode = node;
    }else if(key.compareTo(node.key) > 0){
        //待删除元素key大于当前节点的键，向右递归寻找
        node.right = remove(node.right, key);
        retNode = node;
    }else {
        //待删除节点左子树为空
        if(node.left == null){
            Node rightNode = node.right;
            node.right = null;
            size --;
            retNode = rightNode;
        }

        //待删除节点右子树为空
        else if(node.right == null){
            Node rightNode = node.left;
            node.left = null;
            size --;
            retNode = rightNode;
        }else {
            //待删除节点左、右子树不为空
            //找到比待删除节点大的最小节点，即待删除节点右子树最小节点
            //用这个节点顶替待删除节点的位置

            //找到比待删除节点大的最小节点，即待删除节点右子树最小节点
            Node successor = minimum(node.right);
            //删除比待删除节点大的最小节点，并将返回值给succeer的右孩子
            //successor.right = removeMin(node.right);
            successor.right = remove(node.right, successor.key);

            //node.left赋值给successor.left
            successor.left = node.left;
            //node节点和二分搜索树脱离关系
            node.left = node.right = null;
            retNode = successor;
        }
    }

    if(retNode == null){
        //如果删除了该节点，返回的二叉树节点的根节点为空的话
        return null;
    }

    //更新节点的高度height
    retNode.height = Math.max(getHeight(retNode.left), getHeight(retNode.right)) + 1;

    //计算平衡因子
    int balanceFactor = getBalanceFactor(retNode);

    //平衡维护
    //LL
    // 左子树比右子树高度超过了1，说明当前节点的平衡被打破
    // 且新添加的节点是在左子树的左子树的左侧
    if(balanceFactor > 1 && getBalanceFactor(retNode.left) >= 0){
        //右旋转
        return rightRotate(retNode);
    }

    //RR
    // 右子树比左子树高度超过了1，说明当前节点的平衡被打破
    // 且新添加的节点是在右子树的右子树的右侧
    if(balanceFactor < -1 && getBalanceFactor(retNode.right) <= 0){
        //左旋转
        return leftRotate(retNode);
    }

    //LR
    // 左子树比右子树高度超过了1，说明当前节点的平衡被打破
    // 且新添加的节点是在左子树的左子树的右侧
    if(balanceFactor > 1 && getBalanceFactor(retNode.left) < 0){
        //先对node.left进行左旋转
        retNode.left = leftRotate(retNode.left);
        //然后对node进行右旋转
        return rightRotate(retNode);
    }

    //RL
    // 右子树比左子树高度超过了1，说明当前节点的平衡被打破
    // 且新添加的节点是在右子树的右子树的左侧
    if(balanceFactor < -1 && getBalanceFactor(retNode.right) > 0){
        //先对node.right进行右旋转
        retNode.right = rightRotate(retNode.right);
        //然后对node进行左旋转
        return leftRotate(retNode);
    }

    //如果删除节点后，没有打破平衡，直接返回当前根节点
    return retNode;
}

3.4 完整代码

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: huangyibo
 * @Date: 2022/2/26 20:24
 * @Description: AVL Tree
 */

public class AVLTree, V> {

    //AVLTree 树节点类
    private class Node, V>{

        public K key;

        public V value;

        public Node left;

        public Node right;

        //当前节点所处的高度值
        public int height;

        public Node(K key, V value){
            this.key = key;
            this.value = value;
            this.left = null;
            this.right = null;
            //初始化新的节点都是叶子节点，高度都为1
            this.height = 1;
        }

        @Override
        public String toString() {
            return key.toString() +" : " + value.toString();
        }
    }

    // 根节点
    private Node root;

    // 树容量
    private Integer size;

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

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

    public int getSize() {
        return size;
    }

    /**
     * 判断该二叉树是否是一棵二分搜索树
     * @return
     */
    private boolean isBST(){
        List keys = new ArrayList<>();
        inOrder(root, keys);
        for (int i = 1; i < keys.size(); i++) {
            if(keys.get(i - 1).compareTo(keys.get(i)) > 0){
                return false;
            }
        }
        return true;
    }

    //中序遍历
    private void inOrder(Node node, List keys) {
        if(node == null){
            return;
        }
        inOrder(node.left, keys);
        keys.add(node.key);
        inOrder(node.right, keys);
    }

    /**
     * 判断该二叉树是否是一棵平衡二叉树
     * @return
     */
    private boolean isBalanced(){
        return isBalanced(root);
    }

    /**
     * 判断该二叉树是否是一棵平衡二叉树, 递归调用函数
     * @param node
     * @return
     */
    private boolean isBalanced(Node node){
        //node == null 代表该树是一颗平衡二叉树，
        //平衡二叉树左右子树高度相差不超过1
        // 因为空树的左右子树高度相差不超过1
        if(node == null){
            return true;
        }

        //获取平衡因子
        int balanceFactor = getBalanceFactor(node);

        //左右子树高度相差超过1，则不是平衡二叉树
        if(Math.abs(balanceFactor) > 1){
            return false;
        }
        //递归调用该节点的左右子树，判断是否是平衡二叉树
        return isBalanced(node.left) && isBalanced(node.right);
    }


    /**
     * 返回node节点的高度值
     * @param node
     * @return
     */
    private int getHeight(Node node){
        if(node == null){
            return 0;
        }
        return node.height;
    }

    /**
     * 获取节点node的平衡因子
     * @param node
     * @return
     */
    private int getBalanceFactor(Node node){
        if(node == null){
            return 0;
        }
        return getHeight(node.left) - getHeight(node.right);
    }

    /**
     * 右旋转
     * // 对节点y进行向右旋转操作，返回旋转后新的根节点x
     * //        y                              x
     * //       / \                           /   \
     * //      x   T4     向右旋转 (y)        z     y
     * //     / \       - - - - - - - ->    / \   / \
     * //    z   T3                       T1  T2 T3 T4
     * //   / \
     * // T1   T2
     * @param y
     * @return
     */
    private Node rightRotate(Node y){
        Node x = y.left;
        Node T3 = x.right;
        //向右旋转过程
        x.right = y;
        y.left = T3;

        //更新节点的高度height值
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
        return x;
    }


    /**
     * 向左旋转
     * // 对节点y进行向左旋转操作，返回旋转后新的根节点x
     * //    y                             x
     * //  /  \                          /   \
     * // T1   x      向左旋转 (y)       y     z
     * //     / \   - - - - - - - ->   / \   / \
     * //   T2  z                     T1 T2 T3 T4
     * //      / \
     * //     T3 T4
     * @param y
     * @return
     */
    private Node leftRotate(Node y){
        Node x = y.right;
        Node T2 = x.left;
        //向左旋转过程
        x.left = y;
        y.right = T2;

        //更新节点的高度height值
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
        return x;
    }


    /**
     * 向AVL树添加新的元素(key,value)
     * @param key
     * @param value
     */
    public void add(K key, V value){
        //向根节点添加元素e
        root = add(root, key, value);
    }

    /**
     * 向以node为根的AVL树中插入元素(key,value)，递归算法
     * @param node
     * @param key
     * @param value
     * @return 返回插入新元素的AVL树的根
     */
    private Node add(Node node, K key, V value){
        if(node == null){
            size ++;
            return new Node<>(key, value);
        }

        //递归调用，元素添加到node.left
        if(key.compareTo(node.key) < 0){
            node.left = add(node.left, key, value);
        }else if(key.compareTo(node.key) > 0){
            //递归调用，元素添加到node.right
            node.right = add(node.right, key, value);
        }else {
            node.value = value;
        }

        //更新节点的高度height
        node.height = Math.max(getHeight(node.left), getHeight(node.right)) + 1;

        //计算平衡因子
        int balanceFactor = getBalanceFactor(node);

        //平衡维护
        //LL
        // 左子树比右子树高度超过了1，说明当前节点的平衡被打破
        // 且新添加的节点是在左子树的左子树的左侧
        if(balanceFactor > 1 && getBalanceFactor(node.left) >= 0){
            //右旋转
            return rightRotate(node);
        }

        //RR
        // 右子树比左子树高度超过了1，说明当前节点的平衡被打破
        // 且新添加的节点是在右子树的右子树的右侧
        if(balanceFactor < -1 && getBalanceFactor(node.right) <= 0){
            //左旋转
            return leftRotate(node);
        }

        //LR
        // 左子树比右子树高度超过了1，说明当前节点的平衡被打破
        // 且新添加的节点是在左子树的左子树的右侧
        if(balanceFactor > 1 && getBalanceFactor(node.left) < 0){
            //先对node.left进行左旋转
            node.left = leftRotate(node.left);
            //然后对node进行右旋转
            return rightRotate(node);
        }

        //RL
        // 右子树比左子树高度超过了1，说明当前节点的平衡被打破
        // 且新添加的节点是在右子树的右子树的左侧
        if(balanceFactor < -1 && getBalanceFactor(node.right) > 0){
            //先对node.right进行右旋转
            node.right = rightRotate(node.right);
            //然后对node进行左旋转
            return leftRotate(node);
        }

        //返回当前根节点
        return node;
    }



    /**
     * 根据key从当前以当前node为根节点中寻找value, 不存在返回null
     * @param node
     * @param key
     * @return
     */
    private Node getNode(Node node, K key){
        //递归终止条件
        if(node == null){
            return null;
        }

        //待寻找key比当前节点key小，递归调用node.left
        if(key.compareTo(node.key) < 0){
            return getNode(node.left, key);
        }else if(key.compareTo(node.key) > 0){
            //待寻找key比当前节点key大，递归调用node.right
            return getNode(node.right, key);
        }else {
            //待寻找key和当前节点key相等，直接返回
            return node;
        }
    }


    public boolean contains(K key) {
        return getNode(root, key) != null;
    }


    public void set(K key, V value) {
        Node node = getNode(root, key);
        if(node == null){
            //不存在直接抛异常
            throw new IllegalArgumentException(key + " doesn't exist!");
        }

        //key已存在，则更新
        node.value = value;
    }

    public V get(K key) {
        Node node = getNode(root, key);
        return node == null ? null : node.value;
    }

    /**
     * 返回以node为根的二分搜索树的最小值所在的节点
     * @param node
     * @return
     */
    private Node minimum(Node node){
        if(node.left == null){
            return node;
        }
        return minimum(node.left);
    }

    /**
     * 从二分搜索树中删除元素键为key的节点, 并返回value, 不存在返回null
     * @param key
     * @return
     */
    public V remove(K key){
       Node node = getNode(root, key);
        if(node == null){
            //不存在直接返回null
            return null;
        }
        //存在
        root = remove(root, key);
        return node.value;
    }

    /**
     * 删除以node为根的二分搜索树中键为key的节点，递归递归方式
     * 返回删除节点后新的二分搜索树的根
     * @param node
     * @param key
     * @return
     */
    private Node remove(Node node, K key){
        //节点为空，直接返回
        if(node == null){
            return null;
        }

        //声明要返回去的node
        Node retNode;

        if(key.compareTo(node.key) < 0){
            //待删除元素key小于当前节点的键，向左递归寻找
            node.left = remove(node.left, key);
            retNode = node;
        }else if(key.compareTo(node.key) > 0){
            //待删除元素key大于当前节点的键，向右递归寻找
            node.right = remove(node.right, key);
            retNode = node;
        }else {
            //待删除节点左子树为空
            if(node.left == null){
                Node rightNode = node.right;
                node.right = null;
                size --;
                retNode = rightNode;
            }

            //待删除节点右子树为空
            else if(node.right == null){
                Node rightNode = node.left;
                node.left = null;
                size --;
                retNode = rightNode;
            }else {
                //待删除节点左、右子树不为空
                //找到比待删除节点大的最小节点，即待删除节点右子树最小节点
                //用这个节点顶替待删除节点的位置

                //找到比待删除节点大的最小节点，即待删除节点右子树最小节点
                Node successor = minimum(node.right);
                //删除比待删除节点大的最小节点，并将返回值给succeer的右孩子
                //successor.right = removeMin(node.right);
                successor.right = remove(node.right, successor.key);

                //node.left赋值给successor.left
                successor.left = node.left;
                //node节点和二分搜索树脱离关系
                node.left = node.right = null;
                retNode = successor;
            }
        }

        if(retNode == null){
            //如果删除了该节点，返回的二叉树节点的根节点为空的话
            return null;
        }

        //更新节点的高度height
        retNode.height = Math.max(getHeight(retNode.left), getHeight(retNode.right)) + 1;

        //计算平衡因子
        int balanceFactor = getBalanceFactor(retNode);

        //平衡维护
        //LL
        // 左子树比右子树高度超过了1，说明当前节点的平衡被打破
        // 且新添加的节点是在左子树的左子树的左侧
        if(balanceFactor > 1 && getBalanceFactor(retNode.left) >= 0){
            //右旋转
            return rightRotate(retNode);
        }

        //RR
        // 右子树比左子树高度超过了1，说明当前节点的平衡被打破
        // 且新添加的节点是在右子树的右子树的右侧
        if(balanceFactor < -1 && getBalanceFactor(retNode.right) <= 0){
            //左旋转
            return leftRotate(retNode);
        }

        //LR
        // 左子树比右子树高度超过了1，说明当前节点的平衡被打破
        // 且新添加的节点是在左子树的左子树的右侧
        if(balanceFactor > 1 && getBalanceFactor(retNode.left) < 0){
            //先对node.left进行左旋转
            retNode.left = leftRotate(retNode.left);
            //然后对node进行右旋转
            return rightRotate(retNode);
        }

        //RL
        // 右子树比左子树高度超过了1，说明当前节点的平衡被打破
        // 且新添加的节点是在右子树的右子树的左侧
        if(balanceFactor < -1 && getBalanceFactor(retNode.right) > 0){
            //先对node.right进行右旋转
            retNode.right = rightRotate(retNode.right);
            //然后对node进行左旋转
            return leftRotate(retNode);
        }

        //如果删除节点后，没有打破平衡，直接返回当前根节点
        return retNode;
    }
}

四、AVL树实现映射(Map)

  • Map接口
public interface Map {

    /**
     * 添加元素
     * @param key
     * @param value
     */
    void add(K key, V value);

    /**
     * 删除元素，返回元素对应的value
     * @param key
     * @return
     */
    V remove(K key);

    /**
     * 是否包含key
     * @param key
     * @return
     */
    boolean contains(K key);

    /**
     * 修改元素key对应的value
     * @param key
     * @param value
     */
    void set(K key, V value);

    /**
     * 获取key对应的value
     * @param key
     * @return
     */
    V get(K key);

    /**
     * 映射的元素个数
     * @return
     */
    int getSize();

    /**
     * 映射是否为空
     * @return
     */
    boolean isEmpty();
}
  • AVLTreeMap实现
/**
 * @Author: huangyibo
 * @Date: 2022/2/27 0:47
 * @Description: AVLTreeMap 底层基于AVLTree
 */

public class AVLTreeMap, V> implements Map {

    private AVLTree avlTree;

    public AVLTreeMap(){
        avlTree = new AVLTree<>();
    }

    @Override
    public void add(K key, V value) {
        avlTree.add(key,value);
    }

    @Override
    public V remove(K key) {
        return avlTree.remove(key);
    }

    @Override
    public boolean contains(K key) {
        return avlTree.contains(key);
    }

    @Override
    public void set(K key, V value) {
        avlTree.set(key, value);
    }

    @Override
    public V get(K key) {
        return avlTree.get(key);
    }

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

    @Override
    public boolean isEmpty() {
        return avlTree.isEmpty();
    }
}

五、AVL树实现集合(Set)

  • 集合(Set)接口
public interface Set {

    /**
     * 添加元素
     * @param e
     */
    void add(E e);

    /**
     * 删除元素
     * @param e
     */
    void remove(E e);

    /**
     * 集合是否包含元素
     * @param e
     * @return
     */
    boolean contains(E e);

    /**
     * 集合的元素个数
     * @return
     */
    int getSize();

    /**
     * 集合是否为空
     * @return
     */
    boolean isEmpty();
}
  • AVLTreeSet实现
/**
 * @Author: huangyibo
 * @Date: 2022/2/27 0:52
 * @Description: AVLTreeSet 底层基于AVLTree
 */

public class AVLTreeSet> implements Set {

    private AVLTree avlTree;

    public AVLTreeSet(){
        avlTree = new AVLTree<>();
    }

    @Override
    public void add(E e) {
        avlTree.add(e, null);
    }

    @Override
    public void remove(E e) {
        avlTree.remove(e);
    }

    @Override
    public boolean contains(E e) {
        return avlTree.contains(e);
    }

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

    @Override
    public boolean isEmpty() {
        return avlTree.isEmpty();
    }
}

参考：
https://chiclaim.blog.csdn.net/article/details/80740418

https://catwing.blog.csdn.net/article/details/89110319

你可能感兴趣的:(数据结构——AVL树)

  • 数据结构奇妙旅程之深入解析快速排序 山间漫步人生路 数据结构排序算法算法
    快速排序（QuickSort）是一种高效的排序算法，它使用了分治法的策略来将一个数组排序。其基本思想是选择一个基准元素，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比基准元素小，另一部分的所有数据都比基准元素大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。工作原理选择基准：从待排序的序列中选一个元素作为基准（pivo
  • OpenCV 如何使用 XML 和 YAML 文件的文件输入和输出 愚梦者 深度学习人工智能计算机视觉c++opencv
    返回：OpenCV系列文章目录（持续更新中......）上一篇：如何利用OpenCV4.9离散傅里叶变换下一篇:目标本文内容主要介绍：如何使用YAML或XML文件打印和读取文件和OpenCV的文本条目？如何对OpenCV数据结构做同样的事情？如何为您的数据结构执行此操作？使用OpenCV数据结构，例如cv::FileStorage,cv::FileNodeorcv::FileNodeIterato
  • 【数据结构】实验一 实现顺序表各种基本运算的算法 张鱼·小丸子 数据结构实验c++数据结构
    题目：实现顺序表各种基本运算的算法要求：1、建立一个顺序表，输入n个元素并输出；2、查找线性表中的最大元素并输出；3、在线性表的第i个元素前插入一个正整数x；4、删除线性表中的第j个元素；5、将线性表中的元素按升序排列；6、将线性表中的元素就地逆序（只允许用一个暂存单元）；#include#defineSIZE1000usingnamespacestd;typedefstruct{int*a;//
  • Java中HashMap底层数据结构及主要参数? 山间漫步人生路 java数据结构开发语言
    在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
  • java中栈和队列的解释和使用 。。。。。96 java开发语言
    一、栈在Java中，栈（Stack）是一种基于后进先出（LIFO）原则的数据结构，用于存储和管理对象。栈通常用于方法调用、表达式求值、历史记录管理等场景。在Java中，栈的常用方法包括：push(Eitem)：将元素压入栈顶。pop()：移除并返回栈顶元素。peek()：查看栈顶元素，但不移除它。empty()：检查栈是否为空。search(Objecto)：查找特定元素在栈中的位置，返回相对于栈
  • 数据结构——单向链表（C语言版） GG Bond.ฺ 数据结构链表c语言
    在数据结构和算法中，链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C语言中，我们可以使用指针来实现单向链表。下面将详细介绍如何用C语言实现单向链表。目录1.定义节点结构体2.初始化链表3.插入节点4.删除节点5.遍历链表6.主函数1.定义节点结构体首先，我们需要定义表示链表节点的结构体。每个节点包含一个数据域和一个指向下一个节点的指针域。typedefst
  • 数据结构之有序表 普通的一个普通猿 数据结构数据结构
    目录一简介二抽象数据类型描述三有序表的存储结构三有序表的基本运算一简介有序表是一种线性数据结构，其中元素按照特定顺序排列，每个元素具有一个唯一的键值，并且该键值在表中的位置反映了其相对大小关系。在有序表中，可以根据键值快速查找、插入和删除元素，常见的有序表包括有序数组和平衡二叉搜索树等结构。通过维护元素间的有序性，有序表提供了高效的检索服务，例如可以在对数时间内完成查找、插入和删除操作。二抽象数据
  • 【数据结构】复杂度计算 一只小鹿lu 数据结构
    1、时间复杂度1.1概念时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。1.2大O的渐进表示法大O符号（BigOnotation）：是用于描述函数渐进行为的数学符号。推导大O阶方法：1、用常数1取代运行时间中的所有加法常数。2、在修改后的运行次数函数中，只保
  • 数据结构——双向链表（C语言版） GG Bond.ฺ 数据结构链表c语言
    上一章：数据结构——单向链表（C语言版）-CSDN博客目录什么是双向链表？双向链表的节点结构双向链表的基本操作完整的双向链表示例总结什么是双向链表？双向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两个指针：一个指向前一个节点，一个指向后一个节点。双向链表可以在任意位置高效地插入和删除节点，相比单向链表，双向链表可以双向遍历，但相应地需要更多的内存空间存储额外的指针。双向链表的节点结构
  • 数据结构面试常见问题 工作学习小贴士 java数据结构
    数据结构是面试中经常被问及的重要主题之一，以下是一些常见的数据结构面试问题：什么是数据结构？为什么需要数据结构？数组和链表有什么区别？各自的优缺点是什么？树的常见类型有哪些？请解释它们的特点。图的常见表示方法有哪些？有向图和无向图有什么区别？栈和队列是什么？它们在哪些场景中有用？常见的排序算法有哪些？请分别介绍它们的思想和时间复杂度。什么是哈希表（HashTable）？它的工作原理是什么？如何处理
  • java后端工程师八股文合集 吹林 springcloudeurekajavajava-eespringboot
    1、SQL调优的基本步骤如下：确认性能瓶颈：首先要确定数据库中哪些查询是慢的，哪些查询最需要优化。可以通过监控数据库的CPU、磁盘I/O、网络I/O、缓存等指标来确定性能瓶颈。优化查询语句：如果查询语句本身存在问题，例如使用了不必要的子查询、重复的连接操作等，就需要对查询语句进行优化。优化索引：索引是提高查询性能的关键因素之一。可以通过创建、修改、删除索引来优化查询性能。优化数据结构：如果数据库中
  • 突破编程_C++_面试（STL 编程 stack） breakthrough_01 突破编程_C++_面试c++面试
    1请简述std::stack在C++STL中的基本功能和使用场景std::stack在C++STL（标准模板库）中是一个容器适配器，专门用于实现后进先出（LIFO，Last-In-First-Out）的数据结构。其基本功能和使用场景如下：基本功能：push(element)：向栈顶添加元素。pop()：移除栈顶元素。如果栈为空，则此操作可能会导致未定义行为。top()：返回栈顶元素的引用，但不移除
  • 无锁队列（Lock-Free Queue） 笨死de猪 游戏服务器架构开发语言c++无锁队列
    一、什么是无锁队列无锁队列（Lock-FreeQueue）是一种不使用锁机制（如互斥锁或读写锁）来实现线程安全的数据结构，是lock-free中最基本的数据结构。它通过复杂的原子操作（如CAS操作，在C++中，可以使用std::atomic库提供的原子操作）来确保在多线程环境下的正确性和一致性。无锁队列的设计目标是在高并发场景下提供高性能的入队和出队操作，避免了锁机制带来的性能开销和潜在的死锁问题
  • Redis是如何避免“数组+链表”的过长问题 龙大. Redisredis散列表数据库
    目录一、扩展和收缩二、使用高质量的哈希函数三、使用跳跃表（skiplist）或其他数据结构四、哈希表分片一、扩展和收缩Redis通过动态调整哈希表的大小来解决“数组+链表”的长度问题，这涉及到两个过程：扩展(Expand)和收缩(Shrink)。扩展:当哈希表的负载因子(loadfactor)超过一个阈值时，Redis会进行扩展操作。负载因子是哈希表已存储的元素数量与哈希表大小的比值。扩展操作包括
  • 请介绍一下大数据主要是干什么的？决策支持预测分析用户行为分析个性化服务操作优化风险管理创新与产品开发加拿大卡尔加里大学历史背景学术结构研究和创新校园设施 盛溪的猫猫 感悟大数据英语加拿大
    目录请介绍一下大数据主要是干什么的？决策支持预测分析用户行为分析个性化服务操作优化风险管理创新与产品开发加拿大卡尔加里大学历史背景学术结构研究和创新校园设施国际化学生生活大语言模型目前的问题卡尔加里经济地理和气候文化和活动教育交通绿色城市AVL树的旋转单右旋（LL旋转）单左旋（RR旋转）左右旋（LR旋转）右左旋（RL旋转）请介绍一下大数据主要是干什么的？大数据是一个涉及从极其庞大和复杂的数据集中提
  • 编程之美_目录 wangwangmoon_light 编程之美算法
    编程之美0）0_0_常用函数库0）0_1_测试函数总结1）1.1数据结构之数组2）1.2数据结构之字符串3）1.3数据结构之链表4）1.4数据结构之队列5）1.5数据结构之栈5）1.6数据结构之二叉树6）1.7数据结构之BFS7）1.8数据结构之DFS8）2.1算法之动态规划
  • 数据结构与算法中顺序栈中入栈和出栈 小范想进鹅厂 gitc++c语言java数据结构
    在数据结构中，顺序栈是一种基于数组实现的栈结构。它具有先进后出的特点，可以通过入栈和出栈操作对栈进行操作。顺序栈的入栈操作即将元素插入到栈顶，出栈操作即将栈顶元素删除并返回。以下是顺序栈的入栈和出栈的示例代码：```python#定义顺序栈类classSeqStack:def__init__(self,max_size):self.max_size=max_sizeself.data=[None]
  • 数据结构链表 小范想进鹅厂 链表数据结构
    链表是一种常见的线性数据结构，用于存储一组元素。与数组不同的是，链表的元素可以不连续地存储在内存中，而是通过指针相互连接起来。链表由一系列节点组成。每个节点包含两部分：数据部分和指针部分。数据部分用于存储元素的值，指针部分用于指向下一个节点。链表有两种常见的类型：单向链表和双向链表。-单向链表：每个节点只有一个指针，指向下一个节点。链表的头节点指向第一个节点，尾节点指向最后一个节点，尾节点的指针为
  • 还在使用 RESTful API ? 试一试 GraphQL zoe_ya restfulgraphql后端
    前言GraphQL和RESTfulAPI是两种不同的网络通信接口设计理念，它们都可以用于客户端和服务器之间的数据交换，但是有着不同的工作方式和特点。各自的特点以及优缺点GraphQL：特点：查询语言:GraphQL是一个查询语言，允许客户端精确地指定需要的数据结构。单一端点:与REST不同，GraphQL通常只使用一个端点来处理所有的数据请求。强类型系统:GraphQL服务定义了一套强类型的API
  • C语言经典面试题目（十五） Masami22 C语言面试题目c语言面试开发语言职场和发展
    1、如何在C语言中实现堆数据结构？在C语言中，可以通过动态内存分配来实现堆数据结构。一种常见的方式是使用数组来表示堆，并使用堆的性质来维护数组的结构。以下是一个简单的堆数据结构的示例：#include#include#defineMAX_HEAP_SIZE100typedefstruct{int*elements;intsize;intcapacity;}Heap;Heap*createHeap(
  • Redis 的数据类型及使用场景 程序员JavaWind redis数据库缓存
    String最常规的set/get操作，Value可以是String也可以是数字。一般做一些复杂的计数功能的缓存。Hash这里Value存放的是结构化的对象，比较方便的就是操作其中的某个字段。我在做单点登录的时候，就是用这种数据结构存储用户信息，以CookieId作为Key，设置30分钟为缓存过期时间，能很好的模拟出类似Session的效果。List使用List的数据结构，可以做简单的消息队列的功
  • C语言经典面试题目（十二） Masami22 C语言面试题目c语言面试开发语言职场和发展算法数据结构链表
    1、如何在C语言中实现栈和队列数据结构？栈（Stack）：栈是一种后进先出（LIFO）的数据结构，可以使用数组或链表来实现。以下是一个使用数组实现的简单栈的示例：#defineMAX_SIZE100typedefstruct{intdata[MAX_SIZE];inttop;}Stack;voidinitStack(Stack*s){s->top=-1;}intisEmpty(Stack*s){r
  • C++从零开始(day44)——二叉搜索树 云淡风轻kk c++开发语言
    这是关于一个普通双非本科大一学生的C++的学习记录贴在此前，我学了一点点C语言还有简单的数据结构，如果有小伙伴想和我一起学习的，可以私信我交流分享学习资料那么开启正题今天分享的是关于二叉搜索树的知识点1.二叉搜索树概念二叉搜索树又叫做二叉排序树，有以下性质（或为空树）1.左子树结点所有结点的值都小于根节点的值2.右子树结点所有结点的值都大于根节点的值3.它的左右子树也都是二叉搜索树2.二叉搜索树操
  • C语言从入门到熟悉------第五阶段 DaveVV C语言专栏c语言开发语言c++算法
    结构体结构体很重要，一定要掌握。但是在很多C语言书籍中结构体的内容讲得非常少，因为从结构体开始，后面介绍的内容已经超出C语言基础的范畴，属于C高级编程部分了。仅仅具备前面的知识是远远不够的，因为在实际编程中，真正核心的部分正是自本章开始的C高级部分。而且结构体会影响到对数据结构和面向对象语言的学习。首先数据结构里面都是链表，所以必须要学结构体。其次如果以后要学习C++或Java的话，那么就必须了解
  • 5.68 BCC工具之runqlat.py解读 高桐@BILL AndroideBPFBooklinuxebpfandroidbccpython
    一，工具简介runqlat工具用于分析和监视运行队列延迟。运行队列是操作系统内核中用于管理待运行进程的数据结构。当进程准备运行时，它们会被添加到运行队列中，然后由调度器选择并在CPU上执行。runqlat工具通过测量进程在运行队列中等待的时间，并以直方图的形式展示，它显示了任务等待在CPU上运行的时间。这帮助开发者了解系统调度行为的性能。使用该工具可以帮助我们识别和解决与调度延迟相关的问题。例如，
  • ZooKeeper 概述 龙大. Zookeeperzookeeper分布式云原生
    定义和功能ZooKeeper是一个开源的分布式协调服务，由Apache软件基金会托管。它主要用于解决分布式应用中遇到的一些复杂问题，如命名服务、状态同步服务、集群管理、分布式锁和队列管理等。核心特性一致性:ZooKeeper保证了客户端之间的数据一致性，即客户端无论连接到哪一个ZooKeeper服务器，看到的数据都是一致的。简单的数据模型:ZooKeeper维护了一个类似文件系统的数据结构，它的数
  • linux基础学习，java中间件、数据库与spring框架 疯狂Android讲义 Javajavalinux学习
    蚂蚁金服一面：先自我介绍，讲讲自己基础掌握情况，以及项目经历平时会用到哪些数据结构？链表和数组的优缺点？解决hash冲突的方法有哪些？讲讲自己对HashMap的理解，以及和Weakhashmap的区别？你刚才讲的是JDK1.7版本的实现，知道JDK1.8做了哪些改动么？你们在微服务中用RPC通信还是REST？RPC和HTTP的关系是什么？谈谈什么是HTTP的长连接和短连接？TCP的三次握手和四次挥
  • python推导式 电商人学python python基础及进阶python开发语言经验分享
    python推导式是一种简洁且强大的内建语法结构，它允许我们以一种极其紧凑和易于理解的方式创建新的列表、字典、集合或生成器对象，能够更高效地操作和转换数据结构。列表推导式基本语法如下图：其他推导式的语法也基本相似，看着有点lambda的感觉，上面图片遍历一个名为oldlist的列表，并将大于0的元素逐一进行双倍运算后，添加至新列表newlist中。接下来我们逐一分析各个推导式：目录一、列表推导式二
  • 数据结构.pta测试二 丰海洋 数据结构
    #includeusingnamespacestd;typedefstructnode{intdata;node*next;}*List;ListlistPoduce(){inta;ListL;node*r,*new0;//创建指针L=newnode();//分配空间r=L;cin>>a;while(a!=-1){new0=newnode();new0->data=a;r->next=new0;r
  • 《数据结构》复试问答题总结 CarmenHu 计算机复试问答题数据结构深度优先算法
    请简述深度优先遍历、广度优先遍历的基本思想？：深度遍历是在图中先选择一个顶点，随后的每次遍历中选择与顶点相邻并且还没有遍历过的结点进行遍历，类似于树的先序遍历广度遍历是先在图中选择一个顶点，并加入队列中，然后向该顶点的所有未访问过的邻接点进行扩散，加入到队列当中，类似于树的广度遍历简述二叉树，完全二叉树，二叉排序树，平衡二叉树的特性：二叉树（BinaryTree）：要求其任意节点的子节点数量不超过
  • LeetCode[Math] - #66 Plus One Cwind javaLeetCode题解AlgorithmMath
    原题链接：#66 Plus One   要求： 给定一个用数字数组表示的非负整数，如num1 = {1, 2, 3, 9}, num2 = {9, 9}等，给这个数加上1。 注意： 1. 数字的较高位存在数组的头上，即num1表示数字1239 2. 每一位（数组中的每个元素）的取值范围为0~9   难度：简单   分析： 题目比较简单，只须从数组
  • JQuery中$.ajax()方法参数详解 AILIKES JavaScriptjsonpjqueryAjaxjson
    url: 要求为String类型的参数，（默认为当前页地址）发送请求的地址。 type: 要求为String类型的参数，请求方式（post或get）默认为get。注意其他http请求方法，例如put和    delete也可以使用，但仅部分浏览器支持。 timeout: 要求为Number类型的参数，设置请求超时时间（毫秒）。此设置将覆盖$.ajaxSetup()方法的全局
  • JConsole & JVisualVM远程监视Webphere服务器JVM Kai_Ge JVisualVMJConsoleWebphere
        JConsole是JDK里自带的一个工具，可以监测Java程序运行时所有对象的申请、释放等动作，将内存管理的所有信息进行统计、分析、可视化。我们可以根据这些信息判断程序是否有内存泄漏问题。 　　使用JConsole工具来分析WAS的JVM问题，需要进行相关的配置。 　　首先我们看WAS服务器端的配置. 　　1、登录was控制台https://10.4.119.18
  • 自定义annotation 120153216 annotation
    Java annotation 自定义注释@interface的用法 一、什么是注释      说起注释，得先提一提什么是元数据(metadata)。所谓元数据就是数据的数据。也就是说，元数据是描述数据的。就象数据表中的字段一样，每个字段描述了这个字段下的数据的含义。而J2SE5.0中提供的注释就是java源代码的元数据，也就是说注释是描述java源
  • CentOS 5/6.X 使用 EPEL YUM源 2002wmj centos
    CentOS 6.X 安装使用EPEL YUM源1. 查看操作系统版本[root@node1 ~]# uname -a Linux node1.test.com 2.6.32-358.el6.x86_64 #1 SMP Fri Feb 22 00:31:26 UTC 2013 x86_64 x86_64 x86_64 GNU/Linux [root@node1 ~]#
  • 在SQLSERVER中查找缺失和无用的索引SQL 357029540 SQL Server
    --缺失的索引 SELECT  avg_total_user_cost * avg_user_impact * ( user_scans + user_seeks ) AS PossibleImprovement ,          last_user_seek ,    
  • Spring3 MVC 笔记（二） —json+rest优化 7454103 Spring3 MVC
    接上次的 spring mvc 注解的一些详细信息！                          其实也是一些个人的学习笔记  呵呵！
  • 替换“\”的时候报错Unexpected internal error near index 1 \ ^ adminjun java“\替换”
    发现还是有些东西没有刻子脑子里,,过段时间就没什么概念了,所以贴出来...以免再忘...   在拆分字符串时遇到通过 \ 来拆分，可是用所以想通过转义 \\ 来拆分的时候会报异常   public class Main {          /*
  • POJ 1035 Spell checker(哈希表) aijuans 暴力求解--哈希表
    /* 题意：输入字典，然后输入单词，判断字典中是否出现过该单词，或者是否进行删除、添加、替换操作，如果是，则输出对应的字典中的单词 要求按照输入时候的排名输出 题解：建立两个哈希表。一个存储字典和输入字典中单词的排名，一个进行最后输出的判重 */ #include <iostream> //#define using namespace std; const int HASH =
  • 通过原型实现javascript Array的去重、最大值和最小值 ayaoxinchao JavaScriptarrayprototype
    用原型函数（prototype）可以定义一些很方便的自定义函数，实现各种自定义功能。本次主要是实现了Array的去重、获取最大值和最小值。 实现代码如下：   <script type="text/javascript"> Array.prototype.unique = function() { var a = {}; var le
  • UIWebView实现https双向认证请求 bewithme UIWebViewhttpsObjective-C
              什么是HTTPS双向认证我已在先前的博文 ASIHTTPRequest实现https双向认证请求 中有讲述，不理解的读者可以先复习一下。本文是用UIWebView来实现对需要客户端证书验证的服务请求，网上有些文章中有涉及到此内容，但都只言片语，没有讲完全，更没有完整的代码，让人困扰不已。但是此知
  • NoSQL数据库之Redis数据库管理(Redis高级应用之事务处理、持久化操作、pub_sub、虚拟内存) bijian1013 redis数据库NoSQL
    3.事务处理         Redis对事务的支持目前不比较简单。Redis只能保证一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。当一个client在一个连接中发出multi命令时，这个连接会进入一个事务上下文，该连接后续的命令不会立即执行，而是先放到一个队列中，当执行exec命令时，redis会顺序的执行队列中
  • 各数据库分页sql备忘 bingyingao oraclesql分页
    ORACLE 下面这个效率很低 SELECT * FROM ( SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_FS_RETURN order by id desc) A ) WHERE RN <20; 下面这个效率很高 SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_
  • 【Scala七】Scala核心一：函数 bit1129 scala
    1. 如果函数体只有一行代码，则可以不用写{},比如 def print(x: Int) = println(x) 一行上的多条语句用分号隔开，则只有第一句属于方法体，例如   def printWithValue(x: Int) : String= println(x); "ABC"   上面的代码报错，因为，printWithValue的方法
  • 了解GHC的factorial编译过程 bookjovi haskell
    GHC相对其他主流语言的编译器或解释器还是比较复杂的，一部分原因是haskell本身的设计就不易于实现compiler，如lazy特性，static typed，类型推导等。 关于GHC的内部实现有篇文章说的挺好，这里，文中在RTS一节中详细说了haskell的concurrent实现，里面提到了green thread，如果熟悉Go语言的话就会发现，ghc的concurrent实现和Go有点类
  • Java-Collections Framework学习与总结-LinkedHashMap BrokenDreams LinkedHashMap
            前面总结了java.util.HashMap，了解了其内部由散列表实现，每个桶内是一个单向链表。那有没有双向链表的实现呢？双向链表的实现会具备什么特性呢？来看一下HashMap的一个子类——java.util.LinkedHashMap。       
  • 读《研磨设计模式》-代码笔记-抽象工厂模式-Abstract Factory bylijinnan abstract
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * Abstract Factory Pattern * 抽象工厂模式的目的是： * 通过在抽象工厂里面定义一组产品接口，方便地切换“产品簇” * 这些接口是相关或者相依赖的
  • 压暗面部高光 cherishLC PS
    方法一、压暗高光&重新着色 当皮肤很油又使用闪光灯时，很容易在面部形成高光区域。 下面讲一下我今天处理高光区域的心得： 皮肤可以分为纹理和色彩两个属性。其中纹理主要由亮度通道（Lab模式的L通道）决定，色彩则由a、b通道确定。 处理思路为在保持高光区域纹理的情况下，对高光区域着色。具体步骤为：降低高光区域的整体的亮度，再进行着色。 如果想简化步骤，可以只进行着色（参看下面的步骤1
  • Java VisualVM监控远程JVM crabdave visualvm
    Java VisualVM监控远程JVM    JDK1.6开始自带的VisualVM就是不错的监控工具. 这个工具就在JAVA_HOME\bin\目录下的jvisualvm.exe, 双击这个文件就能看到界面   通过JMX连接远程机器, 需要经过下面的配置: 1. 修改远程机器JDK配置文件 (我这里远程机器是linux).    
  • Saiku去掉登录模块 daizj saiku登录olapBI
    1、修改applicationContext-saiku-webapp.xml <security:intercept-url pattern="/rest/**" access="IS_AUTHENTICATED_ANONYMOUSLY" />  <security:intercept-url pattern=&qu
  • 浅析 Flex中的Focus dsjt htmlFlexFlash
    关键字：focus、 setFocus、 IFocusManager、KeyboardEvent 焦点、设置焦点、获得焦点、键盘事件 一、无焦点的困扰——组件监听不到键盘事件 原因：只有获得焦点的组件（确切说是InteractiveObject）才能监听到键盘事件的目标阶段；键盘事件（flash.events.KeyboardEvent）参与冒泡阶段，所以焦点组件的父项（以及它爸
  • Yii全局函数使用 dcj3sjt126com yii
    由于YII致力于完美的整合第三方库，它并没有定义任何全局函数。yii中的每一个应用都需要全类别和对象范围。例如，Yii::app()->user;Yii::app()->params['name'];等等。我们可以自行设定全局函数，使得代码看起来更加简洁易用。(原文地址) 我们可以保存在globals.php在protected目录下。然后，在入口脚本index.php的，我们包括在
  • 设计模式之单例模式二（解决无序写入的问题） come_for_dream 单例模式volatile乱序执行双重检验锁
                    在上篇文章中我们使用了双重检验锁的方式避免懒汉式单例模式下由于多线程造成的实例被多次创建的问题，但是因为由于JVM为了使得处理器内部的运算单元能充分利用，处理器可能会对输入代码进行乱序执行（Out Of Order Execute）优化，处理器会在计算之后将乱序执行的结果进行重组，保证该
  • 程序员从初级到高级的蜕变 gcq511120594 框架工作PHPandroidhtml5
    软件开发是一个奇怪的行业，市场远远供不应求。这是一个已经存在多年的问题，而且随着时间的流逝，愈演愈烈。 我们严重缺乏能够满足需求的人才。这个行业相当年轻。大多数软件项目是失败的。几乎所有的项目都会超出预算。我们解决问题的最佳指导方针可以归结为——“用一些通用方法去解决问题，当然这些方法常常不管用，于是，唯一能做的就是不断地尝试，逐个看看是否奏效”。 现在我们把淫浸代码时间超过3年的开发人员称为
  • Reverse Linked List hcx2013 list
    Reverse a singly linked list.   /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ p
  • Spring4.1新特性——数据库集成测试 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • C# Ajax上传图片同时生成微缩图(附Demo) liyonghui160com
        1.Ajax无刷新上传图片,详情请阅我的这篇文章。（jquery + c# ashx）         2.C#位图处理  System.Drawing。         3.最新demo支持IE7,IE8,Fir
  • Java list三种遍历方法性能比较 pda158 java
    从c/c++语言转向java开发，学习java语言list遍历的三种方法，顺便测试各种遍历方法的性能，测试方法为在ArrayList中插入1千万条记录，然后遍历ArrayList，发现了一个奇怪的现象，测试代码例如以下： package com.hisense.tiger.list; import java.util.ArrayList; import java.util.Iterator;
  • 300个涵盖IT各方面的免费资源（上）——商业与市场篇 shoothao seo商业与市场IT资源免费资源
    A.网站模板+logo+服务器主机+发票生成 HTML5 UP:响应式的HTML5和CSS3网站模板。 Bootswatch:免费的Bootstrap主题。 Templated:收集了845个免费的CSS和HTML5网站模板。 Wordpress.org|Wordpress.com:可免费创建你的新网站。 Strikingly:关注领域中免费无限的移动优
  • localStorage、sessionStorage uule localStorage
    W3School 例子   HTML5 提供了两种在客户端存储数据的新方法： localStorage - 没有时间限制的数据存储 sessionStorage - 针对一个 session 的数据存储   之前，这些都是由 cookie 完成的。但是 cookie 不适合大量数据的存储，因为它们由每个对服务器的请求来传递，这使得 cookie 速度很慢而且效率也不
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他