二叉查找树删除操作

最新推荐文章于 2024-08-20 10:48:49 发布
最新推荐文章于 2024-08-20 10:48:49 发布
阅读量846 收藏
点赞数
分类专栏： 数据结构 文章标签： null tree search delete 算法 测试

二叉查找树中，最复杂的操作就是删除操作。对于叶子节点，直接删除即可。对于一颗子树的节点，用子树取代原节点即可。对于拥有两颗子树的节点，首先用右子树最小的节点取代源节点，再递归删除此最小节点。

具体代码如下所示：

[java] view plain copy print ?
  1. package com.Algorithm.Tree;  
  2. import java.util.*;  
  3. import java.io.*;  
  4. /* 
  5.  * author:Tammy Pi 
  6.  * function:二叉查找树 
  7.  */  
  8. public class BiSearchTree {  
  9.   
  10.     public TreeNode root=null;  
  11.     private Scanner scanner=null;  
  12.       
  13.     public BiSearchTree()  
  14.     {  
  15.         scanner=new Scanner(System.in);  
  16.     }  
  17.     public TreeNode getRoot() {  
  18.         return root;  
  19.     }  
  20.     public void setRoot(TreeNode root) {  
  21.         this.root = root;  
  22.     }  
  23.     public Scanner getScanner() {  
  24.         return scanner;  
  25.     }  
  26.     public void setScanner(Scanner scanner) {  
  27.         this.scanner = scanner;  
  28.     }  
  29.       
  30.     public void createTree()  
  31.     {  
  32.         this.root=createTree(this.root);  
  33.     }  
  34.     public void midTraverse()  
  35.     {  
  36.         midTraverse(this.root);  
  37.     }  
  38.     //中序遍历，相当于排序   
  39.     public void midTraverse(TreeNode root)  
  40.     {  
  41.         if(root!=null)  
  42.         {  
  43.             midTraverse(root.getLchild());  
  44.             System.out.print(root.getData()+" ");  
  45.             midTraverse(root.getRchild());  
  46.         }  
  47.     }  
  48.     //建立二叉查找树   
  49.     public TreeNode createTree(TreeNode root)  
  50.     {  
  51.         String str=scanner.next();  
  52.         int n=Integer.parseInt(str);  
  53.           
  54.         for(int i=0;i<n;i++)  
  55.         {  
  56.             String data=scanner.next();  
  57.             if(root==null)  
  58.             {  
  59.                 root=new TreeNode(data);  
  60.             }  
  61.             else   
  62.             {  
  63.                 TreeNode node=new TreeNode(data);  
  64.                 TreeNode x=root,y=root;  
  65.                   
  66.                 while(x!=null)  
  67.                 {  
  68.                     if(x.getData().compareTo(node.getData())>0)  
  69.                     {  
  70.                         y=x;  
  71.                         x=x.getLchild();  
  72.                     }  
  73.                     else   
  74.                     {  
  75.                         y=x;  
  76.                         x=x.getRchild();  
  77.                     }  
  78.                 }  
  79.                 if(y.getData().compareTo(node.getData())>0)  
  80.                 {  
  81.                     y.setLchild(node);  
  82.                 }  
  83.                 else  
  84.                 {  
  85.                     y.setRchild(node);  
  86.                 }  
  87.             }  
  88.         }//for i   
  89.           
  90.         return root;  
  91.     }//createTree   
  92.     //查找最小的节点   
  93.     public TreeNode findMin(TreeNode node)  
  94.     {  
  95.         TreeNode x=node;  
  96.         while(node!=null)  
  97.         {  
  98.             x=node;  
  99.             node=node.getLchild();  
  100.         }  
  101.         return x;  
  102.     }  
  103.     public void testRemove()  
  104.     {  
  105.         root.setRchild(remove(root.getRchild(),root.getRchild()));  
  106.         System.out.print("删除节点后，中序遍历结果为：");  
  107.         midTraverse();  
  108.     }  
  109.     //删除节点   
  110.     //node为待删除节点   
  111.     public TreeNode remove(TreeNode node,TreeNode subTree)  
  112.     {  
  113.         if(subTree==null)  
  114.         {  
  115.             return null;  
  116.         }  
  117.           
  118.         int state=node.getData().compareTo(subTree.getData());  
  119.         if(state<0)  
  120.         {  
  121.             node.setLchild(remove(node,subTree.getLchild()));  
  122.         }  
  123.         else if(state>0)  
  124.         {  
  125.             node.setRchild(remove(node,subTree.getRchild()));  
  126.         }  
  127.         else if(node.getLchild()!=null&&node.getRchild()!=null)  
  128.         {  
  129.             TreeNode temp=findMin(node.getRchild());  
  130.             node.setData(temp.getData());  
  131.             node.setRchild(remove(temp,node.getRchild()));  
  132.         }  
  133.         else  
  134.         {  
  135.             node=(node.getLchild()!=null?node.getLchild():node.getRchild());  
  136.         }  
  137.         return node;  
  138.     }  
  139.     //用于测试的主函数   
  140.     public static void main(String[] args)  
  141.     {  
  142.         BiSearchTree biTree=new BiSearchTree();  
  143.         biTree.createTree();  
  144.         System.out.println("查找二叉树建立完成！");  
  145.         System.out.print("中序遍历结果为：");  
  146.         biTree.midTraverse();  
  147.         System.out.println();  
  148.         biTree.testRemove();  
  149.     }  
  150. }  

 

在本练习中，我们讨论从二叉查找树删除节点问题。删除算法不像插入算法那么简单明了。删除一个值可能有三种不同的情况————该值包含在一个叶子节点中（没有子节点），该值包含在只有一个子节点中或者包含在两个子节点的节点中。

如果该项在叶节点中，直接删除该节点，将其父节点指向它的指针置为空。

如果该项包含在只含一个子节点的节点中，把父节点的指针指向它的子节点再删除这个数据项，就是由它的子节点替代该节点的位置。最后一种情况是最难的。当要删除的节点含有2个子节点时，由另一个叶子节点代替它的位置

编写一个二叉树的成员函数deleteNode，以树的根节点指针和要删除的值为参数。该函数需要找到包含该值的节点，使用上面讨论的算法将该节点删除。该函数还要打印一条信息以表明该节点被删除。当删除完成后，使用中序、前序和后序遍历来确认该节点是否已被正确删除。

///BinSTree.h//

#pragma once

#include <iostream>

#include <stdio.h>

using namespace std;

class BinSTree;

class TreeNode

{

public:

         friend class BinSTree;

         TreeNode(char item, TreeNode *lptr = NULL, TreeNode *rptr = NULL                            ):contents(item),left(lptr),right(rptr){ }

private:

         char contents;         //节点值

         TreeNode *left;         //左孩子

         TreeNode *right;        //右孩子

};

typedef TreeNode* LPTreeNode;

class BinSTree

{

public:

         BinSTree(void);

         ~BinSTree(void);

         void CreatBinSTree(LPTreeNode &tree);   //创建新树

         void MiddleRead(TreeNode *t);     //中序遍历

         void FirstRead(TreeNode *t);     //前序遍历

          void LastRead(TreeNode *t);      //后序遍历

         void Find(TreeNode *tree,char i);    //查找是否存在值为i的节点

         LPTreeNode Search(LPTreeNode &tree);     //

         void DeleteNode(LPTreeNode &tree,char i); //删除值为i的节点

         TreeNode *node;         //根节点

private:

         bool tj;

};

BinSTree.cpp/

#include "BinSTree.h"

BinSTree::BinSTree(void)

{

         tj=false;

}

BinSTree::~BinSTree(void)

{

}

void BinSTree::CreatBinSTree(LPTreeNode &tree)

{

         char c;

         scanf("%c",&c);         //获得一个节点值

         if(c==' ')

         {

                  tree = NULL;

         }

         else

         {

                  tree = new TreeNode(c);      //生成一个新节点

                  CreatBinSTree(tree->left);     //生成左子树

                  CreatBinSTree(tree->right);     //生成右子树

         }

}

void BinSTree::MiddleRead(TreeNode *t)

{

         if(node == NULL)

         {

                  cout<<"空树,无法遍历!"<<endl;

                  return;

         }

         if(t!=NULL)

         {

                  MiddleRead(t->left);

                  cout<<t->contents<<" ";

                  MiddleRead(t->right);

          }

}

void BinSTree::FirstRead(TreeNode *t)

{

         if(node == NULL)

         {

                  cout<<"空树,无法遍历!"<<endl;

                  return;

         }

         if(t!=NULL)

         {

                  cout<<t->contents<<" ";

                  MiddleRead(t->left);

                  MiddleRead(t->right);

         }

}

void BinSTree::LastRead(TreeNode *t)

{

         if(node == NULL)

         {

                  cout<<"空树,无法遍历!"<<endl;

                  return;

         }

         if(t!=NULL)

         {

                  MiddleRead(t->left);

                  MiddleRead(t->right);

                  cout<<t->contents<<" ";

         }

}

void BinSTree::Find(TreeNode *tree,char i)

{

         if(tree!=NULL)

         {

                  if(tree->contents==i)

                  {

                           tj=true;

                           return;

                  }

                  if(tree->left!=NULL)

                  {

                           if(tree->left->contents == i)

                           {

                                    tj=true;

                                    return;

                           }

                  }

                  if(tree->right!=NULL)

                  {

                           if(tree->right->contents == i)

                           {

                                    tj=true;

                                    return;

                           }

                  }

         Find(tree->left,i);

         Find(tree->right,i);

         }

}

LPTreeNode BinSTree::Search(LPTreeNode &tree)

{

         if(tree!=NULL)

         {  

                  if(tree->left->left==NULL && tree->left->right==NULL)

                  {

                           return tree->left;

                   }

         else if(tree->right->left==NULL && tree->right->right==NULL)

         {

                  return tree->right;

         }

         return Search(tree->left);

         return Search(tree->right);

         }

void BinSTree::DeleteNode(LPTreeNode &tree,char i)
{
         Find(tree,i);
         if(!tj)
         {
                  cout<<"无此节点!"<<endl;
                  return;
         }
         if(tree!=NULL)
         {
                  if(node->contents == i)
                  {
                           if(node->left == NULL && node->right == NULL)
                           {
                                    delete node;
                                    node=NULL;
                                     cout<<"已删除节点,当前树为空"<<endl;
                                    return;
                           }
                           else if(node->left != NULL && node->right == NULL)
                           {
                                    TreeNode *p = node;
                                    TreeNode *d = new TreeNode(Search(node)->contents);
                                    d->left = tree->left;
                                    d->right = NULL;
                                     node = d;
                                    delete p;
                                    cout<<"值为"<<i<<"的节点已被删除"<<endl;
                           }
                            else if(node->right != NULL && node->left == NULL)
                           {
                                    TreeNode *p = node;
                                    TreeNode *d = new TreeNode(Search(node)->contents);
                                    d->left = NULL;
                                    d->right = tree->right;
                                    node = d;
                                    delete p;
                                    cout<<"值为"<<i<<"的节点已被删除"<<endl;
                           }
                           else
                            {
                                    TreeNode *p = node;
                                    TreeNode *d = new TreeNode(Search(node)->contents);
                                    d->left = tree->left;
                                     d->right = tree->right;
                                     node = d;
                                    delete p;
                                    cout<<"值为"<<i<<"的节点已被删除"<<endl;
                            }
                  }
                   if(tree->left!=NULL)
                   {
                           if(tree->left->contents == i)
                           {
                                    if(tree->left->left == NULL && tree->left->right != NULL)
                                    {
                                             TreeNode *p = tree->left;
                                              tree->left = tree->left->right;
                                             delete p;
                                             cout<<"值为"<<i<<"的节点已被删除"<<endl;
                                    }
                                    else if(tree->left->left == NULL && tree->left->right == NULL)
                                    {
                                             delete tree->left;
                                             tree->left = NULL;
                                             cout<<"值为"<<i<<"的节点已被删除"<<endl;
                                    }
                                    else if(tree->left->left != NULL && tree->left->right == NULL)
                                     {
                                             TreeNode *p = tree->left;
                                             tree->left = tree->left->left;
                                             delete p;
                                             cout<<"值为"<<i<<"的节点已被删除"<<endl;
                                    }
                                    else if(tree->left->left != NULL && tree->left->right != NULL)
                                     {
                                             TreeNode *p = tree->left;
                                             TreeNode *d = new TreeNode(Search(node)->contents);
                                             d->left = tree->left->left;
                                             d->right = tree->left->right;
                                            tree->left = d;
                                             delete p;
                                    }
                                    return;
                           }
                  }
                   if(tree->right!=NULL)
                  {
                           if(tree->right->contents == i)
                           {
                                    if(tree->right->left == NULL && tree->right->right == NULL)
                                    {
                                             delete tree->right;
                                             tree->right = NULL;
                                             cout<<"值为"<<i<<"的节点已被删除"<<endl;
                                    }
                                    else if(tree->right->left != NULL && tree->right->right == NULL)
                                    {
                                             TreeNode *p = tree->right;
                                              tree->right = tree->right->left;
                                             delete p;
                                             cout<<"值为"<<i<<"的节点已被删除"<<endl;
                                    }
                                    else if(tree->right->left == NULL && tree->right->right != NULL)
                                    {
                                             TreeNode *p = tree->right;
                                             tree->right = tree->right->right;
                                             delete p;
                                             cout<<"值为"<<i<<"的节点已被删除"<<endl;
                                     }
                                    else if(tree->right->left != NULL && tree->right->right != NULL)
                                    {
                                             TreeNode *p = tree->right;
                                             TreeNode *d = new TreeNode(Search(node)->contents);
                                              d->left = tree->right->left;
                                             d->right = tree->right->right;
                                             tree->right = d;
                                             delete p;
                                     }
                                    return;
                           }
                  }
                  DeleteNode(tree->left,i);
                  DeleteNode(tree->right,i);
         }
}

 

 

 

 

总体思想：分多种情况讨论

1.被删除节点没有子树的情况，直接删除，并修改对应父节点的指针为空。

2.对于只有一个子树的情况，考虑将其子树作为其父节点的子树，关于是左还是右，根据被删除的节点确定。

3.最复杂的是有两个子数的情况，可以考虑两种方法，都是同样的思想：用被删除节点A的左子树的最右节点或者A的右子树的最左节点作为替代A的节点，并修改相应的最左或最右节点的父节点的指针，修改方法类似2 ，不做细致讨论

 

/*************二叉树的节点的删除***********/

/*********该程序描述了从递归建立二叉树到查找*********/
/*********以及删除的全过程，也算是对前面几个*********/
/*********程序的联习与总结***************************/
#include<stdio.h>
#include<stdlib.h>

#define Maxsize 16

//定义二叉树节点
struct treenode
{
 int data;
 struct treenode* left;
 struct treenode* right;
};
typedef treenode Node;
typedef Node* btree;

//递归建立二叉树
btree create_btree(int* nodelist,int postion)
{
 btree newnode;
 
 if(nodelist[postion]==0||postion>=Maxsize)
     return NULL;
 else
 {
  newnode=(btree) malloc(sizeof(Node));
  newnode->data=nodelist[postion];
  newnode->left=create_btree(nodelist,postion*2);
  newnode->right=create_btree(nodelist,postion*2+1);
  return newnode;
 }
}

/********查找二叉树的节点********/
btree search(btree root,int node)
{
 btree point;
 point=root;
 if(point==NULL)
  return root;
 else
  if(point->data==node)
   return point;
  else
   if(point->data>node)
    search(point->left,node);
   else
    search(point->right,node);
}

/********第二种查找方法，记录其父节点的值********/
btree binary_search(btree point,int node,int *postion)
{
 btree parent;

 parent=point;
 *postion=0;

 while(point!=NULL)
 {
  if(point->data==node)
   return parent;
  else
  {
   parent=point;
   if(point->data>node)
   {
    point=point->left;
    *postion=-1;

   }
   else
   {
    point=point->right;
    *postion=1;
   }
  }

 }
 return NULL;

}

/**********删除二叉树节点的操作***********/
btree deletenode(btree root,int node)
{
 btree parent;
 btree point;
 btree child;
    int postion;


 parent=binary_search(root,node,&postion); 
 //二叉树为空的情况
   if(parent==NULL)
  return root;
   else
   {
    switch(postion)
   { case -1:point=parent->left;break;

  case 1 :point=parent->right;break;

  case  0 :point=parent;break;
   }

 if(point->left==NULL&&point->right==NULL)
 {
  switch(postion)
  {
         case -1:parent->left=NULL;break;
         case 1:parent->right=NULL;break;
         case 0:parent=NULL;break;
  }

    free(point);
   return root;
    }

 if(point->left==NULL&&point->right!=NULL)
  {
   if(postion==-1)
    parent->left=point->right;
   else
    if(postion==1)
    parent->right=point->right;
    else
     root=root->right;

   free(point);
   return root;
  }
  
 if(point->left!=NULL&&point->right==NULL)
 {
  if(postion==-1)
   parent->left=point->left;
  else
   if(postion==1)
    parent->right=point->left;
   else
    root=root->left;
  return root;
 }

 if(point->left!=NULL&& point->right!=NULL)
 {
  parent=point;
  child=point->left;
  while(child->right!=NULL)
  {
   parent=child;
   child=child->right;
  }
  point->data=child->data;
  if(parent->left=child)
   parent->left=child->left;
  else
   parent->right=child->left;

  free(child);
  return root;
    }
  }

}

/*********中序遍历二叉树*************/
void Inorder(btree point)
{
 if(point!=NULL)
 {
  Inorder(point->left);
  printf("[%2d]",point->data);
  Inorder(point->right);
 }
}

/*********主程序测试函数***********/
void main()
{
 btree root=NULL;
 int deletetree;

 int nodelist[16]={0,5,4,6,2,0,0,8,1,3,0,0,0,0,7,9};

 root=create_btree(nodelist,1);

 printf("/n the original tree is");
 Inorder(root);
 printf("/n");

 printf("Input the value of the number /n");
 int test;
 scanf("%d",&test);

 root=deletenode(root,test);
 printf("/n the deleted tree is /n");
 Inorder(root);
 printf("/n");

 
}

 

chummyhe89
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉查找树 减治法——C++代码
05-24
这种特性使得二叉查找树在搜索、插入和删除操作上的效率比普通二叉树更高。 减治法（Divide and Conquer，简称D&C）是计算机科学中一种常见的算法设计策略，通过将大问题分解为小问题来解决。在二叉查找树的应用中...
二叉查找树python二叉查找树源码
11-22
这种特性使得二叉查找树非常适合进行查找、插入和删除操作。 在给定的Python代码中，定义了两个类：`Node` 和 `BST`。`Node` 类用于创建二叉树的节点，包含三个属性：`data` 存储节点的键，`lchild` 指向左子节点的...
5.3 删除二叉搜索树的最大元素和最小元素
weixin_34060741的博客
04-11 774
5.3 删除二叉搜索树的最大元素和最小元素 在5.2中完成了树的遍历，这一节中将对如何从二叉搜索树中删除最大元素和最小元素做介绍：我们要想删除二分搜索树的最小值和最大值，就需要先找到二分搜索树的最小值和最大值，其实也还是很容易的，因为根据二叉搜索树的特点，它的左子树一定比当前节点要小，所以二叉搜索树的最小值一定是左子树一直往下走，一直走到底。同...
数据结构——二叉搜索树的实现、删除（最大值和最小值、最大值和最小值）
qq_52301431的博客
08-25 1044
删除节点要从查找要删的节点开始, 找到节点后, 需要考虑三种情况: 该节点是叶结点(没有子节点, 比较简单) 没有子节点的根节点 该节点有一个子节点(也相对简单) 该节点有两个子节点.(情况比较复杂, 我们后面慢慢道来)...
（Swift 实现）二叉搜索树 —— 创建，最大，最小，查找，插入，删除，前驱，后继，中序遍历
赫凯的博客
03-24 638
了解了二叉堆之后，二叉搜索树就好说了，就是一个节点，左边的子节点是不可能比他大的，右边的子节点是一定大于它的，想了半天终于把创建给写好了。直接看代码import UIKitvar str = &quot;二叉搜索树&quot; //这个就不跟前面的完全二叉树一样了，得自己建了类或者结构体了，我建了个类 class erchaTreeNote { var data: Int var leftChild:
二叉搜索树的查找、最值查找、插入和删除
大力海棠的博客
05-14 9664
对于一棵二叉搜索树，如果不为空，它应该满足以下三个特点：1、树上的任一结点，该结点的值都大于它的非空左子树的值。2、树上的任一结点，该结点的值都小于它的非空右子树的值。3、任一结点的左右子树都是二叉搜索树。对于二叉搜索树的查找，思路方法是：1、从根结点开始查找，如果树为空，就返回NULL。2、如果树不空，就让数据X和根结点的数据Data作比较。3、如果X的值大于根结点的Data，就往右子树中进行搜...
二叉排序树的查找、插入、删除，最大值、最小值
GQ_666的博客
10-20 578
查找递归实现 查找非递归实现 查找最小值的递归实现 查找最大值的非递归实现 向二叉排序树中插入结点 删除节点 下面代码，拿去即可运行： package leetcode; public class TreeNode { private Integer value; private TreeNode left; private TreeNode right; public TreeNode() { } public TreeN
查找算法【二叉查找树】 - 二叉查找树的删除
谢谢你们的关注
10-28 2789
查找算法【二叉查找树】 - 二叉查找树的删除
二叉查找树的删除操作
qq_44687268的博客
08-21 1086
删除操作 删除的节点为叶子节点，直接删除。 删除的节点有右子树，用后继(successor)节点代替要删除的节点，递归删除后继节点。 删除的节点无右子树有左子树，用前驱(predecessor)节点代替要删除的节点，递归删除前驱节点。 递归实现 1.先找到要删除的节点， ​ 如果key>root.val说明要删除的节点在当前节点的右子树，root.right=deleteNode(key); 如果key<root.val说明要删除的节点在当前节点的左子树，则root.left=d
二叉查找树详细介绍.docx
06-27
插入操作涉及在适当位置插入新节点，而删除操作可能需要重新连接分支以保持二叉查找树的性质。 总之，二叉查找树是一种重要的数据结构，它提供了一种快速查找、插入和删除有序数据的方法。理解和熟练使用二叉查找树...
c++实现二叉查找树示例
09-04
在C++中实现二叉查找树，我们需要定义两个类，一个是数据节点`dNode`，另一个是二叉树节点`bstNode`，以及一个用于操作二叉查找树的类`bst`。 首先，数据节点`dNode`包含了三个成员变量：`name`表示姓名，`age`表示...
二叉查找树
01-20
这种结构使得二叉查找树在查找、插入和删除操作上的平均时间复杂度为O(logn)，其中n是树中节点的数量。相比于线性查找的O(n)复杂度，二叉查找树在处理大量数据时具有显著优势。 **插入操作**： 插入一个新元素到...
C#数据结构与算法学习笔记 删除树中元素，计算树的最大高度
Mr_Tfos的博客
05-23 189
1.删除最大和最小元素 找到最小值、最大值： public E Min() { if (IsEmpty) throw new ArgumentException("空树！"); return Min(root).e; } //返回以node为根的二叉查找树的最小值所在的节点 private Node Min(Node node)
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 781
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 333
基于Pygame和PIL的迷宫生成器
C语言——函数递归
2406_83392683的博客
08-18 369
递归是一种解决问题的方法，在C语言中，就是。但是，如果递归无限地进行下去，就会出现栈溢出，上述就是一个典型例子。
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 571
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
Leetcode 219. 存在重复元素 II⭐️
最新发布
铁马冰河入梦来
08-20 356
哈希表解决存在重复元素二问题
noip2001数的划分
no_play_no_games的博客
08-18 190
将整数n分成k份，且每份不能为空，任意两份不能相同(不考虑顺序)。例如：n=7，k=3，下面三种分法被认为是相同的。1，1，5;1，5，1;5，1，1;问有多少种不同的分法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值