加瓦不加班
加瓦不加班

二叉搜索树的基础操作

如果对于二叉搜索树不是太清楚，为什么要使用二叉搜索树？作者推荐：二叉搜索树的初步认识_加瓦不加班的博客-CSDN博客

定义节点

static class BSTNode {
    int key; // 若希望任意类型作为 key, 则后续可以将其设计为 Comparable 接口
    Object value;
    BSTNode left;
    BSTNode right;

    public BSTNode(int key) {
        this.key = key;
        this.value = key;
    }

    public BSTNode(int key, Object value) {
        this.key = key;
        this.value = value;
    }

    public BSTNode(int key, Object value, BSTNode left, BSTNode right) {
        this.key = key;
        this.value = value;
        this.left = left;
        this.right = right;
    }
}

查询

参照图：

二叉搜索树的基础操作_第1张图片

递归实现

//解题思路：从根节点出发 比根节点大的向右找 比根节点小的向左找  如果相等则返回
public Object get(int key) {
    return doGet(root, key);
}
//查询方法：递归实现
private Object doGet(BSTNode node, int key) {
    if (node == null) {
        return null; // 没找到
    }
    if (key < node.key) {
        return doGet(node.left, key); // 向左找
    } else if (node.key < key) {
        return doGet(node.right, key); // 向右找
    } else {
        return node.value; // 找到了
    }
}

非递归实现

public Object get(int key) {
    BSTNode node = root;
    while (node != null) {
        if (key < node.key) {
            node = node.left;
        } else if (node.key < key) {
            node = node.right;
        } else {
            return node.value;
        }
    }
    return null;
}

Comparable

随便给个泛型T就能参与大小比较吗？不能,所以我们要对T进行限制，让它能够参与大小比较，那么就需要实现一个接口： Comparable 接口

如果希望让除 int 外更多的类型能够作为 key，一种方式是 key 必须实现 Comparable 接口。

代码实现：

//>:将来我的泛型T就有个上限了，必须是Comparable的子类型，那么T就再也不是任意类型
public class BSTTree2> {
    static class BSTNode {
        T key; // 若希望任意类型作为 key, 则后续可以将其设计为 Comparable 接口
        Object value;
        BSTNode left;
        BSTNode right;

        public BSTNode(T key) {
            this.key = key;
            this.value = key;
        }

        public BSTNode(T key, Object value) {
            this.key = key;
            this.value = value;
        }

        public BSTNode(T key, Object value, BSTNode left, BSTNode right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }

    //定义根节点
    BSTNode root;

    public Object get(T key) {
        return doGet(root, key);
    }

    //注意：key.compareTo(p.key)的方法比较
    //-1： key p.key
    //0： key =p.key
    //1： key p.key
    //递归的实现
    private Object doGet(BSTNode node, T key) {
        if (node == null) {
            return null;
        }
        int result = node.key.compareTo(key);
        if (result > 0) {
            return doGet(node.left, key);
        } else if (result < 0) {
            return doGet(node.right, key);
        } else {
            return node.value;
        }
    }
    //非递归的实现
    //注意：key.compareTo(p.key)的方法比较
    //-1： key p.key
    //0： key =p.key
    //1： key p.key
    //非递归的实现
    public Object get(T key){
        BSTNode p=root;
        while (p!=null){
            int result = key.compareTo(p.key);
            if(result<0){
                p=p.left;
            }else if(result>0){
                p=p.right;
            }else {
                return p.value;
            }
        }
        return null;
    }

}

还有一种做法不要求 key 实现 Comparable 接口，而是在构造 Tree 时把比较规则作为 Comparator 传入，将来比较 key 大小时都调用此 Comparator 进行比较，这种做法可以参考 Java 中的 java.util.TreeMap

当然我们也可以实现像Map一样的格式，给value也加个泛型，然后我们将key的泛型修改一下名字，就更像Map:

public class BSTTree2, V> {
static class BSTNode {
    K key;
    V value;
    BSTNode left;
    BSTNode right;

    public BSTNode(K key) {
        this.key = key;
    }

    public BSTNode(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public BSTNode(K key, V value, BSTNode left, BSTNode right) {
        this.key = key;
        this.value = value;
        this.left = left;
        this.right = right;
    }
}

BSTNode root;

public V get(K key) {
    BSTNode p = root;
    while (p != null) {
        /*
            -1 key < p.key
            0 key == p.key
            1 key > p.key
         */
        int result = key.compareTo(p.key);
        if (result < 0) {
            p = p.left;
        } else if (result > 0) {
            p = p.right;
        } else {
            return p.value;
        }
    }
    return null;
	}
}

但是后面，我们为了更加使得我们小白能够更好理解代码，我们还是以int key,object value来实现后续的代码。

查询最小值

参照图：

二叉搜索树的基础操作_第2张图片

递归实现

思路：从根节点开始，一直往左走，一直走到最后的节点没有左孩子就停止

//思路：从根节点开始，一直往左走，一直走到最后的节点没有左孩子就停止
public Object min() {
    return doMin(root);
}

public Object doMin(BSTNode node) {
    if (node == null) {//当给的节点为Null 我们就不需要去找
        return null;
    }
    // 左边已走到头
    if (node.left == null) { //最小的节点
        return node.value;
    }
    return doMin(node.left);
}

非递归实现

public Object min() {
    if (root == null) {
        return null;
    }
    BSTNode p = root;
    // 左边未走到头
    while (p.left != null) {
        p = p.left;
    }
    return p.value;
}

查询最大值

参考：其实现方法与《最小》的操作基本上是一样的

二叉搜索树的基础操作_第3张图片

递归实现

public Object max() {
    return doMax(root);
}

public Object doMax(BSTNode node) {
    if (node == null) {
        return null;
    }
    // 右边已走到头
    if (node.left == null) { 
        return node.value;
    }
    return doMin(node.right);
}

非递归实现

public Object max() {
    if (root == null) {
        return null;
    }
    BSTNode p = root;
    // 右边未走到头
    while (p.right != null) {
        p = p.right;
    }
    return p.value;
}

新增操作

参考图：

二叉搜索树的基础操作_第4张图片

解题思路：

//1.key在该二叉树中有 那就更新key所对应的value值
//2.key在该二叉树中没有 那就新增key与所对应的value值

新增前：

二叉搜索树的基础操作_第5张图片

新增后：

二叉搜索树的基础操作_第6张图片

图示解析：以上述图为例，新增前，从根节点开始找，找到8时，9大于8，那么就要要继续向右找，但是此时前进不了了，因为8已经是叶子节点，走到头还没有找到9，那么就新增9连通值一起创建出来，做为8的右孩子新增进去。

递归实现

public void put(int key, Object value) {
    root = doPut(root, key, value);
}

private BSTNode doPut(BSTNode node, int key, Object value) {
    if (node == null) {
        return new BSTNode(key, value);
    }
    if (key < node.key) {
        node.left = doPut(node.left, key, value);
    } else if (node.key < key) {
        node.right = doPut(node.right, key, value);
    } else {
        node.value = value;
    }
    return node;
}

  • 若找到 key，走 else 更新找到节点的值

  • 若没找到 key，走第一个 if，创建并返回新节点

    • 返回的新节点，作为上次递归时 node 的左孩子或右孩子

    • 缺点是，会有很多不必要的赋值操作

非递归实现

public void put(int key, Object value) {
    BSTNode node = root;
    BSTNode parent = null;
    while (node != null) {
        parent = node;// 4 7 8
        if (key < node.key) {
            node = node.left;
        } else if (node.key < key) {
            node = node.right;//4->7 7->8 8->null
        } else {
            // 1. key 存在则更新
            node.value = value;
            return;
        }
    }
    // 2. key 不存在则新增
    if (parent == null) {
        //当我二叉树是null，那么parent初始就是Null 那么新增的key就是根节点
        root = new BSTNode(key, value);
    } else if (key < parent.key) {
        parent.left = new BSTNode(key, value);
    } else {
        parent.right = new BSTNode(key, value);
    }
}

查询节点的前驱后继

二叉搜索树的基础操作_第7张图片

什么叫屈曲与后继？

答：

一个节点的前驱（前任）节点是指比它小的节点中，最大的那个

一个节点的后继（后任）节点是指比它大的节点中，最小的那个

1 2 3 4 5 6 7 8

例如上图中

  • 1 没有前驱，后继是 2

  • 2 前驱是 1，后继是 3

  • 3 前驱是 2，后继是 4

  • ...

查询节点前驱

简单的办法是中序遍历，即可获得排序结果，此时很容易找到前驱后继

二叉树的中序遍历就是升序的结果

要效率更高，需要研究一下规律，找前驱分成 2 种情况：

二叉搜索树的基础操作_第8张图片

  1. 节点有左子树，此时前驱节点就是左子树中的最大值， 图中属于这种情况的有

    • 2 的前驱是1

    • 4 的前驱是 3

    • 6 的前驱是 5

    • 7 的前驱是 6

    个人理解：比如:(4的前驱节点有 1 2 3，其中最大值就是3)

  2. 节点没有左子树，若离它最近的祖先自从左而来，此祖先即为前驱，如

    • 3 的祖先 2 自左而来，前驱 2

    • 5 的祖先 4 自左而来，前驱 4

    • 8 的祖先 7 自左而来，前驱 7

    • 1 没有这样的祖先，前驱 null

个人理解：比如:(5的祖先节点有 6 7 4，其中以5为参考点，右边6和7都是比5大的，左边4是比5小的，从左而来的祖先4即为前驱)

比如:(3的祖先节点有 2 4，其中以3为参考点，右边4是比3大的，左边2是比3小的，从左而来的祖先2即为前驱)

// 情况2 - 有祖先自左而来
//对于情况2，我们如何知道哪些节点是要找节点的祖先，又是如何知道这些祖先节点哪些是自从左而来的呢？
//以5节点为例，那我要找到5这个节点的过程中，它必然已经经历过一些节点了，从根节点4开始找，5比4大就向右找，7比5大就向左找，6比5大就像左找，找到了


//在从根节点开始4 7 6是不是都是5的祖先？是的  其实循环的每步都是在经历他这些祖先节点，好，现在知道怎么去获取祖先节点。


//那我们怎么去进一步判断 它这个祖先是左边来还是从右边来呢？
//答：你看4到7是不是向右走，那么以5为参考点，那么4是不是在左边？那么7到6、6到5都是向左走，但是以5为参考点，那么7到6、6到5都是向右走
//所以只要我们看到这种向右走的代码if (p.key < key) {p = p.right;}那就表示祖先是自左而来
//而且我们每次循环更新都是最新也就是最近的自左而来的祖先节点

在predecessor方法之前，我们对于Max方法进行简单的修改，因为我们上面写的Max方法仅仅只是针对于root根节点来查询最大：

   //非递归实现  针对于root的max方法
    public Object max() {
     return   max(root);
//        if (root == null) {
//            return null;
//        }
//        BSTNode p = root;
//        // 右边未走到头
//        while (p.right != null) {
//            p = p.right;
//        }
//        return p.value;
    }
    

    //通用的Max方法
    private Object max(BSTNode node){
        if (node == null) {
            return null;
        }
        BSTNode p = node;
        // 右边未走到头
        while (p.right != null) {
            p = p.right;
        }
        return p.value;
    }

然后我们就开始书写查询节点的前驱代码：

public Object predecessor(int key) {
    BSTNode ancestorFromLeft = null;
    BSTNode p = root;
    //查找用户给的Key在二叉树中是否有
    while (p != null) {
        if (key < p.key) {
            p = p.left;
        } else if (p.key < key) {
            ancestorFromLeft = p;
            p = p.right;
        } else {
            break;
        }
    }
    //key没找到，说明也就没有前任节点
    if (p == null) {
        return null;
    }
    // 情况1 - 有左孩子
    if (p.left != null) {
        return max(p.left);
    }
    // 情况2 - 有祖先自左而来
    //对于情况2，我们如何知道哪些节点是要找节点的祖先，又是如何知道这些祖先节点哪些是自从左而来的呢？
    //以5节点为例，那我要找到5这个节点的过程中，它必然已经经历过一些节点了，从根节点4开始找，5比4大就向右找，7比5大就向左找，6比5大就像左找，找到了
    //在从根节点开始4 7 6是不是都是5的祖先？是的  其实循环的每步都是在经历他这些祖先节点，好，现在知道怎么去获取祖先节点。
    //那我们怎么去进一步判断 它这个祖先是左边来还是从右边来呢？
    //答：你看4到7是不是向右走，那么以5为参考点，那么4是不是在左边？那么7到6、6到5都是向左走，但是以5为参考点，那么7到6、6到5都是向右走
    //所以只要我们看到这种向右走的代码if (p.key < key) {p = p.right;}那就表示祖先是自左而来
    //而且我们每次循环更新都是最新也就是最近的自左而来的祖先节点
           
    return ancestorFromLeft != null ? ancestorFromLeft.value : null;
}

查询节点后继

找后继也分成 2 种情况 与找前任的代码相类似

二叉搜索树的基础操作_第9张图片

  1. 节点有右子树，此时后继节点即为右子树的最小值，如

    • 2 的后继 3

    • 3 的后继 4

    • 5 的后继 6

    • 7 的后继 8

  2. 节点没有右子树，若离它最近的祖先自从右而来，此祖先即为后继，如

    • 1 的祖先 2 自右而来，后继 2

    • 4 的祖先 5 自右而来，后继 5

    • 6 的祖先 7 自右而来，后继 7

    • 8 没有这样的祖先，后继 null

在successor方法之前，我们对于Min方法进行简单的修改，因为我们上面写的Min方法仅仅只是针对于root根节点来查询最小：

    //非递归实现
    public Object min() {
        return min(root);
//        if (root == null) {
//            return null;
//        }
//        BSTNode p = root;
//        // 左边未走到头
//        while (p.left != null) {
//            p = p.left;
//        }
//        return p.value;
    }
    
    private Object min(BSTNode node){
        if (node == null) {
            return null;
        }
        BSTNode p = node;
        // 左边未走到头
        while (p.left != null) {
            p = p.left;
        }
        return p.value;
    }

然后我们就开始书写查询节点的后继代码：

public Object successor(int key) {
    BSTNode ancestorFromRight = null;
    BSTNode p = root;
    while (p != null) {
        if (key < p.key) {
            ancestorFromRight = p;
            p = p.left;
        } else if (p.key < key) {
            p = p.right;
        } else {
            break;
        }
    }

    if (p == null) {
        return null;
    }
    // 情况1 - 有右孩子
    if (p.right != null) {
        return min(p.right);
    }
    // 情况2 - 有祖先自右而来
    return ancestorFromRight != null ? ancestorFromRight.value : null;
}

删除操作

要删除某节点（称为 D），必须先找到被删除节点的父节点，这里称为 Parent

1.删除节点没有左孩子，将右孩子托孤给 Parent

二叉搜索树的基础操作_第10张图片

2.删除节点没有右孩子，将左孩子托孤给 Parent

二叉搜索树的基础操作_第11张图片

3.删除节点左右孩子都没有，已经被涵盖在情况1、情况2当中，把null托孤给Parent

4.删除节点左右孩子都有，可以将它的后继节点（称为S)托孤给Parent,设S的父亲为SP,又分两种情况:

               1.SP 就是被删除节点，此时 D 与 S 紧邻，只需将 S 托孤给 Parent

二叉搜索树的基础操作_第12张图片

               2.SP 不是被删除节点，此时 D 与 S 不相邻，此时需要将 S 的后代托孤给 SP，再将 S 托孤给 Parent

二叉搜索树的基础操作_第13张图片

非递归实现

/**
 * 
根据关键字删除

 *
 * @param key 关键字
 * @return 被删除关键字对应值
 */
public Object delete(int key) {
    BSTNode p = root;
    BSTNode parent = null;//记录待删除节点的父亲
    while (p != null) {
        if (key < p.key) {
            parent = p;
            p = p.left;
        } else if (p.key < key) {
            parent = p;
            p = p.right;
        } else {
            break;
        }
    }
    if (p == null) {
        return null;
    }
    // 删除操作
    if (p.left == null) {
        shift(parent, p, p.right); // 情况1
    } else if (p.right == null) {
        shift(parent, p, p.left); // 情况2
    } else {
        // 情况4：被删除节点是左、右都有子节点，所以找后继节点：节点有右子树，此时后继节点即为右于树的最小值
        // 4.1 被删除节点找后继
        BSTNode s = p.right;//后继节点
        BSTNode sParent = p; // 后继父亲
        while (s.left != null) {  //当循环结束，后继节点即为s
            sParent = s;
            s = s.left;
        }
        // 4.2 删除和后继不相邻, 处理后继的后事
        if (sParent != p) {                
            shift(sParent, s, s.right); // 不可能有左孩子：因为节点有右子树，此时后继节点即为右于树的最小值
            s.right = p.right;//顶上去的后继节点的右孩子==被删除节点的右孩子
        }
        // 4.3 后继取代被删除节点
        shift(parent, p, s);
        s.left = p.left;//shift方法只改变了父类节点的左右孩子的指向，而没有改变你后继节点的做左右孩子的指向
    }
    return p.value;
}

/**
 * 托孤方法
 *
 * @param parent  被删除节点的父亲
 * @param deleted 被删除节点
 * @param child   被顶上去的节点
 */
// 只考虑让 n1父亲的左或右孩子指向 n2, n1自己的左或右孩子并未在方法内改变
private void shift(BSTNode parent, BSTNode deleted, BSTNode child) {
    //情况讨论：当被删除节点就是根节点，而根节点是没有父亲的
    if (parent == null) {
        root = child;//你们被删除节点的子节点就成根节点
    } else if (deleted == parent.left) {
        parent.left = child;
    } else {
        parent.right = child;
    }
}

递归实现

  /**
     * 
根据关键字删除

     *
     * @param key 关键字
     * @return 被删除关键字对应值  是删除单个节点，当该节点被删除，则它的子节点将会与该节点的父类节点进行连接
     */

    public Object remove(int key) {
        ArrayList result = new ArrayList<>(); // 保存被删除节点的值
        root = doRemove(root, key, result);
        return result.isEmpty() ? null : result.get(0);
    }


        /*
              4
             / \
            2   6
           /     \
          1       7

        node 起点
        返回值 删剩下的孩子(找到) 或 null(没找到)
     */
    //递归实现删除操作  BSTNode node:我要删除时，从哪个节点开始删除  node是起点
    private BSTNode doRemove(BSTNode node, int key, ArrayList result) {
        //1.没有找到的情况：
        if (node == null) {
            return null;
        }
        //2.找到的情况：
        if (key < node.key) {//向左查找
            node.left = doRemove(node.left, key, result);
            return node;
        }
        if (node.key < key) {//向右查找
            node.right = doRemove(node.right, key, result);
            return node;
        }
        result.add(node.value);
        if (node.left == null) { // 情况1 - 只有右孩子
            return node.right;
        }
        if (node.right == null) { // 情况2 - 只有左孩子
            return node.left;
        }
        //s：后继节点
        BSTNode s = node.right; // 情况3 - 有两个孩子
        while (s.left != null) {
            s = s.left;
        }
        //while循环结束以后，找到了后继节点
        s.right = doRemove(node.right, s.key, new ArrayList<>());
        s.left = node.left;
        return s;
    }

对于第四种情况进行代码解析：


当D与S紧邻：


二叉搜索树的基础操作_第14张图片


当D与S不是紧邻：


二叉搜索树的基础操作_第15张图片


对于remove方法的解析：


二叉搜索树的基础操作_第16张图片


说明




    

  1.  
    ArrayList result 用来保存被删除节点的值
     

  2.  
    第二、第三个 if 对应没找到的情况，继续递归查找和删除，注意后续的 doDelete 返回值代表删剩下的，因此需要更新
     
    3. 

  3.  
    最后一个 return 对应删除节点只有一个孩子的情况，返回那个不为空的孩子，待删节点自己因没有返回而被删除
     
    4. 

  4.  
    第四个 if 对应删除节点有两个孩子的情况，此时需要找到后继节点，并在待删除节点的右子树中删掉后继节点，最后用后继节点替代掉待删除节点返回，别忘了改变后继节点的左右指针
     
    5. 



    范围查询
    

    下面三种题型的核心解题思路：
    

    我们利用中序遍历的特性：遍历出来的都是升序的结果来进行范围查询
    

    

    找小的
    

        /*
                 4
               /   \
              2     6
             / \   / \
            1   3 5   7
     */
//找 > key 的所有 value
//解题思路：我们利用中序遍历的特性：遍历出来的都是升序的结果
public List less(int key) { //当我们输入的是6
    //result：将符合条件的加入到result中
    ArrayList result = new ArrayList<>();
    //中序遍历过程：
    BSTNode p = root;
    LinkedList stack = new LinkedList<>();
    while (p != null || !stack.isEmpty()) {
        if (p != null) {
            stack.push(p);
            p = p.left;
        } else {
            BSTNode pop = stack.pop();
            if (pop.key < key) {
                result.add(pop.value);
            } else {
                //当我们遇到比key大的分支时，该分支的子分支就没必要多此一举的进行判断，直接跳出
                //比如：当key=6，那么我们6右节点就不需要多此一举的去判断，而是直接跳出
                break;
            }
            p = pop.right;
        }
    }
    return result;
}

    找大的
    

    方法与《找小的》操作类似
    

    第一种方法：
    

        /*
                 4
               /   \
              2     6
             / \   / \
            1   3 5   7
     */
//解题思路：我们利用中序遍历的特性：遍历出来的都是升序的结果
public List greater(int key) {
    ArrayList result = new ArrayList<>();
    BSTNode p = root;
    LinkedList stack = new LinkedList<>();
    while (p != null || !stack.isEmpty()) {
        if (p != null) {
            stack.push(p);
            p = p.left;
        } else {
            BSTNode pop = stack.pop();
            if (pop.key > key) {//在这里，我们遍历>key的就不需要break,让它执行到子节点为Null
                result.add(pop.value);
            }
            p = pop.right;
        }
    }
    return result;
}

    但这样效率不高，可以用 RNL 遍历
    

    什么是RNL 遍历？
    

    答：
    

    

    注：
    

    前三中就是我们之前所讲的前、中、后序遍历 N：值 L：左 R：右
    

      

    •  
      Pre-order, NLR
       
      • 

    •  
      In-order, LNR
       
      • 

    •  
      Post-order, LRN
       
      • 

    

    以下三种遍历与上三种遍历的区别：上三种是先左后右，下三种是先右后左
    

      

    •  
      Reverse pre-order（反向前序遍历）, NRL
       
      • 

    •  
      Reverse in-order（中向前序遍历）, RNL
       
      • 

    •  
      Reverse post-order（反向后序遍历）, RLN
       
      • 

    

    

    第二种方法：
    

    public List greater(int key) {
    ArrayList result = new ArrayList<>();
    BSTNode p = root;
    //RNL 遍历:得到的是降序的结果
    LinkedList stack = new LinkedList<>();
    while (p != null || !stack.isEmpty()) {
        if (p != null) {
            stack.push(p);
            p = p.right;
        } else {
            BSTNode pop = stack.pop();
            if (pop.key > key) {
                result.add(pop.value);
            } else {
                break;
            }
            p = pop.left;
        }
    }
    return result;
}

    

    找之间
    

    方法与《找小的》操作类似
    

    public List between(int key1, int key2) {
    ArrayList result = new ArrayList<>();
    BSTNode p = root;
    LinkedList stack = new LinkedList<>();
    while (p != null || !stack.isEmpty()) {
        if (p != null) {
            stack.push(p);
            p = p.left;
        } else {
            BSTNode pop = stack.pop();
            if (pop.key >= key1 && pop.key <= key2) {
                result.add(pop.value);
            } else if (pop.key > key2) {
                break;
            }
            p = pop.right;
        }
    }
    return result;
}

    

    小结
    

    优点：
    

    

      

    1.  
      如果每个节点的左子树和右子树的大小差距不超过一，可以保证搜索操作的时间复杂度是 O(log n)，效率高。
       
      2. 

    2.  
      插入、删除结点等操作也比较容易实现，效率也比较高。
       
      3. 

    3.  
      对于有序数据的查询和处理，二叉查找树非常适用，可以使用中序遍历得到有序序列。
       
      4. 

    

    

    缺点：
    

    

      

    1.  
      如果输入的数据是有序或者近似有序的，就会出现极度不平衡的情况，可能导致搜索效率下降，时间复杂度退化成O(n)。
       
      2. 

    2.  
      对于频繁地插入、删除操作，需要维护平衡二叉查找树，例如红黑树、AVL 树等，否则搜索效率也会下降。
       
      3. 

    3.  
      对于存在大量重复数据的情况，需要做相应的处理，否则会导致树的深度增加，搜索效率下降。
       
      4. 

    4.  
      对于结点过多的情况，由于树的空间开销较大，可能导致内存消耗过大，不适合对内存要求高的场景。
       
      5. 

    

    

    







    



    


    


    




    

    你可能感兴趣的:(数据结构,算法,leetcode,数据结构)
    

    

    

      

    • 频控限流设计---云信方案
M_灵均
java开发语言

      方案背景频控限流是一种非常重要的技术手段，它主要用于控制对服务器或服务的访问频率，以防止服务器因请求过多而崩溃，同时也能够保护系统不会因为过载而影响服务质量。频控限流通常用于API接口调用、网站访问、服务端请求处理等多种场景。频控&限流方案频控限流的常见实现方式包括固定窗口算法、滑动窗口算法、漏桶算法和令牌桶算法。固定窗口算法通过在固定时间窗口内计数请求次数来实现限流，但可能会在窗口切换时出现流量
      

      • 

    • 【力扣】[热题HOT100] 279.完全平方数
失落的换海迷风
#热题HOT100动态规划完全平方数LeetCode最优解最小数量

      1、题目给定正整数n，找到若干个完全平方数（比如1,4,9,16,…）使得它们的和等于n。你需要让组成和的完全平方数的个数最少。给你一个整数n，返回和为n的完全平方数的最少数量。完全平方数是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9和16都是完全平方数，而3和11不是。链接：https://leetcode-cn.com/problems/perfec
      

      • 

    • 【NO.72】LeetCode HOT 100—279. 完全平方数
悬浮海
#LeetCodeHOT100leetcode算法279.完全平方数

      文章目录279.完全平方数解题方法：动态规划279.完全平方数给你一个整数n，返回和为n的完全平方数的最少数量。完全平方数是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9和16都是完全平方数，而3和11不是。示例1：输入：n=12输出：3解释：12=4+4+4示例2：输入：n=13输出：2解释：13=4+9提示：1<=n<=104解题方法：动态规划动态规划
      

      • 

    • Open3D 实现CSF布料模拟算法
今夕是何年，
单目+双目Open3d计算机视觉

      目录一、算法原理二，详细过程三，环境安装四，代码实现五，结果展示6，在cloudcompare中的实现一、算法原理1、流程概述1）利用点云·滤波算法或者点云处理软件滤除异常点;2）将激光雷达点云倒置;3）设置模拟布料，设置布料网格分辨率GR，确定模拟粒子数。布料的位置设置在点云最高点以上;4）将布料模拟点和雷达点投影到水平面，为每个布料模拟点找到最相邻的激光点的高度值，将高度值设置为IHV;5)布
      

      • 

    • Open3D 使用RANSAC分割平面
今夕是何年，
单目+双目计算机视觉

      目录1，概述2，拟合平面3，实现过程4，主要函数：defsegment_plane(self,distance_threshold,ransac_n,num_iterations):'''5，代码实现6，结果展示1，概述随机抽样一致性算法QRANSAC(Randomsampleconsensus)是一种迭代的方法来从一系列包含有离异值的数据中计算数学模型参数的方法。RANSAC算法本质上由两步组成
      

      • 

    • C语言暑假学习刷题——Day4
奋斗小温
C语言c语言学习java

      目录选择题考点一：for循环的理解考点二：while循环和循环嵌套的理解考点三：break在switch语句中的应用考点四：升序插入排序算法的应用考点五：循环嵌套的理解编程题【leetcode题号：645.错误的集合】【难度：简单】【牛客网题号：OR141密码检查】【难度：简单】选择题考点一：for循环的理解1、设变量已正确定义，以下不能统计出一行中输入字符个数（不包含回车符）的程序段是（）A：n
      

      • 

    • C# Tuple、ValueTuple
語衣
C#知识补充c#

      栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
      

      • 

    • CSP-J(/S) 2020爆炸记【游记】
JA_yichao
比赛and游记and总结游记cspCSP-J

      文章目录前言Day-xx训练Day-26初赛Day-18初赛成绩Day-5Day-1Day0Day1总结前言这次CSP−J(/S)CSP-J(/S)CSP−J(/S)的考试我的发挥非常差，该拿的分都没拿到.写一下自己的训练历程和心得感悟吧！Day-xx训练最近学了一大堆算法，在博客里我都有记录，有点应接不暇，但确实是长见识了，发现自己到现在都还没学入门（菜）Day-26初赛考前和gyx，cxy一直
      

      • 

    • Rust中的所有权和借用规则详解
代码云1
rust开发语言后端

      Rust是一种系统编程语言，其设计目标包括内存安全、并发安全以及性能。为了实现这些目标，Rust引入了一系列独特的编程概念，其中最为核心的就是所有权（Ownership）和借用（Borrowing）规则。本文将详细解释Rust中的所有权和借用规则，以及它们如何确保内存安全和并发安全。一、所有权规则在Rust中，每一个值都有一个与之关联的所有者。这个所有者可以是变量、数据结构或者是其他形式的存储。所
      

      • 

    • 一文读懂ZGC
w_rcss
垃圾回收JVMZGC垃圾回收器gcjvmG1

      ZGC（TheZGarbageCollector）前言ZGC是G1后新推出的垃圾回收器，jdk11仅支持linux，jdk14增加了对windows，macOS的支持。本文将通过对比G1来简单介绍ZGC。什么是ZGC？ZGC（TheZGarbageCollector）是标记-整理算法的并发垃圾回收器，官方解释ZGC只是个名字，没有意义。//开启ZGC-XX:+UnlockExperimentalV
      

      • 

    • 数据压缩（1）——简介
永恒星
计算机基础数据压缩信息熵

      【前言】数据压缩存在于计算机、网络的各个地方，是很底层的技术支持，例如歌曲、图像、视频、网页、文本等的保存和传输都是用过数据压缩算法的。总的来说，我们常使用数据压缩来增多硬盘存储的内容、减少网络传输的流量。数据压缩研究的是，在可接受的信息恢复程度下，可以将信息变得有多紧凑。通常有两个思路：减少数据中不同符号的数据量；用更少的位数对更常见的符号进行编码。数据压缩的算法多种多样，没有万能的算法，通用算
      

      • 

    • C++ | Leetcode C++题解之第398题随机数索引
Ddddddd_158
经验分享C++Leetcode题解

      题目：题解：classSolution{vector&nums;public:Solution(vector&nums):nums(nums){}intpick(inttarget){intans;for(inti=0,cnt=0;i

      • 

    • 代码随想录算法训练营第45天 | LeetCode115.不同的子序列、 LeetCode583.两个字符串的删除操作、LeetCode72.编辑距离
霸L
算法数据结构动态规划

      目录LeetCode115.不同的子序列LeetCode583.两个字符串的删除操作LeetCode72.编辑距离LeetCode115.不同的子序列给你两个字符串s和t，统计并返回在s的子序列中t出现的个数，结果需要对10^9+7取模。思路：昨天做了一道判断子序列的问题，今天这个跟它有点区别，这里是问子序列的个数有多少个。但是大体上其实就是分为两个部分，遇到元素相等时如何处理，不相等时又如何处理
      

      • 

    • 代码随想录算法训练营第9天 | LeetCode28.找出字符串中第一个匹配项的下标、LeetCode459.重复的子字符串
霸L
算法数据结构

      LeetCode28.找出字符串中第一个匹配项的下标给你两个字符串haystack和needle，请你在haystack字符串中找出needle字符串的第一个匹配项的下标（下标从0开始）。如果needle不是haystack的一部分，则返回-1。给你两个字符串haystack和needle，请你在haystack字符串中找出needle字符串的第一个匹配项的下标（下标从0开始）。如果needle不
      

      • 

    • 【Kubernetes】常见面试题汇总（十三）
summer.335
Kuberneteskubernetes容器云原生

      目录39.简述KubernetesScheduler使用哪两种算法将Pod绑定到worker节点？40.简述Kuberneteskubelet的作用？41.简述Kuberneteskubelet监控Worker节点资源是使用什么组件来实现的？39.简述KubernetesScheduler使用哪两种算法将Pod绑定到worker节点？KubernetesScheduler根据如下两种调度算法将Po
      

      • 

    • Java中的垃圾回收机制是如何工作的？
Good_tea_h
javajvm算法

      Java中的垃圾回收机制（GarbageCollection,GC）是Java虚拟机（JVM）的一个重要组成部分，它负责自动管理内存的分配和释放，以减轻程序员在内存管理方面的负担，并防止内存泄漏和内存溢出等问题。一、垃圾回收机制的核心思想Java的垃圾回收机制主要基于两个核心思想：标记和回收。标记：垃圾收集器会定期自动扫描内存中的对象，根据特定的算法（如可达性分析法）来判断哪些对象已经不再被程序使
      

      • 

    • 代码随想录算法训练营第46天 | LeetCode647.回文子串、 LeetCode516.最长回文子序列
霸L
算法数据结构动态规划

      目录LeetCode647.回文子串1.动态规划2.双指针法LeetCode516.最长回文子序列LeetCode647.回文子串给你一个字符串s，请你统计并返回这个字符串中回文子串的数目。回文字符串是正着读和倒过来读一样的字符串。子字符串是字符串中的由连续字符组成的一个序列。思路：在回溯系列也做过求给定字符串的所有回文子串，那里求的是所有的划分结果，这里统计的是回文子串的数目，但是因为回溯本质上
      

      • 

    • LeetCode移除元素
山雀~
LeetCode合集leetcode算法职场和发展

      题目描述给你一个数组nums和一个值val，你需要原地移除所有数值等于val的元素。元素的顺序可能发生改变。然后返回nums中与val不同的元素的数量。假设nums中不等于val的元素数量为k，要通过此题，您需要执行以下操作：更改nums数组，使nums的前k个元素包含不等于val的元素。nums的其余元素和nums的大小并不重要。返回k。解题思路通过遍历数组，将不等于val的元素复制到数组的前面
      

      • 

    • Python实现梯度下降法
闲人编程
pythonpython开发语言梯度下降算法优化

      博客：Python实现梯度下降法目录引言什么是梯度下降法？梯度下降法的应用场景梯度下降法的基本思想梯度下降法的原理梯度的定义学习率的选择损失函数与优化问题梯度下降法的收敛条件Python实现梯度下降法面向对象的设计思路代码实现示例与解释梯度下降法应用实例：线性回归场景描述算法实现结果分析与可视化梯度下降法的改进版本随机梯度下降（SGD）小批量梯度下降（Mini-batchGradientDesce
      

      • 

    • 深入链表的遍历——快慢指针算法（LeetCode——876题）
欺霜
链表算法java

      今天我们一起来学习一下一个快速遍历链表的方法我们先来看看一道经典的需要遍历链表的题目（题目来自LeetCode）876.链表的中间结点https://leetcode.cn/problems/middle-of-the-linked-list/给你单链表的头结点head，请你找出并返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。普通方法publicListNodemiddleNode
      

      • 

    • 每天五分钟玩转深度学习PyTorch：模型参数优化器torch.optim
幻风_huanfeng
深度学习框架pytorch深度学习pytorch人工智能神经网络机器学习优化算法

      本文重点在机器学习或者深度学习中，我们需要通过修改参数使得损失函数最小化(或最大化)，优化算法就是一种调整模型参数更新的策略。在pytorch中定义了优化器optim，我们可以使用它调用封装好的优化算法，然后传递给它神经网络模型参数，就可以对模型进行优化。本文是学习第6步(优化器)，参考链接pytorch的学习路线随机梯度下降算法在深度学习和机器学习中，梯度下降算法是最常用的参数更新方法，它的公式
      

      • 

    • 二叉树--python
电子海鸥
Python数据结构与算法python开发语言数据结构

      二叉树一、概述1、介绍是一种非线性数据结构，将数据一分为二，代表根与叶的派生关系，和链表的结构类似，二叉树的基本单元是结点，每个节点包括值和左右子节点引用。每个节点都有两个引用（类似于双向链表），分别指向左子节点和右子节点，该节点被称为这两个子节点的父节点。当给定一个二叉树的结点时，我们将在该节点的左子节点以及其以下结点所形成的树称为左子树，同理，右子节点的部分被称为右子树。在二叉树中，除了叶节点
      

      • 

    • 使用WAF防御网络上的隐蔽威胁之反序列化攻击
baiolkdnhjaio
网络安全

      什么是反序列化反序列化是将数据结构或对象状态从某种格式转换回对象的过程。这种格式通常是二进制流或者字符串（如JSON、XML），它是对象序列化（即对象转换为可存储或可传输格式）的逆过程。反序列化的安全风险反序列化的安全风险主要来自于处理不受信任的数据源时的不当反序列化。如果应用程序反序列化了恶意构造的数据，攻击者可能能够执行代码、访问敏感数据、进行拒绝服务攻击等。这是因为反序列化过程中可能会自动触
      

      • 

    • 力扣100题——技巧
MogulNemenis
题解leetcode算法

      只出现一次的数字题目136.只出现一次的数字-力扣（LeetCode）思路这题很有意思，考察的知识点也比较偏，涉及到位运算。由于每个元素除了一个只出现一次外，其他元素都出现了两次，所以我们可以利用位运算中的异或操作来解决这个问题。位运算（异或操作）：异或操作（^）的性质：x^x=0（任何数与自身异或为0）x^0=x（任何数与0异或还是这个数）异或运算满足交换律和结合律基于上述性质，如果我们将数组中
      

      • 

    • 一刷Day7|454.四数相加II 15. 三数之和 18. 四数之和
Alisa-AY
哈希算法c语言

      文章目录454.四数相加II识别核心/易错难点/亮点算法设计思路代码实现代码实现分析15.三数之和（排序数组后左右双指针法，abc均去重）##识别核心/易错难点/亮点算法设计思路代码实现代码注释18.四数之和（在三数之和的基础上套了一层for循环numsk，剪枝&去重）识别核心/易错难点/亮点算法设计思路代码实现代码注释383.赎金信454.四数相加II识别本题有4个数组，较四数之和（一个数组），
      

      • 

    • Python世界：简易地址簿增删查改算法实践
来知晓
Python世界python机器学习开发语言

      Python世界：简易地址簿增删查改算法实践任务背景编码思路代码实现本文小结任务背景该任务来自简明Python教程中迈出下一步一章的问题：编写一款你自己的命令行地址簿程序，你可以用它浏览、添加、编辑、删除或搜索你的联系人，例如你的朋友、家人、同事，还有他们诸如邮件地址、电话号码等多种信息。这些详细信息必须被妥善储存以备稍后的检索。编码思路从问题中可以提炼以下信息：1、地址簿需要支持本地存储读写；2
      

      • 

    • 查找算法--python
电子海鸥
Python数据结构与算法算法python数据结构

      二分查找一、概述基于有序数组的一种查找算法，主要使用了分治的思想，在每次查找的过程后，都能缩小一半的搜索范围，比如在1到100内猜数字，在保险的情况下先说50，根据结果再分析范围是1到49、51到100还是就是50，可以大大的减少查询次数。二、查找元素位置步骤设置边界，一般left取0作为左边界，right取lenth-1作为右边界计算mid=(left+right)//2，查看中间值，并和tar
      

      • 

    • 【203→算法】人生算法课B段（上）
Koala谦爸

      1片面图片来源《得到APP》2狭隘图片来源《得到APP》3模糊图片来源《得到APP》4侥幸图片来源《得到APP》5宿命图片来源《得到APP》6追悔图片来源《得到APP》7非理性图片来源《得到APP》8冲动图片来源《得到APP》9犹豫图片来源《得到APP》10武断图片来源《得到APP》11情面图片来源《得到APP》12霉运图片来源《得到APP》
      

      • 

    • java 线程池 队列封装_java线程池（线程池组---分离任务队列和线程池）
爱打怪的小魔女
java线程池队列封装

      线程池本质上所使用的逻辑模型仍然是我们熟悉的“生产者/消费者”模型。生产消费外部线程(生产者)－－－>任务消费者和生产者共享一个数据结构(缓存任务)PriorityQueue；生产者将任务添加到队列中，消费者从队列中取出数据；队列和线程池(线程池内部维护一个线程数组)，完全耦合在一起，当任务特别多，队列就不断的膨胀，增多，拥堵；就向车子过洞子另外一头走不掉，我靠，长龙(世界最长堵车世界纪录在天朝2
      

      • 

    • VLSI电路单元的自动布局：全局布局基础介绍
Jaaiko
数学建模算法开源图论matlab

      2024年华数杯全国大学生数学建模竞赛B题为：VLSI电路单元的自动布局。本题主要关注的是全局布局问题。学术界针对全局布局的评估模型和优化方法的研究历史悠久。本文借题顺势介绍全局布局的一些重点基础内容和相关工具/资料，以期为对EDA算法设计领域感兴趣、对数学建模感兴趣的人降低研究门槛。VLSI是超大规模集成电路的简称。完成一个VLSI设计的流程十分复杂，包含多种数据格式的转化，其中将逻辑网表转变为
      

      • 

    • 强大的销售团队背后 竟然是大数据分析的身影
蓝儿唯美
数据分析

      Mark Roberge是HubSpot的首席财务官，在招聘销售职位时使用了大量数据分析。但是科技并没有挤走直觉。
大家都知道数理学家实际上已经渗透到了各行各业。这些热衷数据的人们通过处理数据理解商业流程的各个方面，以重组弱点，增强优势。
Mark Roberge是美国HubSpot公司的首席财务官，HubSpot公司在构架集客营销现象方面出过一份力——因此他也是一位数理学家。他使用数据分析 
      

      • 

    • Haproxy+Keepalived高可用双机单活
bylijinnan
负载均衡keepalivedhaproxy高可用

      我们的应用MyApp不支持集群，但要求双机单活（两台机器：master和slave）：
1.正常情况下，只有master启动MyApp并提供服务
2.当master发生故障时，slave自动启动本机的MyApp，同时虚拟IP漂移至slave，保持对外提供服务的IP和端口不变
F5据说也能满足上面的需求，但F5的通常用法都是双机双活，单活的话还没研究过
服务器资源
10.7
      

      • 

    • eclipse编辑器中文乱码问题解决
0624chenhong
eclipse乱码

      使用Eclipse编辑文件经常出现中文乱码或者文件中有中文不能保存的问题，Eclipse提供了灵活的设置文件编码格式的选项，我们可以通过设置编码 格式解决乱码问题。在Eclipse可以从几个层面设置编码格式：Workspace、Project、Content Type、File
本文以Eclipse 3.3（英文）为例加以说明：
1. 设置Workspace的编码格式：
Windows-&g
      

      • 

    • 基础篇--resources资源
不懂事的小屁孩
android

      最近一直在做java开发，偶尔敲点android代码，突然发现有些基础给忘记了，今天用半天时间温顾一下resources的资源。
String.xml    字符串资源   涉及国际化问题 
http://www.2cto.com/kf/201302/190394.html  
string-array
      

      • 

    • 接上篇补上window平台自动上传证书文件的批处理问卷
酷的飞上天空
window

      
@echo off
: host=服务器证书域名或ip，需要和部署时服务器的域名或ip一致 ou=公司名称, o=公司名称
set host=localhost
set ou=localhost
set o=localhost
set password=123456
set validity=3650
set salias=s
      

      • 

    • 企业物联网大潮涌动：如何做好准备？
蓝儿唯美
企业

      物联网的可能性也许是无限的。要找出架构师可以做好准备的领域然后利用日益连接的世界。
尽管物联网（IoT）还很新，企业架构师现在也应该为一个连接更加紧密的未来做好计划，而不是跟上闸门被打开后的集成挑战。“问题不在于物联网正在进入哪些领域，而是哪些地方物联网没有在企业推进，” Gartner研究总监Mike Walker说。
Gartner预测到2020年物联网设备安装量将达260亿，这些设备在全
      

      • 

    • spring学习——数据库（mybatis持久化框架配置）
a-john
mybatis

      Spring提供了一组数据访问框架，集成了多种数据访问技术。无论是JDBC，iBATIS(mybatis)还是Hibernate，Spring都能够帮助消除持久化代码中单调枯燥的数据访问逻辑。可以依赖Spring来处理底层的数据访问。
mybatis是一种Spring持久化框架，要使用mybatis，就要做好相应的配置：
1，配置数据源。有很多数据源可以选择，如：DBCP，JDBC，aliba
      

      • 

    • Java静态代理、动态代理实例
aijuans
Java静态代理

      
采用Java代理模式，代理类通过调用委托类对象的方法，来提供特定的服务。委托类需要实现一个业务接口，代理类返回委托类的实例接口对象。
按照代理类的创建时期，可以分为：静态代理和动态代理。
所谓静态代理：　指程序员创建好代理类，编译时直接生成代理类的字节码文件。
所谓动态代理：　在程序运行时，通过反射机制动态生成代理类。
 
一、静态代理类实例：
1、Serivce.ja
      

      • 

    • Struts1与Struts2的12点区别
asia007
Struts1与Struts2

      1) 在Action实现类方面的对比：Struts 1要求Action类继承一个抽象基类；Struts 1的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action接口，也可以实现其他接口，使可选和定制的服务成为可能。Struts 2提供一个ActionSupport基类去实现常用的接口。即使Action接口不是必须实现的，只有一个包含execute方法的P
      

      • 

    • 初学者要多看看帮助文档 不要用js来写Jquery的代码
百合不是茶
jqueryjs

      解析json数据的时候需要将解析的数据写到文本框中,  出现了用js来写Jquery代码的问题;
 
1, JQuery的赋值  有问题
   代码如下: data.username 表示的是:  网易
 
         $("#use
      

      • 

    • 经理怎么和员工搞好关系和信任
bijian1013
团队项目管理管理

              产品经理应该有坚实的专业基础，这里的基础包括产品方向和产品策略的把握，包括设计，也包括对技术的理解和见识，对运营和市场的敏感，以及良好的沟通和协作能力。换言之，既然是产品经理，整个产品的方方面面都应该能摸得出门道。这也不懂那也不懂，如何让人信服？如何让自己懂？就是不断学习，不仅仅从书本中，更从平时和各种角色的沟通
      

      • 

    • 如何为rich:tree不同类型节点设置右键菜单
sunjing
contextMenutreeRichfaces

      组合使用target和targetSelector就可以啦，如下： <rich:tree id="ruleTree" value="#{treeAction.ruleTree}" var="node" nodeType="#{node.type}"
selectionChangeListener=&qu
      

      • 

    • 【Redis二】Redis2.8.17搭建主从复制环境
bit1129
redis

      开始使用Redis2.8.17
Redis第一篇在Redis2.4.5上搭建主从复制环境，对它的主从复制的工作机制，真正的惊呆了。不知道Redis2.8.17的主从复制机制是怎样的，Redis到了2.4.5这个版本，主从复制还做成那样，Impossible is nothing! 本篇把主从复制环境再搭一遍看看效果，这次在Unbuntu上用官方支持的版本。   Ubuntu上安装Red
      

      • 

    • JSONObject转换JSON--将Date转换为指定格式
白糖_
JSONObject

      项目中，经常会用JSONObject插件将JavaBean或List<JavaBean>转换为JSON格式的字符串，而JavaBean的属性有时候会有java.util.Date这个类型的时间对象，这时JSONObject默认会将Date属性转换成这样的格式：
 
{"nanos":0,"time":-27076233600000,
      

      • 

    • JavaScript语言精粹读书笔记
braveCS
JavaScript

      【经典用法】：
 
//①定义新方法
Function .prototype.method=function(name, func){
this.prototype[name]=func;
return this;
}
//②给Object增加一个create方法，这个方法创建一个使用原对
      

      • 

    • 编程之美-找符合条件的整数 用字符串来表示大整数避免溢出
bylijinnan
编程之美

      
import java.util.LinkedList;
public class FindInteger {
/**
* 编程之美 找符合条件的整数 用字符串来表示大整数避免溢出
* 题目：任意给定一个正整数N，求一个最小的正整数M(M>1)，使得N*M的十进制表示形式里只含有1和0
*
* 假设当前正在搜索由0，1组成的K位十进制数
      

      • 

    • 读书笔记
chengxuyuancsdn
读书笔记

      1、Struts访问资源
2、把静态参数传递给一个动作
3、<result>type属性
4、s:iterator、s:if c:forEach
5、StringBuilder和StringBuffer
6、spring配置拦截器
1、访问资源
(1)通过ServletActionContext对象和实现ServletContextAware,ServletReque
      

      • 

    • [通讯与电力]光网城市建设的一些问题
comsci
问题

      
      信号防护的问题,前面已经说过了,这里要说光网交换机与市电保障的关系
      我们过去用的ADSL线路,因为是电话线,在小区和街道电力中断的情况下,只要在家里用笔记本电脑+蓄电池,连接ADSL,同样可以上网........
    
      

      • 

    • oracle 空间RESUMABLE
daizj
oracle空间不足RESUMABLE错误挂起

      空间RESUMABLE操作  转
Oracle从9i开始引入这个功能，当出现空间不足等相关的错误时，Oracle可以不是马上返回错误信息，并回滚当前的操作，而是将操作挂起，直到挂起时间超过RESUMABLE TIMEOUT，或者空间不足的错误被解决。
这一篇简单介绍空间RESUMABLE的例子。
第一次碰到这个特性是在一次安装9i数据库的过程中，在利用D
      

      • 

    • 重构第一次写的线程池
dieslrae
线程池 python

      最近没有什么学习欲望,修改之前的线程池的计划一直搁置,这几天比较闲,还是做了一次重构,由之前的2个类拆分为现在的4个类.
1、首先是工作线程类:TaskThread,此类为一个工作线程,用于完成一个工作任务,提供等待(wait),继续(proceed),绑定任务(bindTask)等方法
#!/usr/bin/env python
# -*- coding:utf8 -*-

      

      • 

    • C语言学习六指针
dcj3sjt126com
c

      初识指针，简单示例程序：
/*
指针就是地址，地址就是指针
地址就是内存单元的编号
指针变量是存放地址的变量
指针和指针变量是两个不同的概念
但是要注意： 通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样
*/
# include <stdio.h>
int main(void)
{
int * p; // p是变量的名字， int * 
      

      • 

    • yii2 beforeSave afterSave beforeDelete
dcj3sjt126com
delete

      public function afterSave($insert, $changedAttributes)
{
parent::afterSave($insert, $changedAttributes);
if($insert) {
//这里是新增数据
} else {
//这里是更新数据
}
}
 
      

      • 

    • timertask
shuizhaosi888
timertask

      java.util.Timer timer = new java.util.Timer(true);
// true 说明这个timer以daemon方式运行（优先级低，
// 程序结束timer也自动结束），注意，javax.swing
// 包中也有一个Timer类，如果import中用到swing包，
// 要注意名字的冲突。
TimerTask task = new
      

      • 

    • Spring Security（13）——session管理
234390216
sessionSpring Security攻击保护超时

      session管理
目录
 
1.1     检测session超时
1.2     concurrency-control
1.3     session 固定攻击保护
 
      
      

      • 

    • 公司项目NODEJS实践0.3[ mongo / session ...]
逐行分析JS源代码
mongodbsessionnodejs

         
http://www.upopen.cn
 
一、前言
        书接上回，我们搭建了WEB服务端路由、模板等功能，完成了register 通过ajax与后端的通信，今天主要完成数据与mongodb的存取，实现注册 / 登录 /
      

      • 

    • pojo.vo.po.domain区别
LiaoJuncai
javaVOPOJOjavabeandomain

      　　POJO = "Plain Old Java Object"，是MartinFowler等发明的一个术语，用来表示普通的Java对象，不是JavaBean, EntityBean 或者 SessionBean。POJO不但当任何特殊的角色，也不实现任何特殊的Java框架的接口如，EJB， JDBC等等。
　　
　　即POJO是一个简单的普通的Java对象，它包含业务逻辑
      

      • 

    • Windows Error Code
OhMyCC
windows

      0 操作成功完成.
1 功能错误.
2 系统找不到指定的文件.
3 系统找不到指定的路径.
4 系统无法打开文件.
5 拒绝访问.
6 句柄无效.
7 存储控制块被损坏.
8 存储空间不足, 无法处理此命令.
9 存储控制块地址无效.
10 环境错误.
11 试图加载格式错误的程序.
12 访问码无效.
13 数据无效.
14 存储器不足, 无法完成此操作.
15 系
      

      • 

    • 在storm集群环境下发布Topology
roadrunners
集群stormtopologyspoutbolt

      storm的topology设计和开发就略过了。本章主要来说说如何在storm的集群环境中，通过storm的管理命令来发布和管理集群中的topology。
 
1、打包
打包插件是使用maven提供的maven-shade-plugin，详细见maven-shade-plugin。
<plugin>
<groupId>org.apache.maven.
      

      • 

    • 为什么不允许代码里出现“魔数”
tomcat_oracle
java

      　　在一个新项目中，我最先做的事情之一，就是建立使用诸如Checkstyle和Findbugs之类工具的准则。目的是制定一些代码规范，以及避免通过静态代码分析就能够检测到的bug。 　　迟早会有人给出案例说这样太离谱了。其中的一个案例是Checkstyle的魔数检查。它会对任何没有定义常量就使用的数字字面量给出警告，除了-1、0、1和2。 　　很多开发者在这个检查方面都有问题，这可以从结果
      

      • 

    • zoj 3511 Cake Robbery(线段树)
阿尔萨斯
线段树

       题目链接：zoj 3511 Cake Robbery
题目大意：就是有一个N边形的蛋糕，切M刀，从中挑选一块边数最多的，保证没有两条边重叠。
解题思路：有多少个顶点即为有多少条边，所以直接按照切刀切掉点的个数排序，然后用线段树维护剩下的还有哪些点。
#include <cstdio>
#include <cstring>
#include <vector&
      

      •