AVL Tree | Set 2 (Deletion)

最新推荐文章于 2023-01-29 15:53:02 发布
最新推荐文章于 2023-01-29 15:53:02 发布
阅读量307 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hellobettershero/article/details/105040517
版权

原文链接：https://www.geeksforgeeks.org/avl-tree-set-2-deletion/

Steps to follow for deletion.
To make sure that the given tree remains AVL after every deletion, we must augment the standard BST delete operation to perform some re-balancing. Following are two basic operations that can be performed to re-balance a BST without violating the BST property (keys(left) < key(root) < keys(right)).

  1. Left Rotation
  2. Right Rotation
T1, T2 and T3 are subtrees of the tree rooted with y (on left side)
or x (on right side)
                y                               x
               / \     Right Rotation          /  \
              x   T3   – - – - – - – >        T1   y
             / \       < - - - - - - -            / \
            T1  T2     Left Rotation            T2  T3
Keys in both of the above trees follow the following order
      keys(T1) < key(x) < keys(T2) < key(y) < keys(T3)
So BST property is not violated anywhere.

c) Right Right Case

  z                                y
 /  \                            /   \ 
T1   y     Left Rotate(z)       z      x
    /  \   - - - - - - - ->    / \    / \
   T2   x                     T1  T2 T3  T4
       / \
     T3  T4

C implementation
Following is the C implementation for AVL Tree Deletion. The following C implementation uses the recursive BST delete as basis. In the recursive BST delete, after deletion, we get pointers to all ancestors one by one in bottom up manner. So we don’t need parent pointer to travel up. The recursive code itself travels up and visits all the ancestors of the deleted node.

我们使用递归的程序进行AVL树删除结点，在用递归程序时，在删除节点后，这个时候的指针就是指向其父亲，再自动递归返回时，就会进行从下到上访问其祖父结点。

  1. Perform the normal BST deletion.
    1）进行正常的BST删除。

  2. The current node must be one of the ancestors of the deleted node. Update the height of the current node.
    现在结点指向删除结点的父亲结点，更新其高度。

  3. Get the balance factor (left subtree height – right subtree height) of the current node.
    再计算其平衡因子。

  4. If balance factor is greater than 1, then the current node is unbalanced and we are either in Left Left case or Left Right case. To check whether it is Left Left case or Left Right case, get the balance factor of left subtree. If balance factor of the left subtree is greater than or equal to 0, then it is Left Left case, else Left Right case.
    如果平衡因子大于1，那么现在结点是不平衡的，也么是left left case or left right case,为了检查到底是哪一个，我们进行得到他左子树的平衡因子。如果左子树的平衡因子>=0，那么就是left left case,否则就是left right case.

  5. If balance factor is less than -1, then the current node is unbalanced and we are either in Right Right case or Right Left case. To check whether it is Right Right case or Right Left case, get the balance factor of right subtree. If the balance factor of the right subtree is smaller than or equal to 0, then it is Right Right case, else Right Left case.

#include<stdio.h>
#include<iostream>
using namespace std;
class Node{
public:
    int data;
    Node *left,*right;
    int height;
    Node():data(0),left(NULL),right(NULL),height(0){};
};

int getHeight(Node *node);
int max(int a,int b);
Node* newNode(int key);
Node *rightRotate(Node *node);
Node *leftRotate(Node *node);
int getBalance(Node *node);
Node *insert(Node *node,int key);
Node *minValueNode(Node *node);
Node *deletNode(Node *root,int key);
void preOrder(Node *node);

int main(){
    Node *root=NULL;
    root = insert(root, 9);
    root = insert(root, 11);
    root = insert(root, 10);
    root = insert(root, 6);
    root = insert(root, 5);
    root = insert(root, 0);
    root = insert(root, 2);
    root = insert(root, -1);
    root = insert(root, 1);
    preOrder(root);
    printf("\n");
    root = deletNode(root,10);
    preOrder(root);
    printf("\n");
    return 0;
}

int getHeight(Node *node){
    if(node==NULL){
        return 0;
    }return node->height;
}
// A utility function to get maximum of two integers
int max(int a,int b){
    return (a>b)?a:b;
}
Node* newNode(int key){
    Node* node=new Node();
    node->data=key;
    return node;
}

Node *rightRotate(Node *node){
    Node *x=node->left;
    Node *T2=x->right;
    x->right=node;
    node->left=T2;
    node->height=max(getHeight(node->left),getHeight(node->right))+1;
    x->height=max(getHeight(x->left),getHeight(x->right))+1;
    return x;
}

Node *leftRotate(Node *node){
    Node *y=node->right;
    Node *T2=y->left;
    y->left=node;
    node->right=T2;
    node->height=max(getHeight(node->left),getHeight(node->right))+1;
    y->height=max(getHeight(y->left),getHeight(y->right))+1;
    return y;
}

int getBalance(Node *node){
    if(node==NULL){return 0;}
    return (getHeight(node->left)-getHeight(node->right));
}

Node *insert(Node *node,int key){
    if(node==NULL){return newNode(key);}
    else if(key>node->data){
        node->right=insert(node->right,key);
    }else if(key<node->data){
        node->left=insert(node->left,key);
    }else return node;
    node->height=max(getHeight(node->left),getHeight(node->right))+1;
    printf("node->data=%d,node->height=%d\n",node->data,node->height);
    int balfac=getBalance(node);
    // If this node becomes unbalanced,then there are 4 cases
    if(balfac>1&&key<node->left->data){
        printf("rightRotate:%d\n",node->data);
        return rightRotate(node);
    }
    if(balfac>1&&key>node->left->data){
        printf("001:leftRotate(%d)\n",node->left->data);
        node->left=leftRotate(node->left);
        printf("002:rightRotate(%d)\n",node->data);
        return  rightRotate(node);
    }
    if(balfac<-1&&key>node->right->data){
        cout<<"leftRotate:"<<node->data<<endl;
        return leftRotate(node);
    }
    if(balfac<-1&&key<node->right->data){
        printf("001:rightRotate(%d)\n",node->right->data);
        node->right=rightRotate(node->right);
        printf("002:leftRotate(%d)\n",node->data);
        return  leftRotate(node);
    }
    return node;        /* return the (unchanged) node pointer */
}
// Recursive function to delete a node with given key from subtree with
// given root. It returns root of the modified subtree.
Node *minValueNode(Node *node){
    Node *current=node;
    while(current->left!=NULL){
        current=current->left;
    }
    return current;
}
Node *deletNode(Node *root,int key){
    // STEP 1: PERFORM STANDARD BST DELETE
    if(root==NULL){return root;}
    else if(key>root->data){
        root->right=deletNode(root->right,key);
    }else if(key<root->data){
        root->left=deletNode(root->left,key);
    }else{      //找到了
        // node with only one child or no child
        if(root->left==NULL||root->right==NULL){
            Node *tmp=root->left?root->left:root->right;
            // No child case
            if(tmp==NULL){
                tmp=root;
                root=NULL;
            }else{
                *root=*tmp;     // Copy the contents of
                free(tmp);      // the non-empty child
            }
        }else{
            //node with two children: Get the inorder
            // successor (smallest in the right subtree)
            Node *tmp=minValueNode(root->right);
            // Copy the inorder successor's data to this node
            root->data=tmp->data;
            // Delete the inorder successor
            root->right=deletNode(root->right, tmp->data);
        }
    }
    // STEP 2: UPDATE HEIGHT OF THE CURRENT NODE
    root->height=1+max(getHeight(root->left),getHeight(root->right));
    // STEP 3: GET THE BALANCE FACTOR OF THIS NODE (to check whether this
    // node became unbalanced)
    int balfac=getBalance(root);
    // If this node becomes unbalanced,then there are 4 cases(just like insert operation)
    // Left Left Case
    if(balfac>1&&getBalance(root->left)>=0){
        return rightRotate(root);
    }
    // Left Right Case
    if(balfac>1&&getBalance(root->left)<0){
        root->left=leftRotate(root->left);
        return rightRotate(root);
    }
    // Right Right Case
    if(balfac<-1&&getBalance(root->right)<=0){
        return leftRotate(root);
    }
    if(balfac<-1&&getBalance(root->right)>0){
        root->right=rightRotate(root->right);
        return leftRotate(root);
    }
    return root;
}

void preOrder(Node *node){
    if(node==NULL){
        return ;
    }
    printf("%d->",node->data);
    preOrder(node->left);
    preOrder(node->right);
}



// C++ program to delete a node from AVL Tree
#include<iostream>
#include<stdio.h>
using namespace std;

// An AVL tree node
class Node
{
    public:
    int key;
    Node *left;
    Node *right;
    int height;
};

// A utility function to get maximum
// of two integers
int max(int a, int b);

// A utility function to get height
// of the tree
int height(Node *N)
{
    if (N == NULL)
        return 0;
    return N->height;
}

// A utility function to get maximum
// of two integers
int max(int a, int b)
{
    return (a > b)? a : b;
}

/* Helper function that allocates a
new node with the given key and
NULL left and right pointers. */
Node* newNode(int key)
{
    Node* node = new Node();
    node->key = key;
    node->left = NULL;
    node->right = NULL;
    node->height = 0; // new node is initially
                    // added at leaf
    return(node);
}

// A utility function to right
// rotate subtree rooted with y
// See the diagram given above.
Node *rightRotate(Node *y)
{   printf("rightRotate:%d\n",y->key);
    Node *x = y->left;
    Node *T2 = x->right;

    // Perform rotation
    x->right = y;
    y->left = T2;

    // Update heights
    y->height = max(height(y->left),
                    height(y->right)) + 1;
    x->height = max(height(x->left),
                    height(x->right)) + 1;

    // Return new root
    return x;
}

// A utility function to left
// rotate subtree rooted with x
// See the diagram given above.
Node *leftRotate(Node *x)
{   printf("leftRotate:%d\n",x->key);
    Node *y = x->right;
    Node *T2 = y->left;

    // Perform rotation
    y->left = x;
    x->right = T2;

    // Update heights
    x->height = max(height(x->left),
                    height(x->right)) + 1;
    y->height = max(height(y->left),
                    height(y->right)) + 1;

    // Return new root
    return y;
}

// Get Balance factor of node N
int getBalance(Node *N)
{
    if (N == NULL)
        return 0;
    return height(N->left) -
        height(N->right);
}

Node* insert(Node* node, int key)
{
    /* 1. Perform the normal BST rotation */
    if (node == NULL)
        return(newNode(key));

    if (key < node->key)
        node->left = insert(node->left, key);
    else if (key > node->key)
        node->right = insert(node->right, key);
    else // Equal keys not allowed
        return node;

    /* 2. Update height of this ancestor node */
    node->height = 1 + max(height(node->left),
                        height(node->right));
    /* 3. Get the balance factor of this
        ancestor node to check whether
        this node became unbalanced */
    int balance = getBalance(node);
    printf("node->data=%d,height=%d,balance=%d\n",node->key,node->height,balance);
    // If this node becomes unbalanced,
    // then there are 4 cases

    // Left Left Case
    if (balance > 1 && key < node->left->key){
       
        return rightRotate(node);}

    // Right Right Case
    if (balance < -1 && key > node->right->key){
        return leftRotate(node);}

    // Left Right Case
    if (balance > 1 && key > node->left->key)
    {
        node->left = leftRotate(node->left);
        return rightRotate(node);
    }

    // Right Left Case
    if (balance < -1 && key < node->right->key)
    {
        node->right = rightRotate(node->right);
        return leftRotate(node);
    }

    /* return the (unchanged) node pointer */
    return node;
   // printf("root:%d\n",node->key);
}

/* Given a non-empty binary search tree,
return the node with minimum key value
found in that tree. Note that the entire
tree does not need to be searched. */
Node * minValueNode(Node* node)
{
    Node* current = node;

    /* loop down to find the leftmost leaf */
    while (current->left != NULL)
        current = current->left;

    return current;
}

// Recursive function to delete a node
// with given key from subtree with
// given root. It returns root of the
// modified subtree.
Node* deleteNode(Node* root, int key)
{
    
    // STEP 1: PERFORM STANDARD BST DELETE
    if (root == NULL)
        return root;

    // If the key to be deleted is smaller
    // than the root's key, then it lies
    // in left subtree
    if ( key < root->key )
        root->left = deleteNode(root->left, key);

    // If the key to be deleted is greater
    // than the root's key, then it lies
    // in right subtree
    else if( key > root->key )
        root->right = deleteNode(root->right, key);

    // if key is same as root's key, then
    // This is the node to be deleted
    else
    {
        // node with only one child or no child
        if( (root->left == NULL) ||(root->right == NULL) )
        {
            Node *temp = root->left ?
                        root->left :
                        root->right;

            // No child case
            if (temp == NULL)
            {
                temp = root;
                root = NULL;
            }
            else // One child case
            *root = *temp; // Copy the contents of
                        // the non-empty child
            free(temp);
        }
        else
        {
            // node with two children: Get the inorder
            // successor (smallest in the right subtree)
            Node* temp = minValueNode(root->right);

            // Copy the inorder successor's
            // data to this node
            root->key = temp->key;

            // Delete the inorder successor
            root->right = deleteNode(root->right,
                                    temp->key);
        }
    }

    // If the tree had only one node
    // then return
    if (root == NULL)
    return root;

    // STEP 2: UPDATE HEIGHT OF THE CURRENT NODE
    root->height = 1 + max(height(root->left),
                        height(root->right));

    // STEP 3: GET THE BALANCE FACTOR OF
    // THIS NODE (to check whether this
    // node became unbalanced)
    int balance = getBalance(root);

    // If this node becomes unbalanced,
    // then there are 4 cases

    // Left Left Case
    if (balance > 1 &&
        getBalance(root->left) >= 0)
        return rightRotate(root);

    // Left Right Case
    if (balance > 1 &&
        getBalance(root->left) < 0)
    {
        root->left = leftRotate(root->left);
        return rightRotate(root);
    }

    // Right Right Case
    if (balance < -1 &&
        getBalance(root->right) <= 0)
        return leftRotate(root);

    // Right Left Case
    if (balance < -1 &&
        getBalance(root->right) > 0)
    {
        root->right = rightRotate(root->right);
        return leftRotate(root);
    }
    return root;
}

// A utility function to print preorder
// traversal of the tree.
// The function also prints height
// of every node
void preOrder(Node *root)
{
    if(root != NULL)
    {
        cout << root->key << " ";
        preOrder(root->left);
        preOrder(root->right);
    }
}

// Driver Code
int main()
{
Node *root = NULL;

    /* Constructing tree given in
    the above figure */
    root = insert(root, 12);
    root = insert(root, 11);
    root = insert(root, 10);
    root = insert(root, 9);
    root = insert(root, 8);
    root = insert(root, -1);
    root = insert(root, 1);
    root = insert(root, 0);
    root = insert(root, 21);
    root = insert(root, 14);
    root = insert(root, 13);
    root = insert(root, 20);
    root = insert(root, 23);
    root = insert(root, 18);
    cout << "Preorder traversal of the "
            "constructed AVL tree is \n";
    preOrder(root);

    root = deleteNode(root, 20);


    cout << "\nPreorder traversal after"
        << " deletion of 10 \n";
    preOrder(root);

    return 0;
}

// This code is contributed by rathbhupendra
hellobettershero
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Geeks - AVL Tree Deletion 平衡二叉树 删除操作
靖空间
05-27 1345
注意： 1 判断一个节点是否平衡的方法 2 平衡一个节点的方法 ： 我这里比原文改进一点，独立出一个平衡节点的函数balanceNode()，这样一个函数可以用来平衡插入和删除操作，使得代码更加简洁了。 这样修改之后就使得平衡二叉树好像和一般二叉树的操作比较，就是多了一个平衡操作。 3 删除操作情况很多，很困难，一定要理清思路。十分容易出bug的地方。 这里是查找后继节点的值，填补上到
AVL树的删除
qq_39208237的博客
07-05 5010
引言 AVL树的定义及性质及其重要的插入方法，我已在AVL树的插入一文中详细阐述过了，其中重要的旋转也已进行详细描述。 本文就不再赘述了，直接使用，要是不清楚的小伙伴，还请移步AVL树的插入再回头复习一下下。 AVL树的删除 AVL树的删除步骤如下： 寻找删除目标（存不存在，定位出目标） 判断删除目标的类型，使用转换的思路，将其转化为删除叶子 将删除目标与AVL树链接断开，调整平衡，完成删除 寻找删除目标 寻找删除目标的思路很简单，因AVL树也属于BST，因此寻找目标的做法与BST的删除思路基本一致。
数据结构与算法3 AVL树
ohuojiuwo的博客
01-29 2927
将 26, 13, 44, 51, 98, 37, 66, 73 顺序插入一棵初始为空的AVL树。将 7, 8, 9, 2, 3, 5, 6, 4 顺序插入一棵初始为空的AVL树。在将{42,26,8,70,102,56,2}插入一个初始空的 AVL 树时，下列哪个语句为真？如果节点{1,2,3,4}的 AVL 树的深度为3(根的深度为1) ，那么节点4可能是根。将2,1,4,5,9,3,6,7插入到一个初始的空 AVL 树中。非空的平衡二叉树中插入一个结点，原有结点中至少一个结点的平衡因子会改变。
数据结构与算法 AVL查找树
m0_51424656的博客
01-10 2807
1-1 The inorder traversal sequence of an AVL tree must be in sorted (non-decreasing) order. T AVL 树的中序遍历序列必须是有序（非递减）顺序 1-3 An AVL tree with the balance factors of all the non-leaf nodes being 0 must be a perfect binary tree.
AVL平衡树的理解（插入、查找、删除）
Dallas01的博客
11-21 273
AVL平衡树的理解（插入、查找、删除） Dargon 2020/11/21 所遇到的的重要的问题: 教科书 来自：《数据结构和算法分析》第四章 树 AVL平衡树出现的原因 在一般的二叉树的插入和删除操作中，想想出现最坏的情况， 例如以20-26的顺讯进行插入的话，就类似形成一个线性链表的结构，让树的深度变得很深，不易搜索 进行删除操作的时候，一般过程，找到需要删除的节点，然后，找到该节点左子树的最大值，将其值保存下来，进行删除，把值更新到原本需要删除的节点，这样完成一次删除操作。久
AVltree_avltree_
09-30
2. `avltree.h`：这是一个头文件，可能包含了AVL树相关的数据结构定义和函数声明。在C语言中，头文件用于在不同的源文件间共享函数和数据结构的定义，使得其他文件可以包含并使用这些定义。 3. `avltree_test.c`：...
avltree算法.rar_avl_avl tree
09-21
AVL树是一种自平衡二叉查找树（Binary Search Tree, BST），由Georgy Adelson-Velsky和E.M. Landis在1962年提出，因此得名AVL，AVL是两位发明者姓名的首字母。这种数据结构在进行插入和删除操作时能保持树的高度平衡...
AVLTree.rar_avltree_in
09-23
2. 删除操作：删除AVL树中的一个节点比插入更复杂，因为它可能涉及多个节点的调整。基本步骤包括找到待删除节点、处理删除节点的三种情况（无子节点、一个子节点、两个子节点）、重新平衡树。 3. 查找操作：在AVL树...
avl_tree.zip_avl tree
09-20
在avl_tree.c文件中，你可以找到上述所有操作的C语言实现。代码通常会包含一个节点结构体定义，以及插入、删除、查找、rank（获取节点在有序遍历中的位置）以及各种遍历函数。rank函数对于AVL树来说是一个很有用的...
AVLTree.rar_avl_java avltree_tree
09-24
AVL树（Adelson-Velsky and Landis Tree）是一种自平衡二叉查找树，它的概念最早由G. M. Adelson-Velsky和E. M. Landis在1962年提出。这种数据结构在进行插入和删除操作时能保持树的高度平衡，从而保证了查找、插入...
AVL树插入、删除的分析与实现
有点甜
07-10 4339
AVL树基本概念 首先，AVL树也是一种
没事儿就学习（2）：AVL树删除
WHU_Giser的博客
06-01 799
       在上一篇文章里莫名其妙的说了AVL树的添加节点，那么这一次我们就可以简单的说一说AVL树的删除节点问题了。学会了添加，删除还会很难吗？当然很简单的，只需要先用递归找到那个需要删除的节点之后，如果其有左孩子，把自己删了然后拿左孩子顶替它，然后把左孩子的右孩子连向它的右孩子（我晕），如果其没有左孩子但是有右孩子，那就拿右孩子顶替他，如果它是个孤寡老人，那就不费事了，直接删了完事儿。   ...
LintCode "Remove Node in Binary Search Tree"
weixin_30274627的博客
10-05 66
Not hard to find a solution, but there are several corner cases. class Solution { public: /** * @param root: The root of the binary search tree. * @param value: Remove the node ...
平衡二叉树（AVL）的创建、插入、删除
D20152107的博客
09-11 3370
一、概念 平衡二叉树（下文称AVL）是满足每个结点的左右子树高度（亦称深度）之差在{0，1，-1}这个范围内的二叉排序树（二叉排序树也叫二叉搜索树）。 AVL的优势是在查找时避免了出现一般二叉排序树查找的最坏情况。但是AVL在经过插入或删除结点的操作之后可能出现不平衡的情况，所以每次插入或删除完之后要判断是否平衡，不平衡就需要rebalance.这会增加插入删除的复杂度。 二、AVL的创...
惰性删除的AVL Tree
no_cross_no_crown的专栏
01-17 1308
<br />/** * Grant D Hawkes * This file implements and AVL Tree including a modified version of lazy deletion. * Much of the code in this file is from Mark Alan Weiss' Data Structures and Algorithms * book and it's accompaning website. */ impor
AVL树删除节点deletenode函数分析 （C++实现）
Tokameine的博客
02-05 1509
先放一下代码：（这里只放一些必要的内容。因为每个人的习惯不同，只有思路可以借鉴。请注意注释。关于旋转函数，我在上一篇帖子分析insert时贴出过，仅供参考。如果在某个地方没有理解，请先继续往下看一会，或许能找到答案。如果发现代码和解释有问题，请务必指出。） typedef struct avlnode* position; typedef struct avlnode* avltree; struct avlnode{ avltree left; avltree right; int heigh.
数据结构之AVLTree（04-1：Root of AVL Tree）
嵇康的专栏
01-28 725
// Root_of_AVL_Tree.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include #include #include #define MAX 50 int length=0; typedef  struct  node { i
AVL Tree 平衡二叉树基本插入删除节点功能的实现
霖林烟雨
09-18 1万+
简述： 实现AVL 树，主要是两个功能 ： 插入某节点和删除某节点 AVL Tree的定义， 1. 是一棵二叉搜索树（故而每个节点是惟一的, 如果出现重复数字会破坏平衡树的算法） 2. 每个节点左右子树的高度之差（平衡因子）相差最多为1 实现： 为了使所得的二叉树为平衡二叉树， 首先在BSTNode中加了一个计算节点高度的方法getHeight()， 当两个节点高度相
AVL树的插入与删除（详解）
热门推荐
老毒的博客
04-16 1万+
AVL树的插入与删除（详解） 平衡二叉树的定义就不在这里赘述了，平衡二叉树的插入与删除都是基于平衡二叉树的查找进行的。平衡二叉树的查找和二叉树的查找又是一样的。 插入的话，我们从平衡二叉树的根结点出发查找我们需要插入的元素，如果查找到了表明该元素已经存在树中，因此就不用插入了，若没有查找到该元素就要创建这个元素结点，将结点插入我们所访问的那个查找失败的结点位置（查找失败结点是我们虚构的一个结点）。...
avl tree insertion
最新发布
04-06
AVL树插入是指在AVL树中添加新元素的过程。在插入元素后，AVL树需要进行平衡操作，以保证树的高度平衡，即左右子树的高度差不超过1。平衡操作有四种：左旋、右旋、左右旋和右左旋。通过这些操作，AVL树可以自我调整...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值