双向链表基本操作

最新推荐文章于 2023-11-10 12:58:42 发布
最新推荐文章于 2023-11-10 12:58:42 发布
阅读量293 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 双向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adorable_/article/details/79634604
版权

尾插

描述

尾删

描述

头插

描述

头删

描述

查找元素在链表中的位置

描述

往指定位置之前插入一个元素

描述

往指定位置之后插入一个元素

描述

删除指定位置的元素

描述

删除指定值的元素

描述

删除指定值的所有元素

描述

具体代码如下：

①dlinklist.h

#pragma once
#include <stddef.h>
#include <stdio.h>

typedef char DLinkType;

typedef struct DLinkNode{
    DLinkType data;
    struct DLinkNode* next;
    struct DLinkNode* prev;
}DLinkNode;

void DLinkListInit(DLinkNode** head);           //初始化

DLinkNode* DLinkListPushBack(DLinkNode* head, DLinkType value);         //尾插

void DLinkListPopBack(DLinkNode* head);             //尾删

void DLinkListPushFront(DLinkNode* head, DLinkType value);          //头插

void DLinkListPopFront(DLinkNode* head);            //头删

DLinkNode* DLinkListFind(DLinkNode* head, DLinkType to_find);           //查找元素在链表中的位置

void DLinkListInsert(DLinkNode* pos, DLinkType value);      //往指定位置之前插入一个元素

void DLinkListInsertAfter(DLinkNode* pos, DLinkType value);     //往指定位置之后插入一个元素

void DLinkListErase(DLinkNode* head, DLinkNode* pos);       //删除指定位置的元素

void DLinkListRemove(DLinkNode* head, DLinkType value);     //删除指定值的元素

void DLinkListRemoveAll(DLinkNode* head, DLinkType value);       //删除指定值的所有元素

size_t DLinkListSize(DLinkNode* head);       //求链表元素个数

int DLinkListEmpty(DLinkNode* head);        //判断链表是否为空，为空返回1，否则返回0

void DLinkListDestroy(DLinkNode** head);        //销毁链表

②dlinklist.c

#include "dlinklist.h"

#include <stdlib.h>
#include <assert.h>

DLinkNode* CreateDLinkListNode(DLinkType value)
{
    DLinkNode* ptr = (DLinkNode*)malloc(sizeof(DLinkNode));
    ptr->data = value;
    ptr->next = ptr;
    ptr->prev = ptr;
    return ptr;
}

void DestroyDLinkListNode(DLinkNode* ptr)
{
    free(ptr);
}

void DLinkListInit(DLinkNode** head)
{
    if (head == NULL)
    {
        return;          //非法输入
    }
    *head = CreateDLinkListNode(0);
    return;
}

DLinkNode* DLinkListPushBack(DLinkNode* head, DLinkType value)          //尾插
{
    if (head == NULL)
    {
        return NULL;        //非法输入
    }
    DLinkNode* new_node = CreateDLinkListNode(value);
    DLinkNode* new_node_next = head;
    DLinkNode* new_node_prev = head->prev;

    new_node_prev->next = new_node;
    new_node->prev = new_node_prev;
    new_node_next->prev = new_node;
    new_node->next = new_node_next;
    return new_node;
}

void DLinkListPopBack(DLinkNode* head)              //尾删
{
    if (head == NULL)
    {
        return;     //非法输入
    }
    if (head->next == head)
    {
        return;     //空链表
    }
    DLinkNode* to_delete = head->prev;
    DLinkNode* to_delete_next = to_delete->next;
    DLinkNode* to_delete_prev = to_delete->prev;
    to_delete_prev->next = to_delete_next;
    to_delete_next->prev = to_delete_prev;
    DestroyDLinkListNode(to_delete);
    to_delete = NULL;
    return;
}

void DLinkListPushFront(DLinkNode* head, DLinkType value)           //头插
{
    if (head == NULL)
    {
        return;     //非法输入
    }
    DLinkNode* new_node = CreateDLinkListNode(value);
    DLinkNode* new_node_next = head->next;
    DLinkNode* new_node_prev = head;

    new_node_next->prev = new_node;
    new_node->next = new_node_next;

    new_node_prev->next = new_node;
    new_node->prev = new_node_prev;
}

void DLinkListPopFront(DLinkNode* head)         //头删
{
    if (head == NULL)
    {
        return;     //非法输入
    }
    if (head == head->next)
    {
        return;     //空链表
    }
    //DLinkNode* to_delete = head->next;
    //DLinkNode* to_delete_next = to_delete->next;
    //DLinkNode* to_delete_prev = to_delete->prev;

    //to_delete_prev->next = to_delete_next;
    //to_delete_next->prev = to_delete_prev;
    //DestroyDLinkListNode(to_delete);
    //to_delete = NULL;
    DLinkListErase(head, head->next);
    return;
}

DLinkNode* DLinkListFind(DLinkNode* head, DLinkType to_find)            //查找元素在链表中的位置
{
    if (head == NULL)
    {
        return NULL;        //非法输入
    }
    if (head == head->next)
    {
        return NULL;        //空链表
    }
    DLinkNode* cur = head->next;
    for (; cur != head; cur = cur->next)
    {
        if (cur->data == to_find)
        {
            return cur;
        }
    }
    return NULL;
}

void DLinkListInsert(DLinkNode* pos, DLinkType value)      //往指定位置之前插入一个元素
{
    if (pos == NULL)
    {
        return;     //非法输入
    }
    DLinkNode* new_node = CreateDLinkListNode(value);
    DLinkNode* new_node_next = pos;
    DLinkNode* new_node_prev = pos->prev;
    new_node_next->prev = new_node;
    new_node->next = new_node_next;

    new_node_prev->next = new_node;
    new_node->prev = new_node_prev;
    return;
}

void DLinkListInsertAfter(DLinkNode* pos, DLinkType value)      //往指定位置之后插入一个元素
{
    if (pos == NULL)
    {
        return;     //非法输入
    }
    DLinkNode* new_node = CreateDLinkListNode(value);
    DLinkNode* new_node_next = pos->next;
    DLinkNode* new_node_prev = pos;
    new_node_next->prev = new_node;
    new_node->next = new_node_next;

    new_node_prev->next = new_node;
    new_node->prev = new_node_prev;
    return;
}

void DLinkListErase(DLinkNode* head, DLinkNode* pos)        //删除指定位置的元素
{
    if (head == NULL || pos == NULL)
    {
        return;     //非法输入
    }
    if (head == head->next)
    {
        return;     //空链表
    }
    DLinkNode* pos_prev = pos->prev;
    DLinkNode* pos_next = pos->next;
    pos_prev->next = pos_next;
    pos_next->prev = pos_prev;
    DestroyDLinkListNode(pos);
    pos = NULL;
    return;
}

void DLinkListRemove(DLinkNode* head, DLinkType value)      //删除指定值的元素
{
    if (head == NULL)
    {
        return;     //非法输入
    }
    DLinkNode* to_find = head->next;
    for (; to_find != head; to_find = to_find->next)
    {
        if (to_find->data == value)
            break;
    }
    if (to_find != head)
    {
        DLinkNode* to_delete_prev = to_find->prev;
        DLinkNode* to_delete_next = to_find->next;
        to_delete_prev->next = to_delete_next;
        to_delete_next->prev = to_delete_prev;
        DestroyDLinkListNode(to_find);
    }
    return;
}

void DLinkListRemoveAll(DLinkNode* head, DLinkType value)        //删除指定值的所有元素
{
    if (head == NULL)
    {
        return;     //非法输入
    }
    while (1)
    {
        DLinkNode* pos = DLinkListFind(head, value);
        if (pos == NULL)
        {
            return;
        }
        DLinkListErase(head, pos);
    }
    return;
}

size_t DLinkListSize(DLinkNode* head)        //求链表元素个数
{
    if (head == NULL)
    {
        return (size_t)-1;
    }
    size_t count = 0;
    DLinkNode* cur = head->next;
    for (; cur != head; cur = cur->next)
    {
        ++count;
    }
    return count;
}

int DLinkListEmpty(DLinkNode* head)     //判断链表是否为空，为空返回1，否则返回0
{
    assert(head);
    if (head->next == head)
    {
        return 1;
    }
    return 0;
}

void DLinkListDestroy(DLinkNode** head)     //销毁链表
{
    if (head == NULL)
    {
        return;     //非法输入
    }
    if (*head == NULL)
    {
        return;     //该链表带头结点，头指针不可能指向空
    }
    if ((*head) == (*head)->next)
    {
        //空链表
        DestroyDLinkListNode(*head);
        *head = NULL;
        return;
    }
    DLinkNode* cur = (*head)->next;
    while (cur != *head)
    {
        DLinkNode* next = cur->next;
        DestroyDLinkListNode(cur);
        cur = next;
    }
    DestroyDLinkListNode(*head);
    *head = NULL;
    return;
}

③test.c

#include "dlinklist.h"

#include <windows.h> 

#define TEST_HEADER printf("\n===========================%s===========================\n",__FUNCTION__)

void DLinkListPrintChar(DLinkNode* head, const char* msg)
{
    printf("[%s]：", msg);
    printf("[head]");
    DLinkNode* cur = head->next;
    for (; cur != head; cur = cur->next)
    {
        printf(" -> [%c:%p]", cur->data, cur);
    }
    printf("\n");
    printf("                ");
    printf("[head]");
    for (cur = head->prev; cur != head; cur = cur->prev)
    {
        printf(" -> [%c:%p]", cur->data, cur);
    }
    printf("\n");
}

void TestInit()
{
    TEST_HEADER;
    DLinkNode* head = NULL;
    DLinkListInit(&head);
    printf("head = %p\n", head);
    printf("head->next = %p\n", head->next);
    printf("head->prev = %p\n", head->prev);
}

void TestPushBack()
{
    TEST_HEADER;
    DLinkNode* head = NULL;
    DLinkListInit(&head);
    DLinkListPushBack(head, 'a');
    DLinkListPushBack(head, 'b');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'd');
    DLinkListPrintChar(head, "尾插四个元素");
}

void TestPopBack()
{
    TEST_HEADER;
    DLinkNode* head = NULL;
    DLinkListInit(&head);
    DLinkListPushBack(head, 'a');
    DLinkListPushBack(head, 'b');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'd');
    DLinkListPrintChar(head, "尾插四个元素");

    DLinkListPopBack(head);
    DLinkListPopBack(head);
    DLinkListPrintChar(head, "尾删两个元素");

    DLinkListPopBack(head);
    DLinkListPopBack(head);
    DLinkListPrintChar(head, "尾删两个元素");

    DLinkListPopBack(head);
    DLinkListPrintChar(head, "对空链表尾删");
}

void TestPushFront()
{
    TEST_HEADER;
    DLinkNode* head = NULL;
    DLinkListInit(&head);
    DLinkListPushFront(head, 'd');
    DLinkListPushFront(head, 'c');
    DLinkListPushFront(head, 'b');
    DLinkListPushFront(head, 'a');
    DLinkListPrintChar(head, "头插四个元素");
}

void TestPopFront()
{
    TEST_HEADER;
    DLinkNode* head = NULL;
    DLinkListInit(&head);
    DLinkListPushFront(head, 'd');
    DLinkListPushFront(head, 'c');
    DLinkListPushFront(head, 'b');
    DLinkListPushFront(head, 'a');
    DLinkListPrintChar(head, "头插四个元素");

    DLinkListPopFront(head);
    DLinkListPopFront(head);
    DLinkListPrintChar(head, "头删两个元素");

    DLinkListPopFront(head);
    DLinkListPopFront(head);
    DLinkListPrintChar(head, "头删两个元素");

    DLinkListPopFront(head);
    DLinkListPrintChar(head, "对空链表头删");
}

void TestFind()
{
    TEST_HEADER;
    DLinkNode* head = NULL;
    DLinkListInit(&head);
    DLinkNode* pos = DLinkListFind(head, 'a');
    printf("[对空链表查找]：");
    printf("pos expect NULL, actual %p\n", pos);

    DLinkListPushBack(head, 'a');
    DLinkNode* pos_b = DLinkListPushBack(head, 'b');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'd');
    DLinkListPrintChar(head, "尾插四个元素");
    pos = DLinkListFind(head, 'b');
    printf("[查找元素b]：");
    printf("pos expect %p, actual %p\n", pos_b, pos);

    pos = DLinkListFind(head, 'x');
    printf("[查找不存在元素x]：");
    printf("pos expect NULL, actual %p\n", pos);
}

void TestInsert()
{
    TEST_HEADER;
    DLinkNode* head = NULL;
    DLinkListInit(&head);
    DLinkListPushBack(head, 'a');
    DLinkNode* pos_b = DLinkListPushBack(head, 'b');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'd');
    DLinkListPrintChar(head, "尾插四个元素");
    DLinkListInsert(pos_b, 'x');
    DLinkListPrintChar(head, "在b之前插入x");
}

void TestInsertAfter()
{
    TEST_HEADER;
    DLinkNode* head = NULL;
    DLinkListInit(&head);
    DLinkListPushBack(head, 'a');
    DLinkNode* pos_b = DLinkListPushBack(head, 'b');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'd');
    DLinkListPrintChar(head, "尾插四个元素");
    DLinkListInsertAfter(pos_b, 'x');
    DLinkListPrintChar(head, "在b之后插入x");
}

void TestErase()
{
    TEST_HEADER;
    DLinkNode* head = NULL;
    DLinkListInit(&head);
    DLinkListPushBack(head, 'a');
    DLinkNode* pos_b = DLinkListPushBack(head, 'b');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'd');
    DLinkListPrintChar(head, "尾插四个元素");
    DLinkListErase(head, pos_b);
    DLinkListPrintChar(head, "删除元素b 后");
}

void TestRemove()
{
    TEST_HEADER;
    DLinkNode* head = NULL;
    DLinkListInit(&head);
    DLinkListPushBack(head, 'a');
    DLinkListPushBack(head, 'b');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'd');
    DLinkListPrintChar(head, "尾插四个元素");
    DLinkListRemove(head, 'a');
    DLinkListPrintChar(head, "删除元素a 后");

    DLinkListRemove(head, 'x');
    DLinkListPrintChar(head, "删除不存在元素x");
}

void TestRemoveAll()
{
    TEST_HEADER;
    DLinkNode* head = NULL;
    DLinkListInit(&head);
    DLinkListPushBack(head, 'a');
    DLinkListPushBack(head, 'b');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'd');
    DLinkListPrintChar(head, "尾插六个元素");
    DLinkListRemoveAll(head, 'c');
    DLinkListPrintChar(head, "删除元素c 后");

    DLinkListRemoveAll(head, 'x');
    DLinkListPrintChar(head, "删除不存在元素x");
}

void TestSize()
{
    TEST_HEADER;
    DLinkNode* head = NULL;
    size_t size = DLinkListSize(head);
    printf("size expect (size_t)-1, actual %lu\n", size);

    DLinkListInit(&head);
    size = DLinkListSize(head);
    printf("size expect 0, actual %lu\n", size);

    DLinkListPushBack(head, 'a');
    DLinkListPushBack(head, 'b');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'd');
    DLinkListPrintChar(head, "尾插六个元素");
    size = DLinkListSize(head);
    printf("size expect 6, actual %lu\n", size);
}

void TestEmpty()
{
    TEST_HEADER;
    DLinkNode* head = NULL;
    DLinkListInit(&head);
    int ret = DLinkListEmpty(head);
    printf("ret expect 1, actual %d\n", ret);

    DLinkListPushBack(head, 'a');
    DLinkListPushBack(head, 'b');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'd');
    DLinkListPrintChar(head, "尾插四个元素");
    ret = DLinkListEmpty(head);
    printf("ret expect 0, actual %d\n", ret);
}

void TestDestroy()
{
    TEST_HEADER;
    DLinkNode* head = NULL;
    DLinkListInit(&head);
    DLinkListPushBack(head, 'a');
    DLinkListPushBack(head, 'b');
    DLinkListPushBack(head, 'c');
    DLinkListPushBack(head, 'd');
    DLinkListPrintChar(head, "尾插四个元素");
    DLinkListDestroy(&head);
    printf("[销毁链表后]：head expect NULL, actual %p\n", head);
}

int main()
{
    TestInit();
    TestPushBack();
    TestPopBack();
    TestPushFront();
    TestPopFront();
    TestFind();
    TestInsert();
    TestInsertAfter();
    TestErase();
    TestRemove();
    TestRemoveAll();
    TestSize();
    TestEmpty();
    TestDestroy();
    system("pause");
    return 0;
}

结果：

结果
结果
结果
结果

adorable_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构—双向链表的基本操作
小虾米编程
06-20 7672
1.双向链表的操作 双向链表的基本操作包括：判断链表是否为空、计算链表的长度、遍历链表，这3中操作的方法和单链表一样，主要和双向链表中的指向后继的指针有关。 双向链表的插入和删除操作和单链表是有区别的：双向链表的插入和删除操作要修改指向前驱和指向后继的指针。 2.双向链表的删除：删除指定位置 i 的元素 1.判断输入的删除的位置是否合法，1<=i<=表长 2.顺着指向后继的指针...
【数据结构-C】双向循环链表基本操作及图解分析
qq_52763385的博客
02-04 4329
目录 ????双向链表介绍 ????双向链表的基本操作及图解分析 ????1.双向链表创建新的结点 ????2.双向链表初始化 ????3.双向链表的尾插 ????4.双向链表的头插 ????5.双向链表的头删 ????6.双向链表的尾删 ????7.查找某个结点并返回该节点地址 ????8.在某结点前插入一个新的结点 ????9.删除某个结点 ????10.销毁双向链表 总结 ????双向链表介绍 双向链表的结点：指针域1+数据域+指针域2 ????指针域1：指向该结点
【数据结构】双向链表及其基本操
Z1tai的博客
11-10 549
双向链表是一种常见的线性数据结构，它与单向链表相比具有双向遍历的优势。除了拥有指向后继节点的指针外，双向链表还拥有指向前驱节点的指针。这使得在双向链表中可以更有效地实现从后往前的遍历，而不像单向链表那样需要重新遍历整个链表。在某些场景下，双向链表能够更加高效地解决问题。
双向链表的基本操作
Kuches的博客
03-08 428
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、初始化双线性链表二、双向链表的节点插入二、双向链表的节点删除三、双向链表的节点修改四、双向链表的打印总结 前言 对双线性链表进行一些基础操作 一、初始化双线性链表 利用尾插法建立一个双向链表 代码示例 void InitDList(DLinkList*L) { (*L)=(DLNode*)malloc(sizeof(DLNode)); (*L)->pre=NULL; (*L)->next=NULL;
双向链表及其基本操作
10-29
C语言，实现双向链表以及其基本操作，基本操作：链表初始化、创建、查询、删除、释放，查询和删除均有两种方式，一种是按照值，另一种是按照结点的序号。
双向链表基本操作.cpp
10-17
双向链表基本操作.cpp
C语言实现数据结构和双向链表操作
01-21
数据结构 双向链表的实现 双向链表中的每一个结点都含有两个指针域，一个指针域存放其后继结点的存储地址，另一个指针域则存放其前驱结点的存储地址。 双向链表结点的类型描述： //双向链表的类型描述 typedef ...
C语言双向链表基本操作
02-26
用C语言实现双向列表的创建，删除，添加节点，删除节点，插入节点，遍历节点，打印节点，并结合插入排序法实现了基于双向链表的升序排序。
C语言数据结构 双向链表的建立与基本操作
01-01
C语言数据结构 双向链表的建立与基本操作 双向链表比单链表有更好的灵活性，其大部分操作与线性表相同。下面总结双向链表与单链表之间的不同之处及我在实现过程中所遇到的问题。 1.双向链表的建立 双向链表在初始...
数据结构之双向链表(完整版)
09-12
双向聊表的实现细节以及菜单显示，对数据结构的同学很有帮助，有注释！大学必备源码，可直接运行，c程序设计加数据结构
双向链表的操作
10-02
双向链表的操作问题 Time Limit: 1000MS Memory Limit: 10000KB Submissions: 111 Accepted: 41 Description 建立一个长度为n的带头结点的双向链表，使得该链表中的数据元素递增有序排列。（必须使用双向链表完成，数据类型为整型。） Input 第一行：双向表的长度； 第二行：链表中的数据元素。 Output 输出双向链表中的数据元素的值。 Sample Input 10 2 4 6 3 5 8 10 21 12 9 Sample Output 2 3 4 5 6 8 9 10 12 21
数据结构双向链表
09-24
编译环境vs2010,C语言实现双向链表的基础操作，详细注释，基础必备。
双向链表的14个基本操作函数C语言
最新发布
03-02
双向链表的14个基本操作函数C语言版，使用DEV-C++ 5.11编译器
双向链表的基本操作C语言
05-02
双向链表基本操作函数
在结点类型为DLink Node 的双链表中将p所指结点（非尾结点）与其后继结点交换的操作
暴力扬
03-25 3006
在结点类型为DLink Node 的双链表中将p所指结点（非尾结点）与其后继结点交换的操作
双向链表的定义及基本操作
IT80hcbz的博客
03-31 398
《匠人的算法课II》为数据结构和算法系列课程的进阶课程。本讲为第一讲，大家详细介绍双向链表的定义以及基本操作。
线性表 之 双链表
weixin_46540768的博客
09-02 532
目录 1.效果截图： 2.双链表结点类型DLinkNode声明 3.整体建立双链表 4.添加头文件 5.基本运算算法（9个） 6.主函数： 7.遇到的问题 在codeblocks 中建立C++ 控制台项目 将4,5,6,的代码都放进去,即可运行！ 1.效果截图： 2.双链表结点类型DLinkNode声明 typedef char ElemType; typedef struct DNode { ElemType data;//存放元素值 struct DNo..
双向链表的基本操作python
10-29
双向链表是一种链表，它的每个节点都有两个指针，一个指向前一个节点，一个指向后一个节点。下面是双向链表的基本操作： 1.创建双向链表：创建一个空链表，即创建一个头节点，头节点的前驱和后继都指向None。 2.添加节点：在双向链表的任意位置添加一个节点，需要先找到要添加的位置，然后将新节点的前驱和后继指针指向相应的节点，相应节点的前驱和后继指针也要指向新节点。 3.删除节点：在双向链表中删除一个节点，需要先找到要删除的节点，然后将相应节点的前驱和后继指针指向要删除节点的前驱和后继节点，要删除节点的前驱和后继节点的指针也要指向相应节点。 4.遍历双向链表：从头节点开始，依次访问每个节点，直到访问到尾节点。 下面是一个Python实现双向链表的例子： ```python class Node: def __init__(self, data): self.data = data self.prev = None self.next = None class DoublyLinkedList: def __init__(self): self.head = None def add_node(self, data): new_node = Node(data) if self.head is None: self.head = new_node else: current = self.head while current.next is not None: current = current.next current.next = new_node new_node.prev = current def delete_node(self, data): current = self.head while current is not None: if current.data == data: if current.prev is not None: current.prev.next = current.next else: self.head = current.next if current.next is not None: current.next.prev = current.prev break current = current.next def traverse(self): current = self.head while current is not None: print(current.data) current = current.next ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值