从0开始学python-day17-数据结构2

news2024/10/30 6:46:46

2.3 队列

队列(Queue)，它是一种运算受限的线性表,先进先出(FIFO First In First Out)

  • 队列是一种受限的线性结构

  • 受限之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作

Python标准库中的queue模块提供了多种队列实现，包括普通队列、双端队列、优先队列等。

当两个程序效率不一样时，可以用队列作为缓冲池（提高系统性能，把同步操作变成异步操作）。生产者-消费者模式。

redis：可以存数组，

2.3.1 普通队列

queue.Queue 是 Python 标准库 queue 模块中的一个类，适用于多线程环境。它实现了线程安全的 FIFO（先进先出）队列。

案例：

import queue
​
q = queue.Queue()
q.put(1)
q.put(3)
q.put(2)
​
print(q.qsize())
print(q.get())
print(q.get())
print(q.get())
2.3.2 双端队列

双端队列（Deque，Double-Ended Queue）是一种具有队列和栈性质的数据结构，它允许我们在两端进行元素的添加（push）和移除（pop）操作。在Python中，双端队列可以通过collections模块中的deque类来实现。

deque是一个双端队列的实现，它提供了在两端快速添加和移除元素的能力。

案例：

from collections import deque
​
​
q = deque()
​
q.append(1)
q.append(2)
q.appendleft(3)
q.appendleft(4)
​
print(q.pop())
print(q.popleft())

当结合使用appendleft和popleft时，你实际上是在实现一个栈（Stack）的数据结构，因为栈是后进先出（LIFO）的，而这两个操作正好模拟了栈的“压栈”和“弹栈”行为。append和pop结合使用同理。

2.3.3 优先队列

优先队列（Priority Queue）是一种特殊的队列，其中的元素按照优先级进行排序。优先级最高的元素总是最先出队。Python 标准库中提供了 queue.PriorityQueue 和 heapq 模块来实现优先队列。

queue.PriorityQueue

queue.PriorityQueue 是 Python 标准库 queue 模块中的一个类，适用于多线程环境。它实现了线程安全的优先队列。

案例：

import queue
​
q = queue.PriorityQueue()
# 向队列中添加元素，元素是一个元组 (priority, item)，其中 priority 是优先级，item 是实际的数据
q.put((1,'item1'))
q.put((3,'item3'))
q.put((2,'item2'))
​
print(q.get())
print(q.get())
print(q.get())

heapq

heapq 模块是 Python 标准库中的一个模块，提供了基于堆的优先队列实现。heapq 模块不是线程安全的，适用于单线程环境。

案例：

import heapq
​
# 创建一个列表作为堆
heap = []
​
# 向堆中添加元素，元素是一个元组 (priority, item)
heapq.heappush(heap, (3, 'Task 3'))
heapq.heappush(heap, (1, 'Task 1'))
heapq.heappush(heap, (2, 'Task 2'))
​
# 从堆中取出元素
print(heapq.heappop(heap))  # 输出: (1, 'Task 1')
print(heapq.heappop(heap))  # 输出: (2, 'Task 2')
print(heapq.heappop(heap))  # 输出: (3, 'Task 3')
import queue
from collections import deque
import heapq
def pd_queue():
    #Queue:普通队列，从队尾入队，从队头出队
    #put():入队
    #get():出队
    q=queue.Queue()
    q.put(1)
    q.put(2)
    q.put(3)
​
    print(q.get())
    print(q.get())
    print(q.get())
#deque:双端队列，既可以在队尾进行入队和出队操作，也可以在队头进行入队和出队操作
#append():在队尾入队
#appendleft():在队头入队
#pop():在队尾出队
#popleft():在队头出队
#appendleft和popleft组合使用时，相当于栈的操作
#appned和pop组合使用同理
    dq=deque()
    dq.append(1)
    dq.append(2)
    dq.appendleft(3)
    dq.appendleft(4)
​
    print(dq.popleft())
    print(dq.popleft())
    print(dq.popleft())
    print(dq.popleft())
​
#PriorityQueue:优先队列，参数：元组（优先级，元素），优先级的数值越小，优先级越高
    pq=queue.PriorityQueue()
    pq.put((1,'item1'))
    pq.put((3, 'item2'))
    pq.put((3, 'item3'))
​
    print('--------------')
    print(pq.get())
    print(pq.get())
    print(pq.get())
​
   #heapq:优先队列，基于堆实现的，预先定义一个数组作为heap对象，线程不安全
   #heappush（）：参数1：heap是预先定义的堆，参数2：向队中添加优先级的元素元祖（优先级，元素值），优先级的数值越小，优先级越高
   #heappop（heap）：参数：heap是预先定义的堆
    heap=[ ]
    heapq.heappush(heap,(1,'hq1'))
    heapq.heappush(heap,(3,'hq2'))
    heapq.heappush(heap,(2,'hq3'))
​
    print('-----------')
    print(heapq.heappop(heap))
    print(heapq.heappop(heap))
    print(heapq.heappop(heap))
​
​
​
​
​
if __name__=='__main__':
    pd_queue

2.4 树

2.4.1 概念和术语

模拟树结构

将组织架构里的数据移除, 抽象出来结构, 那么就是我们要学习的树结构

术语

树的结构：

树的定义:

  • 树（Tree）: n（n≥0）个结点构成的有限集合。

    • 当n=0时，称为空树；

    • 对于任一棵非空树（n> 0），它具备以下性质：

    • 树中有一个称为“根（Root）”的特殊结点，用 root 表示；

    • 其余结点可分为m(m>0)个互不相交的有限集T1，T2，... ，Tm，其中每个集合本身又是一棵树，称为原来树的“子树（SubTree）”

    注意:

    • 子树之间不可以相交

    • 除了根结点外，每个结点有且仅有一个父结点；

    • 一棵N个结点的树有N-1条边。

树的术语:

  • 1.结点的度（Degree）：该结点的拥有的子节点数量。

  • 2.树的度：树的所有结点中最大的度数. (树的度通常为结点的个数N-1)

  • 3.叶子结点（Leaf）：度为0的结点. (也称为叶子结点)

  • 4.父结点（Parent）：有子树的结点是其子树的根结点的父结点

  • 5.子结点（Child）：若A结点是B结点的父结点，则称B结点是A结点的子结点；子结点也称孩子结点。

  • 6.兄弟结点（Sibling）：具有同一父结点的各结点彼此是兄弟结点。

  • 7.路径和路径长度：从结点n1到nk的路径为一个结点序列n1 , n2,… , nk, ni是 ni+1的父结点。路径所包含边的个数为路径的长度。

  • 8.结点的层次（Level）：规定根结点在1层，其它任一结点的层数是其父结点的层数加1。

  • 9.树的深度（Depth）：树中所有结点中的最大层次是这棵树的深度。

2.4.2 二叉树
2.4.2.1 概念

二叉树的定义

  • 二叉树可以为空, 也就是没有结点.

  • 若不为空，则它是由根结点和称为其左子树TL和右子树TR的两个不相交的二叉树组成。

二叉树有五种形态:

  • 注意c和d是不同的二叉树, 因为二叉树是有左右之分的.

2.4.2.2 特性

  • 二叉树有几个比较重要的特性, 在笔试题中比较常见:

    • 一个二叉树第 i 层的最大结点数为：2^(i-1), i >= 1;

    • 深度为k的二叉树有最大结点总数为： 2^k - 1, k >= 1;

    • 对任何非空二叉树 T，若n0表示叶结点的个数、n2是度为2的非叶结点个数，那么两者满足关系n0 = n2 + 1。

2.4.2.3 特殊的二叉树

满二叉树(Full Binary Tree）

  • 在二叉树中, 除了最下一层的叶结点外, 每层节点都有2个子结点, 就构成了满二叉树.

完全二叉树(Complete Binary Tree)

  • 除二叉树最后一层外, 其他各层的节点数都达到最大个数.

  • 且最后一层从左向右的叶结点连续存在, 只缺右侧若干节点.

  • 满二叉树是特殊的完全二叉树.

  • 下面不是完全二叉树, 因为D节点还没有右结点, 但是E节点就有了左右节点.

2.4.2.4 二叉树的存储

二叉树的存储常见的方式是链表.

链表存储:

  • 二叉树最常见的方式还是使用链表存储.

  • 每个结点封装成一个Node, Node中包含存储的数据, 左结点的引用, 右结点的引用.

2.4.2.5 二叉树遍历

前序遍历（Pre-order Traversal）、中序遍历（In-order Traversal）和后序遍历（Post-order Traversal）是二叉树的三种基本遍历方式。

遍历规则：

前序遍历，按照以下顺序访问节点：根节点、左子树、右子树。

中序遍历，按照以下顺序访问节点：左子树、根节点、右子树。

后序遍历，按照以下顺序访问节点：左子树、右子树、根节点。

2.4.3 二叉查找树

二叉查找树（Binary Search Tree, BST）是一种特殊的二叉树，它具有以下性质：

  1. 每个节点都有一个键值（key）。

  2. 对于每个节点，其左子树中的所有节点的键值都小于该节点的键值。

  3. 对于每个节点，其右子树中的所有节点的键值都大于该节点的键值。

  4. 左子树和右子树也分别是二叉查找树。

  5. 二叉查找树不允许出现键值相等的结点。

二叉查找树的主要操作包括插入、删除和遍历。代码实现如下：

2.4.3.1 创建二叉查找树节点
class TreeNode:
    def __init__(self, key):
        self.key = key
        self.left = None
        self.right = None

  • key: 节点的键值。

  • left: 指向左子节点的指针。

  • right: 指向右子节点的指针。

2.4.3.2 创建二叉查找树类
class BinarySearchTree:
    def __init__(self):
        self.root = None

  • root: 指向二叉搜索树的根节点。初始时为 None。

2.4.3.3 插入节点

插入操作的步骤：

  1. 如果树为空：直接将新节点作为根节点。

  2. 如果树不为空：

    • 从根节点开始，根据新节点的键值与当前节点的键值的比较结果，决定向左子树还是右子树移动。

    • 如果新节点的键值小于当前节点的键值，如果当前节点没有左子树，则将新节点插入到当前节点的左子树，否则向左子树移动。

    • 如果新节点的键值大于当前节点的键值，如果当前节点没有右子树，则将新节点插入到当前节点的右子树，否则向右子树移动。

    • 重复上述步骤，直到找到一个空位置，将新节点插入到该位置。

def insert(self, key):
    if self.root is None:
        self.root = TreeNode(key)
    else:
        self._insert(self.root, key)
​
def _insert(self, node, key):
    if key < node.key:
        if node.left is None:
            node.left = TreeNode(key)
        else:
            self._insert(node.left, key)
    elif key > node.key:
        if node.right is None:
            node.right = TreeNode(key)
        else:
            self._insert(node.right, key)

  • insert(key): 公开的插入方法。如果树为空，则创建一个新节点作为根节点；否则，调用 _insert 方法进行递归插入。

  • _insert(node, key): 递归插入方法。根据键值的大小，递归地在左子树或右子树中插入新节点。

2.4.3.4 查找节点
def search(self, key):
    return self._search(self.root, key)
​
def _search(self, node, key):
    if node is None or node.key == key:
        return node
    if key < node.key:
        return self._search(node.left, key)
    return self._search(node.right, key)
2.4.3.5 删除节点

删除逻辑：

1.递归查找待删除节点

  • 如果待删除节点的键值小于当前节点的键值，递归地在左子树中查找并删除。

  • 如果待删除节点的键值大于当前节点的键值，递归地在右子树中查找并删除。

2.找到待删除节点

删除操作的步骤可以分为以下几种情况：

  1. 待删除节点是叶子节点（没有子节点）：直接删除该节点。

  2. 待删除节点只有一个子节点：用其子节点替换该节点。

  3. 待删除节点有两个子节点：

    • 找到右子树中的最小节点（即后继节点）。

    • 用后继节点的键值替换待删除节点的键值。

    • 删除后继节点（后继节点要么是叶子节点，要么只有一个右子节点）。

假设我们有以下二叉搜索树：

        50
       /  \
     30    70
    /  \  /  \
  20  40 60  80

删除节点 20

  1. 找到键值为 20 的节点。

  2. 该节点是叶子节点，直接删除。

删除后的树：

        50
       /  \
     30    70
       \  /  \
       40 60  80

删除节点 30

  1. 找到键值为 30 的节点。

  2. 该节点有一个右子节点 40，用 40 替换 30。

删除后的树：

        50
       /  \
     40    70
          /  \
         60  80

删除节点 50

  1. 找到键值为 50 的节点。

  2. 该节点有两个子节点，找到右子树中的最小节点 60（即后继节点）。

  3. 用 60 替换 50。

  4. 删除右子树中的 60。

删除后的树：

        60
       /  \
     40    70
             \
             80
def delete(self, key):
    self.root = self._delete(self.root, key)
​
def _delete(self, node, key):
    if node is None:
        return node
​
    if key < node.key:
        node.left = self._delete(node.left, key)
    elif key > node.key:
        node.right = self._delete(node.right, key)
    else:
        # 找到要删除的节点
        # 情况 1: 节点是叶子节点
        if node.left is None and node.right is None:
            return None
        # 情况 2: 节点只有一个子节点
        elif node.left is None:
            return node.right
        elif node.right is None:
            return node.left
        # 情况 3: 节点有两个子节点
        temp = self._min_value_node(node.right)
        node.key = temp.key
        node.right = self._delete(node.right, temp.key)
​
    return node
​
def _min_value_node(self, node):
    current = node
    while current.left is not None:
        current = current.left
    return current
2.4.3.6 中序遍历

先遍历左子树，然后访问当前节点，最后遍历右子树。

def inorder_traversal(self):
    result = []
    self._inorder_traversal(self.root, result)
    return result
​
def _inorder_traversal(self, node, result):
    if node:
        self._inorder_traversal(node.left, result)
        result.append(node.key)
        self._inorder_traversal(node.right, result)
2.4.3.7 前序遍历

先访问根节点、然后遍历左子树、最后遍历右子树。

def preorder_search(self):
    result = []
    if self.root is None:
        return None
    self._preorder_search(self.root, result)
    return result
​
def _preorder_search(self,node,result):
    if node is None:
        return None
    result.append(node.key)
    self._preorder_search(node.left,result)
    self._preorder_search(node.right,result)
    
    
# 后序遍历，按照以下顺序访问节点：左子树、右子树、根节点。
    def _behind_search(self, node, result):
        if node:
            self._behind_search(node.left, result)
            self._behind_search(node.right, result)
            result.append(node.key)
​
    def remove(self,key):
        if self.root is None:
            return None
        self.root=self._remove(self.root,key)
   
​
     
​
class TreeNode:
    def __init__(self,key):
        self.key=key
        self.left=None
        self.right=None
​
class BST:
    def __init__(self):
        self.root=None
​
    def insert(self,key):
        #判断树是否为空，是则将新节点赋给根节点
        if self.root is None:
            self.root=TreeNode(key)
        else:
            self._insert(self.root,key)
​
​
    def _insert(self,node,key):
        #如果要插入的键值小于当前节点的键值，则判断当前节点是否有左子树，没有则将新节点赋给当前节点的左子树，
        #有则继续向当前节点的左子树移动，递归插入
        if key<node.key:
            if node.left is None:
                node.left=TreeNode(key)
            else:
                #node.left：当前节点的左子树节点
                self._insert(node.left,key)
        #如果要插入的键值大于当前节点的键值，则判断当前节点是否有右子树，没有则将新节点插入到当前节点的右子树
        #有则继续向当前节点的右子树移动，递归插入
        else:
            if node.right is None:
                node.right=TreeNode(key)
            else:
                self._insert(node.right,key)
​
    def inorder_search(self):
        result=[ ]
        self._inorder_search(self.root,result)
        return result
    #中序遍历：左子树、根、右子树
    def _inorder_search(self,node,result):
        if node:
            self._inorder_search(node.left,result)
            result.append(node.key)
            self._inorder_search(node.right,result)
​
    def frontorder_search(self):
        result=[ ]
        if self.root is None:
            return None
        self._front_search(self.root,result)
        return result
​
    # 前序遍历，按照以下顺序访问节点：根节点、左子树、右子树。
    def _front_search(self, node, result):
        if node is None:
            return None
        else:
            result.append(node.key)
            self._front_search(node.left, result)
            self._front_search(node.right, result)
​
    def behindorder_search(self):
        result=[ ]
        self._behind_search(self.root,result)
        return result
​
    # 后序遍历，按照以下顺序访问节点：左子树、右子树、根节点。
    def _behind_search(self, node, result):
        if node:
            self._behind_search(node.left, result)
            self._behind_search(node.right, result)
            result.append(node.key)
​
    def remove(self,key):
        if self.root is None:
            return None
        self.root=self._remove(self.root,key)
​
    def _remove(self,node,key):
        #如果树为空，则返回None
        if node is None:
            return None
        #判断指定的key和当前节点的key的大小，如果指定key小于当前节点的key，则递归遍历左子树
        #如果指定key大于当前节点的key，则递归遍历右子树
        if key <node.key:
            node.left=self._remove(node.left,key)
        elif key >node.key:
            node.right=self._remove(node.right,key)
        #指定key等于当前节点的key：
        #1.当前节点没有子节点，则直接删除，返回None
        #2.当前节点有一个子节点，1）.有右子节点，则用右子节点替换当前节点；2）.有左子结点，则用左子结点替换当前节点
        #3.当前节点有两个子节点：查找当前节点右子树的左子树，找到最小值，用最小值节点替换当前节点，删除最小值节点
        else:
            #如果当前节点左右子树都为空则返回None
            if node.left is None and node.right is None:
                return None
            #如果当前节点只有一个子树，如果左子树为空，则返回右子树节点；如果右子树节点为空，则返回左子树节点
            elif node.left is None:
                return node.right
            elif node.right is None:
                return node.left
            #如果当前节点有两个子树，则查询当前节点右子树的左子树，找到最小值节点
            #将最小值替换到当前节点
            #将最小值节点递归删除
            else:
                temp=self._min_value_node(node.right)
                node.key=temp.key
                #以当前节点的右子树节点为根节点，删除最小值节点
                node.right=self._remove(node.right,temp.key)
​
        return node
    #查找当前节点的最小值，最小值在当前节点的左子树中
    def _min_value_node(self,node):
        while node.left is not None:
            node=node.left
        return node
​
​
​
​
​
​
if __name__=='__main__':
    bst=BST()
    bst.insert(5)
    bst.insert(8)
    bst.insert(3)
    bst.insert(2)
    bst.insert(7)
    bst.insert(4)
​
​
    result=bst.inorder_search()
    print(result)
    result1 = bst.frontorder_search()
    print(result1)
    result2 = bst.behindorder_search()
    print(result2)
​
    # bst.remove(4)
    # result=bst.inorder_search()
    # print(result)
​
​
​

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

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

相关文章

Element Plus在Vue3的安装

Element Plus在Vue3的安装

本来想下载element ui 的&#xff0c;但是不支持报错了 所以我们使用element plus 在终端使用下命令下载 npm install element-plus --save 然后就可以在package.json里面看到所下载的版本号了 之后在main.js中根据自己的的情况配置Element-Plus // main.ts import { create…
阅读更多...
App Inventor 2 列表显示框能否实现多选？

App Inventor 2 列表显示框能否实现多选？

Q&#xff1a;列表显示框有没有办法做到多选的功能&#xff1f; // 问题分析 // AppInventor2列表显示框原生并没有多选功能&#xff0c;只能点击其中一项&#xff0c;然后触发“选择完成时”这个事件&#xff0c;那么有没有办法做到多选呢&#xff1f; // 问题思路 // 经过…
阅读更多...
Topaz Video AI for Mac 视频无损放大软件安装教程【保姆级，操作简单轻松上手】

Topaz Video AI for Mac 视频无损放大软件安装教程【保姆级，操作简单轻松上手】

Mac分享吧 文章目录 Topaz Video AI for Mac 视频无损放大软件 安装完成&#xff0c;软件打开效果一、Topaz Video AI 视频无损放大软件 Mac电脑版——v5.3.5⚠️注意事项&#xff1a;1️⃣&#xff1a;下载软件2️⃣&#xff1a;安装软件&#xff0c;将安装包从左侧拖入右侧文…
阅读更多...
Linux基础—基础命令及相关知识5(ubuntu网络配置)

Linux基础—基础命令及相关知识5(ubuntu网络配置)

网络的配置方法 centos网络配置 centos的网卡位置 /etc/sysconfig/network-scripts/ifcfg-ens33(centos网卡文件) bootproto表示获得IP地址的方式是静态的还是动态 onboot表示启动系统时是否激活该网络接口 设置IP地址&#xff0c;子网掩码&#xff0c;网关&#xff0c;dns…
阅读更多...
数据分析与效果评估的有效方法与实践探讨

数据分析与效果评估的有效方法与实践探讨

内容概要 在现代社会中&#xff0c;数据分析与效果评估已成为各类项目管理和决策制定中的重要组成部分。首先&#xff0c;数据分析为我们提供了一种系统化的方法&#xff0c;以深入了解所收集数据的内涵与趋势。通过对数据进行整理、分类和分析&#xff0c;我们能够发现潜在的…
阅读更多...
一篇文章入门傅里叶变换

一篇文章入门傅里叶变换

文章目录 傅里叶变换欧拉公式傅里叶变换绕圈记录法质心记录法傅里叶变换公式第一步&#xff1a;旋转的表示第二步&#xff1a;缠绕的表示第三步&#xff1a;质心的表示最终步&#xff1a;整理积分限和系数 参考文献 傅里叶变换 在学习傅里叶变换之前&#xff0c;我们先来了解一…
阅读更多...
电源完整性

电源完整性

电源分配系统 电源分配系统:Power Distribution Network(简称 PDN) 真正用电节点在 Die&#xff0c;所以PDN系统包含 PCB 和 Package上的部分 PCB 上:VRM、大电容、小电容、电源平面、地平面 Package内:电容、电源平面、地平面 电源噪声的产生 稳压电源芯片本身的输出不恒定&a…
阅读更多...
Springboot 日志处理

Springboot 日志处理

一、日志存入数据库&#xff08;AOP&#xff09; 1.引入aop依赖 <!-- aop依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 2.创建aop包&#…
阅读更多...
SpringBoot3使用MyBatisPlus时遇到的问题 Invalid bean definition with name

SpringBoot3使用MyBatisPlus时遇到的问题 Invalid bean definition with name

问题&#xff1a; 运行springboot3项目报错&#xff1a;Invalid bean definition with name ‘XXXMapper’ defined in file… 原因&#xff1a;springboot3支持的mabits-plus依赖不同导致的 解决办法&#xff1a; 修改为&#xff1a; <dependency><groupId>com…
阅读更多...
Chrome和Firefox哪款浏览器的密码管理更安全

Chrome和Firefox哪款浏览器的密码管理更安全

在当今数字化时代&#xff0c;浏览器已成为我们日常生活中不可或缺的工具。其中&#xff0c;谷歌Chrome和Mozilla Firefox是两款广受欢迎的浏览器。除了浏览网页外&#xff0c;它们还提供了密码管理功能&#xff0c;帮助用户保存和管理登录凭证。然而&#xff0c;关于哪款浏览器…
阅读更多...
大数据新视界 -- 大数据大厂之大数据重塑影视娱乐产业的未来（4 - 4）

大数据新视界 -- 大数据大厂之大数据重塑影视娱乐产业的未来（4 - 4）

&#x1f496;&#x1f496;&#x1f496;亲爱的朋友们&#xff0c;热烈欢迎你们来到 青云交的博客&#xff01;能与你们在此邂逅&#xff0c;我满心欢喜&#xff0c;深感无比荣幸。在这个瞬息万变的时代&#xff0c;我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而 我的…
阅读更多...
Mac安装Ruby

Mac安装Ruby

Mac 安装 Ruby 1. 介绍 Ruby 是一种简洁优雅、功能强大的编程语言。在 20 世纪 90 年代中期由日本的松本行弘&#xff08;まつもとゆきひろ/Yukihiro Matsumoto&#xff09;设计并开发。它具有简洁的语法、动态类型、完全面向对象和强大的元编程能力等特点。广泛应用于 Web 开…
阅读更多...
Docker部署MySQL双主双从，主主互备

Docker部署MySQL双主双从，主主互备

1. 双主双从 主主互备 MySQL的双主双从（主主互备）架构是一种高可用性和负载均衡的解决方案，它由两台主数据库服务器和两台从数据库服务器组成。每台主服务器同时充当另一台主服务器的从服务器，形成一个互为主从的关系。这种架构可以提供以下优势： 高可用性：任何一台主服…
阅读更多...
【算法】反转字符串中的单词、奇数在偶数后

【算法】反转字符串中的单词、奇数在偶数后

目录 奇数在偶数后 解法一&#xff1a;双指针 复杂度 解法二&#xff1a;插入排序思想 复杂度 反转字符串中的单词 解法一&#xff1a;栈 复杂度 解法二&#xff1a;双指针 复杂度 奇数在偶数后 题目描述&#xff1a; 输入一个整数数组&#xff0c;实现一个接口来调…
阅读更多...
江协科技STM32学习- P21 ADC模数转换器

江协科技STM32学习- P21 ADC模数转换器

&#x1f680;write in front&#x1f680; &#x1f50e;大家好&#xff0c;我是黄桃罐头&#xff0c;希望你看完之后&#xff0c;能对你有所帮助&#xff0c;不足请指正&#xff01;共同学习交流 &#x1f381;欢迎各位→点赞&#x1f44d; 收藏⭐️ 留言&#x1f4dd;​…
阅读更多...
GPT避坑指南：如何辨别逆向、AZ、OpenAI官转

GPT避坑指南：如何辨别逆向、AZ、OpenAI官转

市面上有些说自己是官转&#xff0c;一刀只需要1块甚至几毛钱&#xff0c;并声称官方倍率的&#xff0c;很大可能就是使用的是 逆向或Azure。 如何鉴别逆向 逆向的种类很多&#xff0c;主要分为3类 逆向不知名A| 镜像站或偷的 key。成本约等于0&#xff0c;调用聊天数据可能在…
阅读更多...
Rust 力扣 - 48. 旋转图像

Rust 力扣 - 48. 旋转图像

文章目录 题目描述题解思路题解代码题解链接 题目描述 题解思路 我们可以将原矩阵进行水平翻转&#xff0c;然后在沿主对角线进行翻转&#xff0c;就能完成原矩阵沿顺时针方向旋转90o的变换 题解代码 impl Solution {pub fn rotate(matrix: &mut Vec<Vec<i32>&…
阅读更多...
Depcheck——专门用于检测 JavaScript 和 Node.js 项目中未使用依赖项的工具

Depcheck——专门用于检测 JavaScript 和 Node.js 项目中未使用依赖项的工具

文章目录 Depcheck 是什麽核心功能&#x1f4da;检测未使用的依赖&#x1f41b;检测缺失的依赖✨支持多种文件类型&#x1f30d;可扩展性 安装与使用1. 安装 Depcheck2. 使用 Depcheck Depcheck 的应用总结项目源码&#xff1a; Depcheck 是什麽 来看一个常见错误场景&#x1…
阅读更多...
微信小程序时间弹窗——年月日时分

微信小程序时间弹窗——年月日时分

需求 1、默认当前时间2、选择时间弹窗限制最大值、最小值3、每次弹起更新最大值为当前时间&#xff0c;默认值为上次选中时间4、 minDate: new Date(2023, 10, 1).getTime(),也可以传入时间字符串new Date(2023-10-1 12:22).getTime() html <view class"flex bb ptb…
阅读更多...
ffmpeg视频滤镜：膨胀操作-dilation

ffmpeg视频滤镜：膨胀操作-dilation

滤镜介绍 dilation 官网链接 > FFmpeg Filters Documentation 膨胀滤镜会使图片变的更亮&#xff0c;会让细节别的更明显。膨胀也是形态学中的一种操作&#xff0c;在opencv中也有响应的算子。此外膨胀结合此前腐蚀操作&#xff0c;可以构成开闭操作。 开操作是先腐蚀…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023