泛型二叉搜索树（C#）

已于 2023-12-03 17:31:52 修改
阅读量991 收藏 16
点赞数 21
分类专栏： 数据结构 文章标签： 算法
于 2023-12-02 16:47:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51613678/article/details/134753106
版权

概念

二叉搜索树
1、什么是二叉搜索树

二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树。
二叉搜索树：一棵二叉树，可以为空；如果不为空，满足以下性质：

  1. 非空左子树的所有键值小于其根结点的键值。
  2. 非空右子树的所有键值大于其根结点的键值。
  3. 左、右子树都是二叉搜索树

因为 中序遍历，必定得到一个有序序列， 即为：二叉排序树

例子：

正确的二叉排序树
图1、二叉搜索树


3、缺点：根结点如果没有选取好，那么这颗二叉搜索树会“退化”，变成一根链条

使用C#实现二叉搜索树

正常手搓一个二叉搜索树，结点内的数据类型只能定义为 int，只进行简单的比大小

因此作出尝试，将数据类型定义为 T (泛型)，满足“字符串、数字、数组” 等数据类型

解决数据比较问题：

        在插入值时，需要将插入值与当前结点的值进行比较，如果数据类型为 T ，值之间的比较方法就需要由创建二叉搜索树的类，自定义回调方法

        使用 deledage (委托) 实现回调

采用非递归实现所有功能

二叉树的结构

public class TreeNode<T>
{
    public int layout;                  // 层级
    public T content;                   // 内容
    public TreeNode<T> left;            // 左子树
    public TreeNode<T> right;           // 右子树
    public TreeNode<T> parent;          // 父结点
}

其中 layout 的作用是标记当前结点在整个二叉树内的层级（即为 深度），方便打印二叉树而作的一个标记

结点中值的对比方法

public delegate bool CompareEqual(T a, T b);  // 判断相等, false为 a!=b ，true为 a=b
public delegate bool Compare(T a, T b);       // 判断大小, false为 a<b ，true为 a>b

该回调需要自定义后才能使用

例如 数据类型为 int 时：

CompareEqual compareEqual = delegate(int i, int i1)
{
    return i == i1;
},
CompareEqual compare = delegate(int i, int i1)
{
    return i > i1;
})

创建二叉树控制器

public class TreeControll<T>
{
    public delegate bool CompareEqual(T a, T b); // 判断相等, false为 a!=b ，true为 a=b
    public delegate bool Compare(T a, T b); // 判断大小, false为 a<b ，true为 a>b

    private TreeNode<T> _treeNode;
    private CompareEqual _compareEqual;
    private Compare _compare;

    public TreeControll(T[] contents, CompareEqual compareEqual, Compare compare)
    {
        _compareEqual = compareEqual;
        _compare = compare;
        for (int i = 0; i < contents.Length; i++)
        {
            // 插入方法
            // Insert(contents[i]);
        }
    }

    public TreeControll(CompareEqual compareEqual, Compare compare)
    {
        _compareEqual = compareEqual;
        _compare = compare;
    }
}
创建存储 int 类型的二叉搜索树
// 构造数据
int[] nums = new[] {15, 10, 19, 8, 13, 16, 28, 5, 9, 12, 14, 20, 30, 25};
TreeControll<int> treeControll = new TreeControll<int>(nums, 
    delegate(int i, int i1)
    {
        return i == i1;
    },
    delegate(int i, int i1)
    {
        return i > i1;
    });

 打印下看看：（没有做处理，只是根据层级简单打印了下）

插入

二叉搜索树在插入前，要找到插入的位置，假设需要插入的值为 num

从根结点开始，比较num与当前结点的值

        当 num < 当前结点.content 时，判断是否存在左子结点

                存在：搜索 当前结点 的 左子结点

                不存在：创建新的结点，新结点作为当前节点的左子结点

        当 num > 当前结点.content 时，判断是否存在右子结点

                存在：搜索 当前结点 的 右子结点

                不存在：创建新的结点，新结点作为当前节点的右子结点

public void Insert(T content)           // 用非递归实现
{
    if (_treeNode == null)
    {
        _treeNode = new TreeNode<T>();
        _treeNode.layout = 0;
        _treeNode.content = content;
        return;
    }

    TreeNode<T> curNode = _treeNode;
    while (true)
    {
        if (_compareEqual(content, curNode.content))
        {
            // 特殊情况：插入的值在树中存在
            Console.WriteLine("插入失败，该值已存在:" + content);
            break;
        }

        if (_compare(content, curNode.content))
        {
            if (curNode.right != null) { curNode = curNode.right; }
            else
            {
                TreeNode<T> node = new TreeNode<T>();
                node.layout = curNode.layout + 1;
                node.content = content;
                node.parent = curNode;
                curNode.right = node;
                break;
            }
        }
        else
        {
            if (curNode.left != null) { curNode = curNode.left; }
            else
            {
                TreeNode<T> node = new TreeNode<T>();
                node.layout = curNode.layout + 1;
                node.content = content;
                node.parent = curNode;
                curNode.left = node;
                break;
            }
        }
    }
}

       

        搜索

（1）查找从根结点开始，如果树为空，返回NULL
（2）若搜索树非空，则根结点关键字和X进行比较，并进行不同处理：
  ① 若X小于根结点键值，只需在左子树中继续搜索；
  ② 如果X大于根结点的键值，在右子树中进行继续搜索；
  ③若两者比较结果是相等，搜索完成，返回指向此结点的指针。

public TreeNode<T> Find(T content)             // 用非递归实现
{
    // 目前该功能只负责返回 是否找到
    Console.WriteLine("----------------  查找  ---------------");
    bool isFind = false;
    TreeNode<T> curNode = _treeNode;
    while (curNode != null)
    {
        if (_compareEqual(content, curNode.content))
        {
            Console.WriteLine("已找到节点: " + content);
            Console.WriteLine("层级为: " + curNode.layout + "    父节点为: " + (curNode.parent != null ? curNode.parent.content.ToString() : "空"));
            isFind = true;
            break;
        }

        if (_compare(content, curNode.content))
        {
            curNode = curNode.right;
        }
        else
        {
            curNode = curNode.left;
        }
    }
    if (!isFind)
    {
        Console.WriteLine("没有找到节点: " + content);
    }
    Console.WriteLine("----------------查找结束---------------\n");
    return isFind ? curNode : null;
}

        查找 13 和 -1

        删除结点

对于二叉搜索树的删除，相对来说就比较麻烦了。因为要考虑以下三种情况：
①要删除的是叶结点；

        左右子树都为空，删掉它并没什么后顾之忧，所以当我们要删除的是叶结点的时候，直接删除就好了。当然不要忘记一个重要的操作——删除之后要修改其父结点指针，即置为NULL
②要删除的结点只有一个孩子结点；

        被删除的结点的孩子无论是左孩子还是右孩子，都只会比被删除的结点的父结点小，所以我们只需要将被删除的结点的父结点的指针指向被删除的结点的孩子结点。
③要删除的结点有左、右两棵子树；

        用被删除结点的右子树的最小元素或者左子树的最大元素替代被删除结点。

        因此设定 repleaseLeft 来自定义是找左子树还是右子树

public void Remove(T content, bool repleaseLeft = true)           // 用非递归实现
{
    // 找到该节点
    TreeNode<T> curNode = Find(content);
    bool isEnd = false;
    while (!isEnd)
    {
        if (curNode.left == null && curNode.right == null)              // 叶子结点
        {
            if (curNode.parent != null)
            {
                if (_compare(curNode.content, curNode.parent.content))
                    curNode.parent.right = null;
                else
                    curNode.parent.left = null;
            }
            curNode = null;
            isEnd = true;
        }
        else if(curNode.left != null && curNode.right != null)          // 存在左右节点
        {
            TreeNode<T> replaceNode;
            if (repleaseLeft)       // 找到左节点最大的节点
            {
                replaceNode = curNode.left;
                while (replaceNode.right != null)
                {
                    replaceNode = replaceNode.right;
                }
            }
            else                    // 找到右节点最小的节点
            {
                replaceNode = curNode.right;
                while (replaceNode.left != null)
                {
                    replaceNode = replaceNode.left;
                }
            }
            curNode.content = replaceNode.content;
            curNode = replaceNode;
        }
        else                                                             // 只存在一个子节点
        {
            TreeNode<T> tmpNode;
            if (curNode.left != null)
                tmpNode = curNode.left;
            else
                tmpNode = curNode.right;
            tmpNode.parent = curNode.parent;
            curNode = null;
            if (_compare(tmpNode.content, tmpNode.parent.content))
                tmpNode.parent.right = tmpNode;
            else
                tmpNode.parent.left = tmpNode;
            refreshLayout(tmpNode);
            isEnd = true;
        }
    }

}
// 刷新从当前结点开始的层级
private void refreshLayout(TreeNode<T> rootNode)
{
    Queue<TreeNode<T>> queue = new Queue<TreeNode<T>>();
    queue.Enqueue(rootNode);
    while (queue.Count != 0)
    {
        TreeNode<T> node = queue.Dequeue();
        if (node.parent != null) node.layout = node.parent.layout + 1;
        else node.layout = 0;
        
        if (node.left != null) queue.Enqueue(node.left);
        if (node.right != null) queue.Enqueue(node.right);
    }
}

        删除结点 10 后，打印树：

总结

至此，瞎想的什么 泛型二叉搜索树 就写完了

写的比较水。。。。

全部代码：

TreeNode.cs
public class TreeNode<T>
{
    public int layout;                  // 层级
    public T content;                   // 内容
    public TreeNode<T> left;            // 左子树
    public TreeNode<T> right;           // 右子树
    public TreeNode<T> parent;          // 父节点
}
TreeControll.cs
public class TreeControll<T>
{
    public delegate bool CompareEqual(T a, T b);         // 判断相等, false为 a!=b ，true为 a=b
    public delegate bool Compare(T a, T b);              // 判断大小, false为 a<b ，true为 a>b

    private TreeNode<T> _treeNode;
    private CompareEqual _compareEqual;
    private Compare _compare;
    public TreeControll(T[] contents, CompareEqual compareEqual, Compare compare)
    {
        _compareEqual = compareEqual;
        _compare = compare;
        for (int i = 0; i < contents.Length; i++)
        {
            Insert(contents[i]);
        }
        
    }
    
    public TreeControll(CompareEqual compareEqual, Compare compare)
    {
        _compareEqual = compareEqual;
        _compare = compare;
    }

    /// <summary>
    /// 插入值
    /// </summary>
    /// <param name="content"></param>
    public void Insert(T content)           // 用非递归实现
    {
        if (_treeNode == null)
        {
            _treeNode = new TreeNode<T>();
            _treeNode.layout = 0;
            _treeNode.content = content;
            return;
        }

        TreeNode<T> curNode = _treeNode;
        while (true)
        {
            if (_compareEqual(content, curNode.content))
            {
                // 特殊情况：插入的值在树中存在
                Console.WriteLine("插入失败，该值已存在:" + content);
                break;
            }

            if (_compare(content, curNode.content))
            {
                if (curNode.right != null) { curNode = curNode.right; }
                else
                {
                    TreeNode<T> node = new TreeNode<T>();
                    node.layout = curNode.layout + 1;
                    node.content = content;
                    node.parent = curNode;
                    curNode.right = node;
                    break;
                }
            }
            else
            {
                if (curNode.left != null) { curNode = curNode.left; }
                else
                {
                    TreeNode<T> node = new TreeNode<T>();
                    node.layout = curNode.layout + 1;
                    node.content = content;
                    node.parent = curNode;
                    curNode.left = node;
                    break;
                }
            }
        }
    }

    /// <summary>
    /// 查找值
    /// </summary>
    /// <param name="content"></param>
    /// <returns></returns>
    public TreeNode<T> Find(T content)             // 用非递归实现
    {
        // 目前该功能只负责返回 是否找到
        Console.WriteLine("----------------  查找  ---------------");

        bool isFind = false;
        TreeNode<T> curNode = _treeNode;
        while (curNode != null)
        {
            if (_compareEqual(content, curNode.content))
            {
                Console.WriteLine("已找到节点: " + content);
                Console.WriteLine("层级为: " + curNode.layout + "    父节点为: " + (curNode.parent != null ? curNode.parent.content.ToString() : "空"));
                isFind = true;
                break;
            }

            if (_compare(content, curNode.content))
            {
                curNode = curNode.right;
            }
            else
            {
                curNode = curNode.left;
            }
        }

        if (!isFind)
        {
            Console.WriteLine("没有找到节点: " + content);
        }
        Console.WriteLine("----------------查找结束---------------\n");
        return isFind ? curNode : null;
    }

    /// <summary>
    /// 删除值
    /// </summary>
    /// <param name="content"></param>
    /// <param name="repleaseLeft"> 删除值后的替换元素，是否采用左节点内的元素 </param>
    public void Remove(T content, bool repleaseLeft = true)           // 用非递归实现
    {
        /*
         * 1、删除叶子节点：直接删
         * 2、删除的节点只包含一个孩子节点：将该节点的父节点指向该节点的孩子节点
         * 2、删除的节点包含左右节点：找到该节点左子树中的最大元素 或 右子树中的最小元素， 进行替换
         */
        
        // 找到该节点
        TreeNode<T> curNode = Find(content);
        bool isEnd = false;
        while (!isEnd)
        {
            if (curNode.left == null && curNode.right == null)              // 叶子结点
            {
                if (curNode.parent != null)
                {
                    if (_compare(curNode.content, curNode.parent.content))
                        curNode.parent.right = null;
                    else
                        curNode.parent.left = null;
                }
                curNode = null;
                isEnd = true;
            }
            else if(curNode.left != null && curNode.right != null)          // 存在左右节点
            {
                TreeNode<T> replaceNode;
                if (repleaseLeft)       // 找到左节点最大的节点
                {
                    replaceNode = curNode.left;
                    while (replaceNode.right != null)
                    {
                        replaceNode = replaceNode.right;
                    }
                }
                else                    // 找到右节点最小的节点
                {
                    replaceNode = curNode.right;
                    while (replaceNode.left != null)
                    {
                        replaceNode = replaceNode.left;
                    }
                }
                curNode.content = replaceNode.content;
                curNode = replaceNode;
            }
            else                                                            // 只存在一个子节点
            {
                TreeNode<T> tmpNode;
                if (curNode.left != null)
                    tmpNode = curNode.left;
                else
                    tmpNode = curNode.right;
                tmpNode.parent = curNode.parent;
                curNode = null;
                if (_compare(tmpNode.content, tmpNode.parent.content))
                    tmpNode.parent.right = tmpNode;
                else
                    tmpNode.parent.left = tmpNode;
                refreshLayout(tmpNode);
                isEnd = true;
            }
        }

    }

    /// <summary>
    /// 刷新从当前结点开始的层级
    /// </summary>
    /// <param name="rootNode"></param>
    private void refreshLayout(TreeNode<T> rootNode)
    {
        Queue<TreeNode<T>> queue = new Queue<TreeNode<T>>();
        queue.Enqueue(rootNode);
        while (queue.Count != 0)
        {
            TreeNode<T> node = queue.Dequeue();
            if (node.parent != null) node.layout = node.parent.layout + 1;
            else node.layout = 0;
            
            if (node.left != null) queue.Enqueue(node.left);
            if (node.right != null) queue.Enqueue(node.right);
        }
    }

    /// <summary>
    /// 打印树
    /// </summary>
    public void PrintOut()
    {
        Console.WriteLine("---------------------- 打印树 ---------------------");
        if (_treeNode == null)
        {
            Console.WriteLine("树为空");
            return;
        }
        Queue<TreeNode<T>> queue = new Queue<TreeNode<T>>();
        queue.Enqueue(_treeNode);
        int curLayout = _treeNode.layout;
        while (queue.Count != 0)
        {
            TreeNode<T> node = queue.Dequeue();
            if (curLayout < node.layout)
            {
                curLayout = node.layout;
                Console.Write("\n");
            }
            Console.Write(node.content + "   ");
            if (node.left != null)
            {
                queue.Enqueue(node.left);
            }
            if (node.right != null)
            {
                queue.Enqueue(node.right);
            }
        }
        Console.WriteLine("\n----------------------打印结束---------------------\n");
    }
}
main函数代码.cs
public class T_Main
{
    //-----------------------------------------------------------------------------------------------//
    // 二叉搜索树  BST (Binary Search Tree)
    /*
     * 性质：
     *      可以为空
     *      非空情况下：
     *          非空左子树的所有键值小于其根节点的键值
     *          非空右子树的所有键值大于其根节点的键值
     *          左、右子树都是二叉搜索树
     *      中序遍历，必定得到一个有序序列
     */
    // 缺点：根节点如果没有选取好，那么这颗二叉搜索树会“退化”，变成一根链条
    
    
    /// <summary>
    /// 起始函数
    /// </summary>
    public static void Main(string[] args)
    {
        // 构造数据
        int[] nums = new[] {15, 10, 19, 8, 13, 16, 28, 5, 9, 12, 14, 20, 30, 25};

        // 创建存储 int 类型的二叉搜索树
        TreeControll<int> treeControll = new TreeControll<int>(nums, 
            delegate(int i, int i1)
            {
                return i == i1;
            },
            delegate(int i, int i1)
            {
                return i > i1;
            });
        
        // 打印树结构
        treeControll.PrintOut();
        
        // 查找
        treeControll.Find(15);
        treeControll.Find(25);
        treeControll.Find(13);
        treeControll.Find(-1);
        
        // 删除
        treeControll.Remove(10);
        treeControll.PrintOut();
    }
}

不伤欣
关注
专栏目录
C# 二叉树
问道生的博客
11-15 1584
using System; using System.Collections; namespace helloWorld { // 二叉树的实现 public class Tree&lt;T&gt; { private TreeNode&lt;T&gt; head; public TreeNode&lt;T&gt; Head { ...
泛型树遍历C#详细教程
WtfBug的博客
11-08 1018
一、前言 本篇目的 构建一个自定义泛型树Tree 定义该类的枚举器，实现先序遍历 用get访问器，实现树的中序，后序，层序遍历 开发环境 操作系统： Windows 10 X64 SDK：NET Framework 4.7.2 IDE：Visual Studio 2019 二、部分名词解释 泛型 泛型，是指通过参数化类型来实现在同一份代码上操作多种数据类型，泛型编程是一种编程范式，它利用“参数化类型”将类型抽象化，从而实现更为灵活的复用。 泛型类型和普通类型的区别在于泛型类型与一组类型参数或类型变
C# 数据结构 之 二叉树
weixin_30263073的博客
08-28 253
二叉树的定义 二叉树(Binary Tree)是n(n>=0)个有限元素的集合，该集合或者为空，或者由一个称为根(root)的元素及两个不相交的，被称为左子树和右子树的二叉树组成。当集合为空时，称该二叉树为空二叉树，在二叉树中，一个元素也称为一个结点。 二叉树是有序的，即若将其左右子树颠倒，就称为另一颗不同的二叉树。 二叉树的相关术语 结点的度：结点所拥有的子树的个数称为该结点的度。...
C#二叉搜索树算法
最新发布
weixin_37074727的博客
09-12 129
思维导航二叉搜索树算法实现原理实现基本步骤和代码示例数组与搜索树的效率对比二叉搜索树常见应用C#数据结构与算法实战入门指南参考文章 二叉搜索树算法实现原理 二叉搜索树（Binary Search Tree，简称BST）是一种节点有序排列的二叉树数据结构。它具有以下性质： 每个节点最多有两个子节点。 对于每个节点，其左子树的所有节点值都小于该节点值，其右子树的所有节点值都大于该节点值。 实现基本...
c# 二叉树
alice_art的专栏
09-28 1089
 本程序中将用到一棵已知的二叉树如图（二叉树图）所示。先序遍历：1.       访问根结点2.       按先序遍历左子树;3.       按先序遍历右子树；4.       例如：遍历已知二叉树结果为：A->B->D->G->H->C->E->F中序遍历：1.       按中序遍历左子树;2.       访问根结点；3.       按中序遍历右子树
C#写算法之二叉树
指尖动听知识库
03-14 342
在数据结构中，树的定义如下：树(tree)是n(n>=0)个节点的有限集，当n=0时，称为空树。在任意一个非空树中，有如下特点：有且仅有一个特定的称为根的节点。当n>1时，其余节点可分为m(m>0)个互不相交的有限集，每一个集合本身又是一个树，并称为根的子树。树有以下概念：根节点、父节点、兄弟节点、孩子节点。树的最大层级数，被称为树的高度或深度。
泛型二叉树
qq_41719955的博客
01-01 176
import java.util.ArrayList; import java.util.List; public class Node<T>{//泛型结点 private Node<T> leftNode = null; private Node<T> rightNode = null; private T value = null; public void add(T t){ if(null == value) { value = t; }
C# Dictionary和SortedDictionary的简介
12-31
SortedDictionary 泛型类是检索运算复杂度为 O(log n) 的二叉搜索树，其中 n 是字典中的元素数。就这一点而言，它与 SortedList 泛型类相似。这两个类具有相似的对象模型，并且都具有 O(log n) 的检索运算...
C#中的递归二叉查找算法与数据结构应用
在二叉查找中，数据通常存储在二叉搜索树（Binary Search Tree, BST）中，每个节点都有两个子节点，左子节点的值小于当前节点，右子节点的值大于当前节点。这使得我们可以快速定位目标值。 在描述中提到的C#代码段...
C#语言视角：递归二叉查找算法解析与实践
二叉查找算法通常基于二叉搜索树（Binary Search Tree, BST），这是一种特殊的二叉树，其中每个节点的左子树只包含小于当前节点值的元素，右子树包含大于当前节点值的元素。在递归版本的二叉查找算法中，我们首先...
C#shiyanTree.zip
05-08
例如，二叉搜索树在插入和删除操作后可能需要进行调整以保持其排序性质。 4. **树的特性**：例如，平衡树（如AVL树和红黑树）可以保证查找操作的最坏情况下的时间复杂度为O(log n)，而二叉树如果不平衡可能导致最坏...
用C#实现的二叉树（窗体应用程序）
04-21
一个用C#写的简单的二叉树，可以创建、前序遍历、中序遍历、后续遍历。Windows 窗体应用程序。
C#实现二叉树遍历算法
04-15
　static void Main(string[] args) 　　{ 　　nodes<string> rootNode = BinTree(); 　　Console.WriteLine("先序遍历方法遍历二叉树："); 　　PreOrder<string>(rootNode); 　　Console.WriteLine("中序遍历方法遍历二叉树："); 　　MidOrder<string>(rootNode); 　　Console.WriteLine("后序遍历方法遍历二叉树："); 　　AfterOrder<string>(rootNode);
关于c#二叉树的实现
12-31
本篇纯属娱乐，源于整理代码，发现还曾实现过遍历二叉树。 虽然.NET/C#中的各种集合类已经实现了最优的排序设计，但了解基本的算法实现有助于软件开发中的各种权衡和选择。比如，如果你实现过B+树排序和查找，并将树节点序列化至二进制文件块，则你应该已经了解了各种数据库索引的基本设计。 什么是二叉树？http://en.wikipedia.org/wiki/Binary_tree 二叉树节点类定义 代码如下:View Code    /// <summary>   /// 二叉树节点   /// </summary>   /// <typeparam name=”T”>The item type</
C# 二叉树
ProjectDD的专栏
12-28 1590
 using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace ConsoleApplication1二叉树 { class Program { static void Main(string[] args) {
泛型实现二叉树
chelen_jak的专栏
09-01 1803
参考资料《Visual C# 2010 从入门到精通》 18.3.2 使用泛型构造二叉树类 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace BinaryTreeTest {     class Program     {
泛型及TreeSet二叉树
weixin_46115287的博客
07-25 261
一，泛型 1.1泛型概述【理解】 泛型的介绍 ​ 泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制 泛型的好处 把运行时期的问题提前到了编译期间 避免了强制类型转换 泛型的定义格式 <类型>: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如: <E> <T> <类型1,类型2…>: 指定多种类型的格式,多种类型之间用逗号隔开.例如: <
数据结构之二叉树（C#版）
jmelzc的博客
01-06 1978
数据结构之二叉树（C#版）简介代码实现总结 简介 代码实现 总结
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

不伤欣

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

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

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

打赏作者

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

抵扣说明：

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

余额充值