Java 数据结构篇-用数组、堆实现优先级队列

news2024/11/22 17:48:09

🔥博客主页： 【小扳_-CSDN博客】
❤感谢大家点赞👍收藏⭐评论✍  

文章目录

        1.0 优先级队列说明

        2.0 用数组实现优先级队列

        3.0 无序数组实现优先级队列

        3.1 无序数组实现优先级队列 - 入队列 offer(E value)

        3.2 无序数组实现优先级队列 - 出队列 poll()

        3.3 无序数组实现优先级队列 - 查看队列中优先级最大的元素 peek() 

        3.4 无序数组实现优先级队列 - 判断是否为空队列

        3.5 无序数组实现优先级队列 - 判断是否为满队列

        3.6 无序数组实现优先级队列完整代码

        4.0 有序数组实现优先级队列

        4.1 有序数组实现优先级队列 - 入队列 offer(E value)

        4.2 有序数组实现有序队列 - 出队列 poll()

        4.3 有序数组实现有序队列 - 查看优先级最大的元素 peek()

        4.4 有序数组实现优先级队列 - 判断队列是否为空

        4.5 有序数组实现优先级队列 - 判断队列是否为满队列

        4.6 有序数组实现优先级队列完整代码

        5.0 大顶堆实现优先级队列

        5.1 堆实现优先级队列 - 入队列 offer(E value)

        5.2 堆实现优先级队列 - 出队列 poll()

        5.3 堆实现优先级队列 - 查看优先级最大的元素 peek()

        5.4 堆实现优先级队列 - 判断该队列是否为空

        5.5 堆实现优先级队列 - 判断该队列是否为满队列

        5.6 堆实现优先级队列完整代码

        1.0 优先级队列说明

        优先级队列是一种特殊的队列，其中每个元素都有一个优先级。在优先级队列中，具有最高优先级的元素首先被移除。这与普通队列不同，普通队列是先进先出（FIFO）的，而优先级队列则是按照优先级来确定元素的出队顺序。

        优先级队列通常用于需要按照优先级处理元素的场景，比如任务调度、事件处理等。它可以使用不同的数据结构来实现，最常见的是使用堆（heap）来实现优先队列。堆是一种特殊的树形数据结构，它可以快速找到并移除具有最高（或最低）优先级的元素。

        优先级队列的常见操作包括插入元素、移除具有最高优先级的元素、查看具有最高优先级的元素等。实现优先级队列的常见算法包括插入时的堆调整、移除最高优先级元素后的堆调整等。

        2.0 用数组实现优先级队列

        可以使用数组来实现优先级队列，一种简单的实现方式是使用数组来存储元素，并且按照优先级顺序来维护数组。

        用数组实现优先级队列可分为两种：无序数组实现、有序数组实现。

        3.0 无序数组实现优先级队列

        可以直接简单粗暴来说，无序数组就是插入元素的时候不按照优先级进行排序，而出队列的时候，严格按照优先级大小进行出队列。

        首先，需要实现队列中的接口。比如：入队列、出队列等。

接口代码如下：

public interface Queue<E> {

    /**
     * 入队操作
     */
    boolean offer(E value);

    /**
     * 出队操作
     */
    E poll();

    /**
     * 查看队头元素
     */
    E peek();

    /**
     * 判断是否为空队列
     */
    boolean isEmpty();

    /**
     * 判断是否为满队列
     */
    boolean isFull();
}

        再接着，设置优先级元素。

代码如下：

public interface Priority {

    int priority();

}
public class Entry implements  Priority{
    String string;
    int priority;

    public Entry(String string, int priority) {
        this.string = string;
        this.priority = priority;
    }

    @Override
    public int priority() {
        return priority;
    }

    @Override
    public String toString() {
        return "Entry{" +
                "string='" + string + '\'' +
                ", priority=" + priority +
                '}';
    }
}

        该设置的优先级元素需要实现 priority 接口，返回当前优先级的大小。

        成员变量有 Priority[] arr 自定义大小的数组、size 标记当前元素的个数。

代码如下：

public class UnorderedPriorityQueue<E extends Priority> implements Queue<E> {

    private Priority[] arr;
    private int size;

    public UnorderedPriorityQueue(int capacity) {
        arr = new Priority[capacity];
    }

}

        3.1 无序数组实现优先级队列 - 入队列 offer(E value)

        由于用无序数组实现，元素可直接在数组尾部入队列。

代码如下：

    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        arr[size++] = value;
        return true;
    }

        注意：在入队前，需要判断是否为满队列。入队完后，需要进行 size++ 。

        3.2 无序数组实现优先级队列 - 出队列 poll()

        根据元素的优先级大小进行出队列，首先需要遍历数组找到索引为 i 处优先级最大的元素。一般有两种情况：

        第一种情况：在索引为 i == size - 1 处找到优先级最大的元素，此时只需要将 size-- ，然后将其引用置为空 arr[size] = null 。

        第二种情况：不在索引为 i !=  size - 1 处找到优先级最大的元素。那么需要将索引为 i 的元素被 i + 1 处的元素进行覆盖，长度为：size - 1 - i 。

代码如下：

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        //先找到优先级大的点
        int j = 0;
        for (int i = 1; i < size; i++) {
            if (arr[j].priority() < arr[i].priority()) {
                j = i;
            }
        }
        E ret = (E)arr[j];
        if (j < size - 1) {
            System.arraycopy(arr,j+1,arr,j,size - 1 - j);
        }
        size--;
        arr[size] = null;
        return ret;
    }

        最后需要返回优先级最大的元素，在被置为 null 之前将其进行保存。每次出队完毕，后需要进行 size-- 、置为 null 。

        3.3 无序数组实现优先级队列 - 查看队列中优先级最大的元素 peek() 

        相比与出队列，找到了优先级最大的元素后，不需要进行删除该优先级最大的元素。

代码如下：

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        //先找到优先级大的点
        int j = 0;
        for (int i = 1; i < size; i++) {
            if (arr[j].priority() < arr[i].priority()) {
                j = i;
            }
        }
        E ret = (E)arr[j];
        return ret;
    }

        注意：在查看元素之前需要先判断是否为空队列。

        3.4 无序数组实现优先级队列 - 判断是否为空队列

        若 size == 0 ，则为空队列；若不是，则不为空。

代码如下：

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

        3.5 无序数组实现优先级队列 - 判断是否为满队列

        若 size == arr.length 时，则为满队列；若不相等，则不为满。

代码如下：

    @Override
    public boolean isFull() {
        return size == arr.length;
    }

        3.6 无序数组实现优先级队列完整代码

public class UnorderedPriorityQueue<E extends Priority> implements Queue<E> {

    private Priority[] arr;
    private int size;

    public UnorderedPriorityQueue(int capacity) {
        arr = new Priority[capacity];
    }

    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        arr[size++] = value;
        return true;
    }

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        //先找到优先级大的点
        int j = 0;
        for (int i = 1; i < size; i++) {
            if (arr[j].priority() < arr[i].priority()) {
                j = i;
            }
        }
        E ret = (E)arr[j];
        if (j < size - 1) {
            System.arraycopy(arr,j+1,arr,j,size - 1 - j);
        }
        size--;
        arr[size] = null;
        return ret;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        //先找到优先级大的点
        int j = 0;
        for (int i = 1; i < size; i++) {
            if (arr[j].priority() < arr[i].priority()) {
                j = i;
            }
        }
        E ret = (E)arr[j];
        return ret;
    }

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

    @Override
    public boolean isFull() {
        return size == arr.length;
    }
}

        4.0 有序数组实现优先级队列

        相对于无序数组优先级队列来说，有序数组实现优先级队列入队列操作需要按照优先级大小进行插入，而出队列操作直接在索引为 size - 1 处直接获取该最大优先级元素。

        首先，同样的，需要实现队列中的接口。比如：入队列、出队列等。

接口代码如下：

public interface Queue<E> {

    /**
     * 入队操作
     */
    boolean offer(E value);

    /**
     * 出队操作
     */
    E poll();

    /**
     * 查看队头元素
     */
    E peek();

    /**
     * 判断是否为空队列
     */
    boolean isEmpty();

    /**
     * 判断是否为满队列
     */
    boolean isFull();
}

        再接着，设置优先级元素。

代码如下：

public class Entry implements  Priority{
    String string;
    int priority;

    public Entry(String string, int priority) {
        this.string = string;
        this.priority = priority;
    }

    @Override
    public int priority() {
        return priority;
    }

    @Override
    public String toString() {
        return "Entry{" +
                "string='" + string + '\'' +
                ", priority=" + priority +
                '}';
    }
}

        成员变量有 Priority[] arr 自定义大小的数组、size 标记当前元素的个数。

代码如下：

public class OrderedPriorityQueue<E extends Priority> implements Queue<E>{

    private Priority[] arr;
    private int size;

    public OrderedPriorityQueue(int capacity) {
        arr = new Priority[capacity];
    }

}

        4.1 有序数组实现优先级队列 - 入队列 offer(E value)

        使用有序数组实现优先级入队列，在入队列之前从后往前遍历数组，找到优先级小于入队列的元素优先级，找到即可插入其中。

代码如下：

    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        //先找到优先级比value的优先级大的索引
        int i = size - 1;
        while (i >= 0 && arr[i].priority() > value.priority()) {
            arr[i+1] = arr[i];
            i--;
        }
        arr[i+1] = value;
        size++;
        return true;
    }

        考虑一种情况，若 size == 0 时，为空队列的时候，该代码有无错误？

                答案是：没有问题的，当 size == 0 时， 则 i = 0 - 1，i = -1 ， 此时不会进入循环直接跳到 arr[i + 1] 处，所以，在这种情况下，该代码没有问题。

        4.2 有序数组实现有序队列 - 出队列 poll()

        这就相对于有序数组入队列来说比较简单了，直接在索引为 i = size - 1 处，得到优先级最大的元素，然后将 size-- ，再接着 arr[size] 置为 null 。

代码如下：

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        E str = (E)arr[size - 1];
        size--;
        arr[size] = null;
        return str;
    }

        注意：需要记录优先级最大的元素并且返回。在出队列之前需要判断该队列是否为空队列。

        4.3 有序数组实现有序队列 - 查看优先级最大的元素 peek()

        先判断该队列是否为空队列，若不是，直接返回该数组索引为 size - 1 处的元素即可。

代码如下：

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        E str = (E)arr[size - 1];
        return str;
    }

        4.4 有序数组实现优先级队列 - 判断队列是否为空

        若 size == 0 ，则为空；若不为，则为不空。

代码如下：

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

        4.5 有序数组实现优先级队列 - 判断队列是否为满队列

        若 size == arr.length 时，则为满队列；若不是，则为不满队列。

代码如下：

    @Override
    public boolean isFull() {
        return size == arr.length;
    }

        4.6 有序数组实现优先级队列完整代码

public class OrderedPriorityQueue<E extends Priority> implements Queue<E>{

    private Priority[] arr;
    private int size;

    public OrderedPriorityQueue(int capacity) {
        arr = new Priority[capacity];
    }

    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        //先找到优先级比value的优先级大的索引
        int i = size - 1;
        while (i >= 0 && arr[i].priority() > value.priority()) {
            arr[i+1] = arr[i];
            i--;
        }
        arr[i+1] = value;
        size++;
        return true;
    }

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        E str = (E)arr[size - 1];
        size--;
        arr[size] = null;
        return str;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        E str = (E)arr[size - 1];
        return str;
    }

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

    @Override
    public boolean isFull() {
        return size == arr.length;
    }
}

        5.0 大顶堆实现优先级队列

        大顶堆说明：

        大顶堆是一种特殊的堆，它是一种完全二叉树，其中每个父节点的值都大于或等于其左右子节点的值。在大顶堆中，根节点的值是整个堆中最大的。

        大顶堆可以使用数组来实现，其中堆的根节点存储在数组的第一个位置，然后按照完全二叉树的性质依次存储其他节点。这种实现方式使得大顶堆的父节点和子节点之间可以通过简单的数学关系来计算，从而方便进行堆调整操作。假设 i 不为 0 ，该双亲索引为：（i - 1）/ 2 ；该左孩子为：2 * i + 1；该右孩子为：2 * i  + 2 。

        首先，需要实现队列中的接口。比如：入队列、出队列等。

接口代码如下：

public interface Queue<E> {

    /**
     * 入队操作
     */
    boolean offer(E value);

    /**
     * 出队操作
     */
    E poll();

    /**
     * 查看队头元素
     */
    E peek();

    /**
     * 判断是否为空队列
     */
    boolean isEmpty();

    /**
     * 判断是否为满队列
     * */
    boolean isFull();
}

         再接着，设置优先级元素。

代码如下：

public class Entry implements  Priority{
    String string;
    int priority;

    public Entry(String string, int priority) {
        this.string = string;
        this.priority = priority;
    }

    @Override
    public int priority() {
        return priority;
    }

    @Override
    public String toString() {
        return "Entry{" +
                "string='" + string + '\'' +
                ", priority=" + priority +
                '}';
    }
}

        成员变量有 Priority[] arr 自定义大小的数组、size 标记当前元素的个数。

代码如下：

public class BigTopPile<E extends Priority> implements Queue<E> {

    private Priority[] arr;
    private int size;

    public BigTopPile(int capacity) {
        arr = new Priority[capacity];
    }

}

        5.1 堆实现优先级队列 - 入队列 offer(E value)

        具体思路为：由于是按照优先级大小来存放元素的，所以，需要先比较优先级大小，在适合的位置插入。现在已知 i = size，该双亲为：（i - 1）/ 2 。接下来，需要判断 arr[（i - 1）/ 2] 的优先级于入队列的元素优先级大小，若 arr[（i - 1）/ 2] 的优先级较大，此时该入队列的元素存放的位置为 arr[i] = value ；若 value 的优先级大于当前 arr[（i - 1）/ 2] 时，先将当前 arr[（i - 1）/ 2] 往后放，即 arr[i] = arr[（i - 1）/ 2] 。之后需要继续往上找双亲，将 i = (i - 1) / 2 ，直到 i == 0 或者 value 的优先级小于当前 arr[（i - 1）/ 2] 时，则为 arr[i] = value 。

代码如下：

    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        int i = size;
        int j = (i - 1) / 2;
        while (i > 0 && arr[j].priority() < value.priority()) {
            arr[i] = arr[j];
            i = j;
            j = (i - 1) / 2;
        }
        arr[i] = value;
        size++;
        return true;
    }

        只要 i == 0 时， j 不能继续往上走了，否则为抛空指针异常。

        5.2 堆实现优先级队列 - 出队列 poll()

        具体思路为：分为两步。

        第一步，将 arr[size - 1] 处的元素交换到 arr[0] 处。

        第二步，由于根处的优先级永远都要大于该孩子的优先级，所以，将交换之后的元素进行下潜，即先找到该左右孩子优先级最大的元素，于根元素进行交换，一直往下进行下潜。直到该根元素没有左右孩子或者根元素的优先级都大于该左右孩子的优先级。

代码实现：

非递归实现：

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }

        E top = (E)arr[0];
        arr[0] = arr[size - 1];
        size--;
        arr[size] = null;
        int i = 0;
        while ( (i * 2 + 1) < size && (i * 2 + 2) < size && (arr[i].priority() < arr[i * 2 + 1].priority() || arr[i].priority() < arr[i * 2 + 2].priority() ) ) {

            int j = 0;
            if (arr[i * 2 + 1].priority() > arr[i * 2 + 2].priority()) {
                j = i * 2 + 1;
            }else if (arr[i * 2 + 1].priority() <= arr[i * 2 + 2].priority()) {
                j = i * 2 + 2;
            }
            E temp = (E)arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
            i = j;
        }
        return top;
    }

         (i * 2 + 1) < size && (i * 2 + 2) < size 该代码判断的是有无左右孩子元素。

递归实现：

    public E poll1() {
        if (isEmpty()) {
            return null;
        }
        //交换头尾
        swap(0,size - 1);
        size--;
        //置为 null
        E ret = (E)arr[size];
        arr[size] = null;

        //下潜
        down(0);
        return ret;

    }
    private void swap(int i, int j) {
        E t = (E)arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
    private void down(int i) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int max = i;
        if ( left < size && arr[max].priority() < arr[left].priority()) {
            max = left;
        }
        if (right < size && arr[max].priority() < arr[right].priority()) {
            max = right;
        }
        if (max != i) {
            swap(max,i);
            down(max);
        }
    }

        

        5.3 堆实现优先级队列 - 查看优先级最大的元素 peek()

        先判断该队列是否为空，若不为空，则直接返回堆顶元素即可。

代码如下：

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return (E)arr[0];
    }

         5.4 堆实现优先级队列 - 判断该队列是否为空

        当 size == 0 时，则为空队列。

代码实现：

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

        5.5 堆实现优先级队列 - 判断该队列是否为满队列

        当 size == arr.length 时，则为满队列。

代码实现：

    @Override
    public boolean isFull() {
        return size == arr.length;
    }

        5.6 堆实现优先级队列完整代码

public class BigTopPile<E extends Priority> implements Queue<E> {

    private Priority[] arr;
    private int size;

    public BigTopPile(int capacity) {
        arr = new Priority[capacity];
    }

    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        int i = size;
        int j = (i - 1) / 2;
        while (i > 0 && arr[j].priority() < value.priority()) {
            arr[i] = arr[j];
            i = j;
            j = (i - 1) / 2;
        }
        arr[i] = value;
        size++;
        return true;
    }

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }

        E top = (E)arr[0];
        arr[0] = arr[size - 1];
        size--;
        arr[size] = null;
        int i = 0;
        while ( (i * 2 + 1) < size && (i * 2 + 2) < size && (arr[i].priority() < arr[i * 2 + 1].priority() || arr[i].priority() < arr[i * 2 + 2].priority() ) ) {

            int j = 0;
            if (arr[i * 2 + 1].priority() > arr[i * 2 + 2].priority()) {
                j = i * 2 + 1;
            }else if (arr[i * 2 + 1].priority() <= arr[i * 2 + 2].priority()) {
                j = i * 2 + 2;
            }
            E temp = (E)arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
            i = j;
        }
        return top;
    }

    public E poll1() {
        if (isEmpty()) {
            return null;
        }
        //交换头尾
        swap(0,size - 1);
        size--;
        //置为 null
        E ret = (E)arr[size];
        arr[size] = null;

        //下潜
        down(0);
        return ret;

    }
    private void swap(int i, int j) {
        E t = (E)arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
    private void down(int i) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int max = i;
        if ( left < size && arr[max].priority() < arr[left].priority()) {
            max = left;
        }
        if (right < size && arr[max].priority() < arr[right].priority()) {
            max = right;
        }
        if (max != i) {
            swap(max,i);
            down(max);
        }
    }



    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return (E)arr[0];
    }

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

    @Override
    public boolean isFull() {
        return size == arr.length;
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1307519.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

mysql数据备份策略-shell脚本优化代码

mysql数据备份策略-shell脚本优化代码

一.备份的主机上需要自己手动安装xtrabackup工具 1.安装xtrabackup-yum源 #下载xtrabackup的yum源 wget http://www.percona.com/downloads/percona-release/redhat/0.1-4/percona-release-0.1-4.noarch.rpmrpm -ivh percona-release-0.1-4.noarch.rpm2.打开yum源 #打开xtra…
阅读更多...
竞赛保研 python 机器视觉 车牌识别 - opencv 深度学习 机器学习

竞赛保研 python 机器视觉 车牌识别 - opencv 深度学习 机器学习

1 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 基于python 机器视觉 的车牌识别系统 &#x1f947;学长这里给一个题目综合评分(每项满分5分) 难度系数&#xff1a;3分工作量&#xff1a;3分创新点&#xff1a;3分 &#x1f9ff; 更多资…
阅读更多...
道路坑洞数据集（坑洞目标检测）VOC+YOLO格式650张

道路坑洞数据集（坑洞目标检测）VOC+YOLO格式650张

路面坑洞的形成原因是由于设计、施工、养护处理不当、控制不适和受气候、环境、地质、水文等自然因素影响&#xff0c;以及车辆的运行和车辆超载运行导致路面破损&#xff0c;出现坑洞的现象。 路面坑洞的分类&#xff1a; &#xff08;1&#xff09;路面混凝土板中坑洞&…
阅读更多...
你真的了解进程注入吗？

你真的了解进程注入吗？

关注公众号回复20231110获取最新网络安全以及内网渗透等资料。 文章目录 关注公众号回复20231110获取最新网络安全以及内网渗透等资料。进程注入进程注入是什么&#xff1f;windows进程虚拟地址空间句柄Tokens线程数特权shellcode注入 进程注入 进程注入是什么&#xff1f; 攻…
阅读更多...
Python码上行动系列丛书（由北京大学出版社出版）

Python码上行动系列丛书（由北京大学出版社出版）

前言 Python码上行动系列丛书火热来袭&#x1f4a5;&#x1f4a5;&#x1f4a5; 三册在手&#xff0c;Python全掌握&#xff01;无论是初学者还是进阶玩家&#xff0c;我们都有你想要的&#xff01; 让ChatGPT带你轻松入门Python编程&#xff0c;享受编程带来的乐趣&#xff0…
阅读更多...
git 实用命令杂记

git 实用命令杂记

使用解决冲突的方式合并&#xff0c;将避免简单的自动合并 git merge origin/dev --strategyresolve清理本地已经合并到 dev 的分支 git branch --merged | grep -v dev | xargs -n 1 git branch -d分支清理 Git 之删除本地无用分支_dearfulan 的博客 - CSDN 博客_git 删除本…
阅读更多...
RV32/64 特权架构

RV32/64 特权架构

machine mode: 运行最可信的代码;supervisor mode:为 Linux&#xff0c;FreeBSD 和 Windows 等操作系统提供支持;user mode:权限最低&#xff0c;应用程序的代码在此模式下运行&#xff1b; 这两种新模式都比user mode有着更高的权限&#xff0c;有更多权限的模式通常可以使用…
阅读更多...
C/C++ 快乐数: 编写一个算法来判断一个数n是不是快乐数

C/C++ 快乐数: 编写一个算法来判断一个数n是不是快乐数

题目&#xff1a; 编写一个算法来判断一个数n是不是快乐数。 快乐数的定义&#xff1a; 对于一个正整数&#xff0c;每一次将该数替换为它每个位置上的数字的平方和。 然后重复这个过程直到这个数变为 1&#xff0c;也可能是 无限循环 但始终变不到 1。 如果这个过…
阅读更多...
数字中台建设指南（大数据平台）

数字中台建设指南（大数据平台）

制定数字中台战略规划&#xff1a;制定符合企业实际情况的数字中台战略规划&#xff0c;明确建设目标、重点任务和时间表。确定数字中台架构&#xff1a;根据企业业务需求和特点&#xff0c;确定数字中台的架构&#xff0c;包括技术架构、应用架构和数据架构。搭建数字中台基础…
阅读更多...
制作Windows 11的U盘启动工具的两种方法，以及如何使用它来安装

制作Windows 11的U盘启动工具的两种方法，以及如何使用它来安装

本文介绍了如何创建Windows 11的U盘启动工具，以及如何使用它来安装Windows 11。 Windows 11 Media Creation Tool 微软网站上提供的Windows 11 Media Creation Tool可以帮助你创建Windows 11的U盘启动工具。它真的很容易使用，因为它可以引导你完成所有的步骤。 1、访问Mic…
阅读更多...
接口测试要测试什么？怎么测？

接口测试要测试什么？怎么测？

本文主要分为两个部分&#xff1a; 第一部分&#xff1a;主要从问题出发&#xff0c;引入接口测试的相关内容并与前端测试进行简单对比&#xff0c;总结两者之前的区别与联系 第二部分&#xff1a;主要介绍为什么要做接口测试&#xff0c;并简单总结接口持续集成和接口质量评估…
阅读更多...
textarea 网页文本框在光标处添加内容

textarea 网页文本框在光标处添加内容

在前端研发中我们经常需要使用脚本在文本框中插入内容。如果产品要求不能直接插入开始或者尾部&#xff0c;而是要插入到光标位置&#xff0c;此时我们就需要获取光标/光标选中的位置。 很多时候&#xff0c;我在格式化文本处需要选择选项&#xff0c;将选择的信息输入到光标位…
阅读更多...
Nginx【通俗易懂】《中篇》

Nginx【通俗易懂】《中篇》

目录 1.Url重写rewrite 2.防盗链 3.静态资源压缩 4.跨域问题 1.Url重写rewrite &#x1f929;&#x1f929;&#x1f929; 1.1.rewrite书写格式 rewrite是实现URL重写的关键指令&#xff0c;根据regex&#xff08;正则表达式&#xff09;部分内容&#xff0c;重定向到rep…
阅读更多...
Jetpack Startup 优雅完成库的初始化和方法接口简化

Jetpack Startup 优雅完成库的初始化和方法接口简化

目录 1.Startup组件是什么2.Startup组件能做啥2.1 startup组件可以简化用户使用我们提供的库的流程。2.2 简化库提供给使用者的API接口 3.如何使用Startup组件3.1 引入依赖3.2 创建一个初始化的类继承Initializer3.3 在我们库的AndroidManifest.xml中加入配置 4.使用Startup组件…
阅读更多...
Windows mysql5.7 执行查询/开启/测试binlog---简易记录

Windows mysql5.7 执行查询/开启/测试binlog---简易记录

前言&#xff1a;基于虚拟机mysql版本为5.7&#xff0c;增量备份测试那就要用到binlog… 简述&#xff1a;二进制日志&#xff08;binnary log&#xff09;以事件形式记录了对MySQL数据库执行更改的所有操作。 binlog是记录所有数据库表结构变更&#xff08;例如CREATE、ALTER…
阅读更多...
C++相关闲碎记录(9)

C++相关闲碎记录(9)

1、非修改型算法 for_each()对每个元素执行某种操作count()返回元素个数count_if()返回满足某一条件的元素的个数min_element()返回最小值元素max_element()返回最大值元素minmax_element()返回最小值和最大值元素find()查找某个数值find_if()查找满足条件的元素find_if_not()…
阅读更多...
03 Temporal 详细介绍

03 Temporal 详细介绍

前言 在后端开发中&#xff0c;大家是否有遇到如下类型的开发场景 需要处理较多的异步事件需要的外部服务可靠性较低需要记录保存某个对象的复杂状态 在以往的开发过程中&#xff0c;可能更多的直接使用数据库、定时任务、消息队列等作为基础&#xff0c;来解决上面的问题。然…
阅读更多...
【概率方法】MCMC 之 Gibbs 采样

【概率方法】MCMC 之 Gibbs 采样

上一篇文章讲到&#xff0c;MCMC 中的 HM 算法&#xff0c;它可以解决拒绝采样效率低的问题&#xff0c;但是实际上&#xff0c;当维度高的时候 HM 算法还是在同时处理多个维度&#xff0c;以两个变量 x [ x , y ] \mathbf{x} [x,y] x[x,y] 来说&#xff0c;也就是同时从联合…
阅读更多...
Nyquist Theorem（取样定理）

Nyquist Theorem（取样定理）

取样定理&#xff0c;又称为奈奎斯特定理&#xff08;Nyquist Theorem&#xff09;&#xff0c;是信号处理领域中一项至关重要的基本原理。它规定了对于连续时间信号&#xff0c;为了能够完全准确地还原出原始信号&#xff0c;即使是在离散时间下进行采样和再构建&#xff0c;都…
阅读更多...
算法基础之树的重心

算法基础之树的重心

树的重心 无向图: 边没有方向 有向图:边有方向 只能单向询问 无向图建立双向的边 要求输出每种情况连通块个数最大值的最小值**(最小的最大值)** #include <cstdio>#include <cstring>#include <iostream>#include <algorithm>using namespace s…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023