java数据结构YZP专栏-----二叉树 && 二叉搜索树(二叉排序树,BST)

Teamcenter Java SOA 开发:连接、查询与保存 本文介绍如何通过 Java 调用 Teamcenter SOA 接口实现外部系统对接,涵盖连接登录、查询保存等核心操作。以最小闭环示例展示 Connection、Service、ModelObject 等关键组件的使用,强调错误处理与事务管理要点。梳理了 DataManagement、Query、File Management 等 API 模块分工,并结合“工作移交WebService”案例,说明幂等性设计与流程状态返回的重要性。适用于 Web 门户、ERP 集成等场景,建议批量操作用 bulk 接口优化性 阅读详情
主文章(数据结构的索引目录—进不去就说明我还没写完)
https://blog.youkuaiyun.com/grd_java/article/details/122377505
模拟数据结构的网站:https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
源码(码云):https://gitee.com/yin_zhipeng/data_structures_and_algorithms_in_java.git
二叉搜索树动画演示

请添加图片描述

二叉树

就是一个看起来像一颗树的逻辑内存结构。由很多个结点(节点)组成,但是二叉树规定每个结点最多有两个子结点(两个分叉)
在这里插入图片描述

  1. 根结点:理解为树的根,树的入口,我们必须从根结点,才能找到其它结点
  2. 父结点:当前结点的父结点,比如图中A是B,C的父结点,C是F,G的父结点
  3. 子结点:就是当前结点的子结点,比如C和B是A的子结点
  4. 叶子结点:没有子结点的结点,比如H,E,F,G
  5. 路径:从根结点找到特定结点的路径
  6. 结点权:结点的额外值,有些情况下我们需要对比结点的权值,以判断开销最小的带权路径。
  7. 层(深度):树的层数,根结点自己算一层,如果它有子结点,子结点算一层,以此类推
  8. 树的高度:共有多少层
  9. 子树:上图中,A是整个二叉树,B是A的左子树,因为B结点是D、H、E结点的根结点。
  10. 森林:有多颗树,就是森林。
  11. 度:表示当前结点是一个什么样的结点。度可以看作结点间的连线。0度,代表这个结点没有子结点,也就是叶子结点。1度,代表这个结点又左或右子树。2度,表示这个结点同时有左右两颗子树
重要的二叉树概念(做题必备特性)

1. 第i层最多有2i-1个结点
2. 二叉树层数为n时,此二叉树最多有2n-1个结点(因为根结点是1个,自己算一层)
3. 叶子结点数为a个,度为2的结点数为b个。则a = b+1,也就是说,叶子结点,永远比度为2的结点多一个

在这里插入图片描述

  1. 满二叉树:除了叶子结点外,其它结点的度都为2。也就是除了最后一层的叶子结点,其它结点都有2个子结点
  1. 结点个数为(2^n)-1(n为层数,2的n次方,减一)
  2. 因为满二叉树,每一层都填满了(连续),所以满二叉树中第 i 层的节点数为 2n-1 个
  3. 深度为 k 的满二叉树必有 2k-1 个节点 ,叶子数为 2k-1
  4. 满二叉树中不存在度为 1 的节点,每一个分支点中都两棵深度相同的子树,且叶子节点都在最底层
  5. 具有 n 个节点的满二叉树的深度为 log2(n+1)----(对数公式都回吧?ax = N,x = logaN)---- 可以算出深度
  1. 完全二叉树:二叉树所有叶子结点,都在倒数第一和倒数第二层。倒数第一层叶子结点左边连续(值不用连续,就是不能缺一块,比如下图14没有左节点81,那么就缺了一块,不是完全二叉树了),倒数第二层叶子结点右边连续。
  1. 注意和满二叉树区分,如果二叉树中除去最后一层节点为满二叉树,且最后一层的结点依次从左到右分布,则此二叉树被称为完全二叉树。
    在这里插入图片描述
  2. X个结点的完全二叉树,深度为(log2X)+1
  3. 第X个元素(X表示二叉树的第几个元素,从0开始)的左子节点为2X+1,右子节点为2X+2,父节点为(X-1)/2.
  4. 总结点个数为total,当前结点下标为X,如果2X>total,则结点没有左子树,否则左子结点为2X,同理,2X+1>total,没有右子树否则2X+1是右子树
  1. 前序遍历:先输出父节点,再遍历左子树和右子树
  2. 中序遍历:先遍历左子树,再输出父节点,再遍历右子树
  3. 后序遍历:先遍历左子树,再遍历右子树,最后输出父节点
如果看不懂上面满二叉树和完全二叉树的区别,可以往下看

在这里插入图片描述

  1. 仔细看满二叉树的编号,数字是一直连续的。它也是一棵完全二叉树。
  2. 而下面的完全二叉树,编号也要连续,并且同一个结点的编号和满二叉树一模一样,这就是完全二叉树。也就是编号连续,并且编号相同的结点和满二叉树相同。但是它的结点个数可能比满二叉树少。
  3. 因此说,满二叉树一定是完全二叉树,但是完全二叉树不一定是满二叉树。因为只要编号是连续的,同一个编号的结点和满二叉树相同,就可以称为是完全二叉树。
  4. 完全二叉树很重要,因为它可以无压力的表示在数组中,因为编号连续(下标)
二叉搜索树(二叉排序树,BST)

二叉树的一种,保留二叉树的概念和每个结点最多两个子结点的特性。但是二叉搜索树有特别的额外规定

  1. 每个结点的左子结点,要比当前结点小,也就是左子树都是更小的
  2. 每个结点的右子结点,要比当前结点大,右子树都是更大的

二叉搜索树的代码实现如下:

  1. 效果
    在这里插入图片描述
  2. 测试方法:我们想让这颗二叉树,能通过泛型,不局限与特定一种数据类型。所以需要用户根据自己使用的数据类型,自定义排序逻辑
    在这里插入图片描述
  3. 树节点
    在这里插入图片描述
  4. 添加结点操作
    在这里插入图片描述
  5. 中序查找和中序遍历,前序和后序,就是代码位置发生了变化而已
    在这里插入图片描述
  6. 删除:分为删除根结点和删除非根结点两种,删除根结点要在二叉树中,非根结点就在树结点类中完成。比较复杂的是,删除结点后,被删除结点的子树如何处理。具体大家直接看代码吧(代码在下面给出),图片这里就理一下逻辑。
    在这里插入图片描述
二叉搜索树
package com.yzpnb.data_structures.tree.binary_search_tree;

import java.util.Comparator;

/**
 * 二叉搜索树
 * 泛用式:使用泛型。泛型无法直接比较,通过用户自定义Comparator实现来进行节点大小比较
 */
public class BinarySearchTree<E> {
    //静态内部类,二叉树结点
    private static class TreeNode<E> {
        TreeNode<E> leftNode;//左子节点,左子树
        E data;//数据域
        TreeNode<E> rightNode;//右子节点,右子树
        //构造方法
        TreeNode(TreeNode<E> leftNode,E data,TreeNode<E> rightNode){
            this.leftNode = leftNode;
            this.data = data;
            this.rightNode = rightNode;
        }
        /**增====需要传入比较规则Comparator,因为我们是泛型。**/
        //根据data元素添加
        public void add(E e, Comparator<? super E> c){
            //compare(o1,o2)正数表示o2>o1,0表示o1=o2,负数表示o2小于o1
            if(c.compare(e,data)>=0){//如果要插入的元素,比如当前结点小,就插入左子树
                //如果当前结点没有左子树,就直接让它当左子树
                if(leftNode == null) leftNode = new TreeNode<E>(null,e,null);
                else leftNode.add(e,c);//否则去左子树继续判断
            }else{//如果比当前结点大,或者和当前结点一样,就插到右子树
                //如果当前结点没有左子树,就直接让它当左子树
                if(rightNode == null) rightNode = new TreeNode<E>(null,e,null);
                else rightNode.add(e,c);//否则去左子树继续判断
            }
        }
        //直接添加结点,代码重复,可以优化
        void add(TreeNode<E> e, Comparator<? super E> c){
            //compare(o1,o2)正数表示o2>o1,0表示o1=o2,负数表示o2小于o1
            if(c.compare(e.data,data)>=0){//如果要插入的元素,比如当前结点小,就插入左子树
                //如果当前结点没有左子树,就直接让它当左子树
                if(leftNode == null) leftNode = e;
                else leftNode.add(e,c);//否则去左子树继续判断
            }else{//如果比当前结点大,或者和当前结点一样,就插到右子树
                //如果当前结点没有左子树,就直接让它当左子树
                if(rightNode == null) rightNode = e;
                else rightNode.add(e,c);//否则去左子树继续判断
            }
        }
        /**删====删除指定非root元素===如果有多个,就删除第一个遇见的,根据要删除的父节点删除。**/
        //如果删除的元素,有左右子节点,就先让左子树上移,然后将右子树添加进入
        public TreeNode<E> deleteOne(E e,Comparator<? super E> c){
            TreeNode<E> parent = null;//为了代码阅读性而定义,要删除结点的父节点
            TreeNode<E> deleted = null;//被删除的节点
            if(leftNode != null){//如果有左子树
                if(leftNode.data.equals(e)){//如果左子节点,恰好是要删除的元素
                    parent = this;//父节点
                    //删除结点,删除结点是父节点的左子树
                    deleted = doDeleteOne(parent,parent.leftNode,true,c);
                    return deleted;//返回被删除结点
                }else{//如果不是左子结点,继续遍历
                    deleted = leftNode.deleteOne(e,c);
                }
            }
            //在左子树找到,直接return,结束递归
            if(deleted != null) return deleted;
            //否则用同样的逻辑找右子树
            if(rightNode != null){
                if(rightNode.data.equals(e)){
                    parent = this;
                    deleted = doDeleteOne(parent,parent.rightNode,false,c);
                    return deleted;
                }else{
                    deleted = rightNode.deleteOne(e,c);
                }
            }
            return deleted;
        }

        /**
         * 负责删除逻辑
         * @param parent 要删除结点的父节点
         * @param deleted 被删除结点
         * @param leftOrRight true表示deleted是parent的leftNode。false表示deleted是parent的rightNode
         * @param c 比较器
         * @return deleted
         */
        public TreeNode<E> doDeleteOne(TreeNode<E> parent,TreeNode<E> deleted,boolean leftOrRight,Comparator<? super E> c){
            //被删除结点
            TreeNode<E> left = deleted.leftNode;//被删除结点的左子树
            TreeNode<E> right = deleted.rightNode;
            //结点反转
            if(leftOrRight){//删除的是parent的左子节点
                parent.leftNode = left; //直接让parent的leftNode指向deleted的左子树
                if(right != null)//如果deleted有右子树
                    parent.add(right,c);//按照逻辑将其插入
            }else{
                parent.rightNode = left;
                if(right != null)
                    parent.add(right,c);
            }
            return deleted;
        }

        /**改====查到指定元素,然后直接改就行**/
        /**查**/
        //中序查找指定元素,先走左,再走当前结点,再走右
        public TreeNode<E> midFind(E e) {
            TreeNode<E> node = null;//用来保存最终结果
            if(leftNode!=null)//如果有左子树,先走左
                node = leftNode.midFind(e);
            //左子树遍历完成
            //判断在左子树是否找到了目标
            if(node != null) return node;
            //没找着就判断当前结点是不是
            if(data.equals(e))
                return this;
            //不是就找右子树
            if(rightNode!=null)
                node = rightNode.midFind(e);
            return node;
        }
        /**遍历**/
        //中序遍历
        public void midPrint() {
            if(leftNode != null) leftNode.midPrint();//先遍历左子树
            System.out.print(" ,"+this);//然后输出自己
            if(rightNode!=null) rightNode.midPrint();//遍历右子树
        }
        @Override
        public String toString() {
            return "TreeNode{" +
                    "data=" + data +
                    '}';
        }
    }
    private TreeNode<E> root;//根结点
    Comparator<? super E> c;
    //构造二叉搜索树
    public BinarySearchTree(Comparator<? super E> c){
        this.c = c;
    }//可以初始不指定根结点
    public BinarySearchTree(TreeNode<E> root,Comparator<? super E> c) {//可以初始化指定root
        this.root = root;
        this.c = c;
    }
    //判断二叉树是否为空
    public boolean isEmpty(){
        return root==null?true:false;
    }
    //如果为空,提示用户
    public boolean isEmptyError(){
        if(isEmpty()) {
            System.out.println("树为空,无法操作!!!");
            return true;
        }else{
            return false;
        }
    }
    /**增====需要传入比较规则Comparator,因为我们是泛型。**/
    //从根结点开始查找正确的插入位置,满足小的在左边,大的在右边,正确的插入位置应该是,找到满足条件且没有子节点的节点,然后当前要插入的节点,成为它的子节点
    public E addNode(E data){
        if(isEmpty()) //如果没有根结点,让新插入的成为根结点。
            root = new TreeNode<>(null,data,null);
        else {
            root.add(data,c);
        }
        return data;
    }
    /**删**/
    public TreeNode<E> deleteOne(E e){
        if(!isEmptyError()) {
            TreeNode<E> deleted = null;
            if(e.equals(root.data)){//根结点需要特殊删除
                deleted = root;
                TreeNode<E> left = root.leftNode,right = root.rightNode;
                if(left != null) {
                    root = left;
                    if(right != null)
                        root.add(right,c);
                }
                else
                    root = right;
            }else{//删除的是非根结点
                deleted = root.deleteOne(e,c);
            }

            if(deleted == null){
                System.out.println("没有找到要删除的节点!!!");
                return deleted;
            }
            return deleted;
        }
        return null;
    }
    /**改====查到指定元素,然后直接改就行**/
    /**查**/
    //中序查找指定元素,先走左,再走当前结点,再走右
    public TreeNode<E> midFind(E e){
        if(!isEmptyError()) {
            TreeNode<E> node = root.midFind(e);
            if( node == null) System.out.println("没找着!!!");
            return node;
        }
        return null;
    }
    /**遍历**/
    //中序遍历先走左,再走当前结点,再走右
    public void midPrint(){
        if(isEmptyError()) return ;
        System.out.print("中序遍历:{");
        root.midPrint();
        System.out.println("}");
    }

}
测试类
package com.yzpnb.data_structures.tree.binary_search_tree;

import java.util.Comparator;

public class Test {
    public static void main(String[] args) {
        BinarySearchTree<String> binarySearchTree = new BinarySearchTree<>(new Comparator<String>() {
            //正数表示o2>o1,0表示o1=o2,负数表示o2小于o1
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        binarySearchTree.addNode("7");
        binarySearchTree.addNode("4");
        binarySearchTree.addNode("5");
        binarySearchTree.addNode("3");
        binarySearchTree.addNode("3");
        binarySearchTree.addNode("7");
        binarySearchTree.addNode("2");
        binarySearchTree.addNode("1");
        binarySearchTree.addNode("3");
        binarySearchTree.midPrint();//中序遍历
        System.out.println("返回data为7的节点:"+binarySearchTree.midFind("7"));
        System.out.println("删除data为7的节点"+binarySearchTree.deleteOne("7"));
        binarySearchTree.midPrint();
        System.out.println("删除data为7的节点"+binarySearchTree.deleteOne("7"));
        binarySearchTree.midPrint();
        System.out.println("删除data为4的节点"+binarySearchTree.deleteOne("4"));
        binarySearchTree.midPrint();
        System.out.println("删除data为3的节点"+binarySearchTree.deleteOne("3"));
        binarySearchTree.midPrint();
        System.out.println("删除data为1的节点"+binarySearchTree.deleteOne("1"));
        binarySearchTree.midPrint();
    }
}

SpringBoot+Vue+MySQL 高校学科竞赛平台 完整可运行版(源码+文档) 本项目基于SpringBoot+Vue+MySQL构建高校学科竞赛管理平台,覆盖学生、教师、领队教师、管理员四大角色,实现竞赛发布、报名、刷题、评分、公示等全流程闭环管理。系统架构清晰,技术主流,配套完整源码、数据库脚本、万字论文、开题报告、答辩PPT及部署文档,支持一键运行,适用于毕业设计、课程设计及院系二次开发,真正实现“开箱即用”。 阅读详情

相关推荐

国产射频直采收发器CX8242KA测试1

CX8242KA/CX8242KAN是一款集成了14比特,12 GSPSDAC和14比特,3GSPSADC的双通道,宽带、射频直采收发器芯片,该器件支持高达6GHz射频信号的直接采样输入和输出,集成了片内高性能采样钟模块,采样时钟Jitter

RFSOC的博客 9169

InnoDB 内存结构总览:Change Buffer、AHI 与 Log Buffer

本文系统梳理InnoDB内存结构中的ChangeBuffer、Adaptive Hash Index(AHI)与LogBuffer。ChangeBuffer缓存二级索引页不在内存时的变更,减少随机IO,仅在页加载时合并;聚簇索引修改立即执行,因数据本身不可延后。AHI基于高频等值查询自动构建哈希索引,加速定位,仅支持等值操作。LogBuffer为redo log内存缓冲,配合磁盘日志实现崩溃恢复。三者均服务于性能优化,其中ChangeBuffer与AHI共享BufferPool空间,而LogBuffer独立

bksczm的博客 311

手把手教你排查Abaqus中的Johnson-Cook损伤参数:避免因d3正负号导致的仿真失败

本文详细解析了Abaqus中Johnson-Cook损伤参数d3正负号设置的关键问题,帮助用户避免因参数错误导致的仿真失败和Excessive distortion报错。通过对比不同文献定义、提供实操指南和典型错误排查流程,有效提升非线性分析的准确性和效率。

weixin_33960567的博客 356

信创环境下PageOffice文档控件适配与实践

信创适配做到文档控件这一层,拼的已经不是"有没有国产版本",而是同一个功能在两类终端上是否真的等价。等价的标准很具体:同一次点击能得到同样的结果,同一份公文能得到同样的版式,同一个项目不需要维护两套代码。这背后是三件并不轻松的工作:服务端用一套接口同时支撑两类终端,客户端把两种系统与四种芯片的安装包分发清楚,文档内核层由产品侧跟着 WPS 的版本走。浏览器这一层的压力,则被收进了产品自己的窗口里——升级节奏由产品掌握,不再交给运气。

zi_wu_xian的专栏 340

华为MA5620配置宽带及语音实例

华为EPON配置实例1、公共部分和宽带PPPOE部分用串口用户名密码root/mduadminMA5620E>enableMA5620E#configMA5620E(config)#MA5620E(config)#sysnamebigcow/给设备起名字/****之前为公共部一、建vlan和地址bigcow(config)#vlan100...

weixin_33862041的博客 6348

第133章 PCL OrientedBoundingBox 有向包围盒

中文叫有向包围盒,是一种旋转过的包围盒。特点:不像AABB那样固定朝向坐标轴能更紧密地包裹物体适用于复杂姿态的物体,比如倾斜、旋转的物体通常通过PCA、惯性矩等算法确定方向。

yumeiguo的博客 265

第三篇 第 6 课

前置:第三篇第 1 课(stdx 引入),第二篇第 1 课(std.regex)。环境:仓颉 SDK 1.2.0。本文所有代码与输出均逐行实测。

weixin_41618057的博客 557

基于STM32的智能电子秤设计毕业论文

摘要:本文设计了一款基于STM32F103C8T6的智能电子秤系统,通过HX711称重传感器实现高精度测量,采用OLED显示和矩阵键盘完成人机交互。系统包含重量采集、数据处理、单价设置、去皮清零及总价计算等功能模块,经测试测量误差小于0.1%,稳定性良好。研究实现了低成本、高可靠性的智能称重方案,为后续无线传输和AI算法集成奠定了基础。关键词:STM32;智能电子秤;HX711;OLED显示;矩阵键盘。

3254968421的博客 853

【从零理解 Spring AI · 12】MCP 的两种角色:做客户端还是做服务端

上一篇讲了 MCP 的概念:标准协议、三大角色、M+N 替代 M×N。

nice_lcj520的博客 624

【逐函数讲解ORB_SLAM3源码】获取普通帧率、关键帧、IMU数据

获得imu的旋转 mRwc * mImuCalib.mTcb.rotationMatrix(); Sophus::SE3 mTwc 创建ORB_SLAM3系统 Create SLAM system. It initializes all system threads and gets ready to process frames. ORB_SLAM3::System SLAM(argv[1],argv[2],ORB_SLAM3::System::IMU_RGBD, true, 0, file_nam

小秋 AI SLAM 入门实战教程 1249

安川机器人外部轴添加

本文详细介绍了如何在安川机器人本体上添加第7轴以及如何设置动作,本文以添加点焊枪为例进行讲解。

haier123888的博客 7895

pcl2启动器下载(Minecraft PCL2 启动器 最新版 安装与使用说明)

摘要:PCL2(Plain Craft Launcher 2)是一款面向 Minecraft 的第三方启动器,支持正式版与快照版本管理、模组与整合包安装、Java 运行时自动匹配,绿色免安装、双击即可运行。适合在 Windows 上玩单机整合包、需要多版本共存或离线启动的用户使用

2611_96675819的博客 239

医学图像的对抗攻击:模型安全性与鲁棒性分析

医学图像的对抗攻击:模型安全性与鲁棒性分析 ,人工智能,计算机视觉,大模型,AI,本文围绕医学图像的对抗攻击展开,分析了其对AI模型的威胁。介绍了对抗样本定义、攻击原理,以及FGSM、BIM、PGD等常见攻击方法,还给出了相关代码示例。阐述了攻击对模型诊断准确性和可信度的影响,提出对抗训练、输入预处理、模型集成等提升模型安全性与鲁棒性的方法,探讨了评估指标、数据集和流程,分析了实际应用中的挑战与应对策略,最后展望了未来发展趋势。

不踩坑,不知道坑有多深;不总结,踩过的坑白踩。 18万+

spring boot 4集成SQLLite,及其SQLLite的建库

spring boot 4集成SQLLite,及其SQLLite的建库

weixin_41463944的博客 257

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

Java 集合容器高频面试题全解:HashMap 树化阈值、1.7 死循环与 ConcurrentHashMap 演进(2026 招聘 JD 真题复盘)

HashMap 树化阈值 8 的泊松分布依据、退化阈值 6 的防抖设计、JDK 1.7 头插成环死循环的排查与修复、1.8 尾插后为何仍线程不安全、ConcurrentHashMap 放弃分段锁的原因与 ForwardingNode 协作扩容、computeIfAbsent 死锁陷阱、大集合找重复的场景题选型,附三层追问链自测。题目来源为 38 期公开招聘 JD 样本与字节、拼多多、建行、美团、快手公开面经。

蒙眼过河 436

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

spdlog 同步日志库使用详解

spdlog是一个轻量级 C++ 日志库,支持同步日志、异步日志、多线程日志、日志文件轮转和自定义日志格式。对于嵌入式 Linux 应用开发,我建议先使用。它可以帮我们完成:日志级别过滤。时间戳和线程 ID 输出。日志格式化。终端和文件输出。多线程安全写入。日志文件按大小或时间轮转。我们不需要自己实现互斥锁、文件写入、日志格式化和轮转等底层功能。

zengjiajun2006的博客 1127

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

JavaSE通关手册:数据类型与变量

代码无需额外处理,编译时编译器自动完成转换。

xys_678的博客 236

IDEA 简介:从零认识 IntelliJ IDEA

IDEA 全称,是由 JetBrains 公司开发的一款主流 Java 集成开发环境(IDE)。它集代码编辑、编译、调试、测试、版本控制、构建管理等功能于一体,被大量 Java 开发者视为日常开发的首选工具。所谓 IDE(Integrated Development Environment,集成开发环境),就是把写代码所需的各类工具整合到同一个界面中。相比只用文本编辑器加命令行编译,IDE 能显著减少重复操作,让开发者把精力集中在业务逻辑上。

ztI10的博客 194

Docker部署linkding:HTTPS与数据备份

部署私人书签库,除了让页面能够打开,还需要考虑几个实际问题:重建容器后数据是否保留、登录和保存是否正常、升级前怎样备份,以及出现 502 或 CSRF 错误时从哪里检查。本文使用 Docker Compose 部署 linkding,采用默认 SQLite 数据库,通过 Caddy 提供 HTTPS,并完成账户创建、数据持久化验证和备份。如果重建后账户或书签消失,应先检查是否换了项目目录、改了挂载路径,或者启动了另一套实例,不要急着重新初始化。遇到权限问题,应根据日志确认具体目录和运行用户,再调整权限。

tedcloud123的博客 200

C++20协程怎么运行?原理与三大核心组件深度剖析

C++20协程是轻量级的无栈状态机,通过co_await、co_yield、co_return实现挂起与恢复,由Promise、协程句柄和Awaitable三大组件协同工作。协程与线程互补,适用于高效管理大量并发I/O任务,显著降低上下文切换开销。其核心在于编译器生成的状态机机制,需配合库(如cppcoro)使用。掌握Promise控制逻辑、句柄生命周期管理及Awaitable语义,是构建高性能异步程序的基础。

Lucis__的博客 337

动态代理两大流派:JDK 代理与子类代理

业务类想加日志,最直白的写法是侵入式修改: 问题很明显:每个方法都要改一遍,改一个业务要动十处。代理模式的解法是:调用方不直接依赖 ,而是依赖一个代理对象。代理对象长得跟目标一模一样,调用它 → 代理先执行增强逻辑 → 再转调真实对象。 关键在于:代理对象的类型是哪来的?这就是"动态"二字的含义:代理类在运行时才诞生。两个角色: 承载增强逻辑, 负责生成代理类。 组装代理并调用: 输出: 业务代码 一行没动,增强逻辑全在 里。这就是 AOP 的味道。 内部四步: 第 2 步 内部:先查 (同一个接口

Android的专栏 665

c++ explicit关键字详解

explicit。

拒绝AI文,努力在AI时代写出感动人心的好文章 170

TRingBuffer两端都能增删(快递站版)

TRingBuffer 是一个支持两端增删、下标访问且容量动态增长的环形双端队列。它通过无符号索引的永不归零设计,利用减法自动模运算实现空满判断与元素计数,避免了传统环形缓冲浪费格子的问题。内部以票号(索引)标记首尾,扩容时重排元素为连续存储,保证 O(1) 操作与高缓存效率。虽不线程安全,但其高效性使其成为游戏开发中事件队列、命令缓冲等场景的理想选择。

u013768914的博客 315

Java 项目实战:交友项目后台系统——网关统一鉴权与 B 端管理后台

本次改造通过引入SpringCloud Gateway实现网关统一鉴权与路由,新建mf-admin管理端复用C端域服务(Dubbo调用),实现管理员登录与用户管理四件查询。核心套路:网关白名单+双体系JWT(同工具不同payload)、管理端零直连业务库、分页形态区分(MySQL自动count/Mongo手动count)、浏览器端独立聚合。踩坑12条,附自检清单与后续改造方向,可复用于多角色后台系统。

Wang的专栏 82

建造者模式,就是“点套餐”而不是“背配方”

建造者模式如同点套餐:无需记住复杂配方,只需一步步选择配置,最后build()交付完整对象。它将复杂对象的构造过程解耦,通过链式调用实现清晰、灵活、可读性强的构建方式,广泛应用于奶茶点单、电脑组装、盖房建屋及Spring Boot等场景,有效避免参数爆炸与语义模糊问题。

weixin_51288065的博客 276

运动控制功能安全实践深度解析 | 安全功能篇(上)

安全功能不只是急停。SLS 限上限、SSR 守区间、SSM 管人员准入,三者约束对象不同,混用等于没设防。本文拆解限速类安全功能的判定逻辑、编码器与无传感器两条采集路径,以及汽车、玻璃、物流、烘焙、机器人等场景的落地差异。

MotroEngineer的博客 280
上一篇: java数据结构与算法刷题-----LeetCode 232:用栈实现队列
下一篇: MySQL 数据存储和优化------ MySQL集群环境搭建(Linux虚拟机) ---- (主从架构---分库分表)持续更新
ydenergy_殷志鹏
博客等级 码龄7年 5889粉丝 543原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ydenergy_殷志鹏

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值