Linux实现插入排序的双向链表

最新推荐文章于 2020-11-16 14:09:37 发布
最新推荐文章于 2020-11-16 14:09:37 发布
阅读量353 收藏
点赞数
分类专栏： 数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/innobase/article/details/51302159
版权
  

    实现插入自动排序的双向链表，插入的的每个元素是唯一且是排序好的，从链表头到链表尾部都是按照从小到大的顺序的

 

 

ds.h如下：

/*************************************************************************
    > File Name: ds.h
    > Author: zhoulin
    > Mail: 715169549@qq.com 
    > Created Time: Thu 31 Dec 2015 07:16:49 PM EST
***********************************************************************/
/***********************************************************************
 * define listNode 、list struct 
***********************************************************************/
#ifndef __ds_h
#define __ds_h
typedef struct listNode   //双向变脸的节点定义
{
    int var;
    struct listNode *prev;
    struct listNode *next;
}listNode;
typedef struct list
{
    unsigned int len; //链表的长度
    struct listNode *head; //链表的头部节点
    struct listNode *tail; //链表的尾部节点
}list;

#define listNodeHead(l)   ((l)->head)
#define listNodeTail(l)   ((l)->tail)
#define listNodeLen(l)    ((l)->len)
#define listNodePrev(l)   ((l)->prev)
#define listNodeNext(l)   ((l)->next)
#define listNodeNull(n)    \
{                          \
    (n)->prev = NULL;      \
    (n)->next = NULL;      \
}
/**********************************************************************
 * operation of struct listNode and list 
 * ********************************************************************/
 list *listCreate(); //链表创建
 int listNodeAdd(list *lt, listNode *value); //添加listNode到链表
 int listNodeDel(list *lt, int var); //删除某个链表
 listNode *listNodeQuery(list *lt, int var); //查询某个链表
 void listNodePrt(list *lt); //打印整个链表
 int listNodeRelease(list *lt); //销毁整个链表
#endif

ds_pt.c代码如下：

/*************************************************************************
    > File Name: ds_pt.c
    > Author: zhoulin
    > Mail: 715169549@qq.com 
    > Created Time: Thu 31 Dec 2015 07:33:04 PM EST
 ************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include "ds.h"
list *listCreate()
{
    list *lt = NULL;
    if((lt = (list *)malloc(sizeof(*lt))) != NULL) {
        listNodeLen(lt) = 0;
        listNodeHead(lt) = NULL;
        listNodeTail(lt) = NULL;
    }
    return lt;
}
int listNodeAdd(list *lt, listNode *value)
{
    if(lt == NULL || value == NULL) {
        return -1;
    }
    if(listNodeLen(lt) == 0) {
        listNodeHead(lt) = listNodeTail(lt) = value;
        __sync_fetch_and_add(&(lt->len),1);
        return 0;
    }
    listNode *pHead = listNodeHead(lt);
    listNode *pTail = listNodeTail(lt);
    if(listNodeLen(lt) == 1) {
        if(pHead->var == value->var){
            return -1;
        }
        if(pHead->var > value->var) {
            listNodeHead(lt) = value;
            listNodeNext(value) = pHead;
            listNodePrev(pHead) = value;
            __sync_fetch_and_add(&(lt->len),1);
            return 0;
        }
        listNodeTail(lt) = listNodeTail(lt) =  value;
        listNodePrev(value) = pHead;
        listNodeNext(pHead) = value;
         __sync_fetch_and_add(&(lt->len),1);
        return 0;
    }
    listNode *pCur = pHead;
    while(pCur != NULL){
        if(pCur->var == value->var){
            return -1;
        }   
        listNode *pNext=listNodeNext(pCur);
        listNode *pPrev=listNodePrev(pCur);
        if(pPrev == NULL && pNext != NULL) {  //head
            if(pCur->var > value->var) {
                listNodeHead(lt) = value;
                listNodeNext(value) = pCur;
                listNodePrev(pCur) = value;
                __sync_fetch_and_add(&(lt->len),1);
                  break;
            }
            if(pCur->var < value->var && pNext->var> value->var) {
                listNodePrev(value) = pCur;
                listNodeNext(value) = pNext;
                listNodePrev(pNext) = listNodeNext(pCur)  = value;
                __sync_fetch_and_add(&(lt->len),1);
                 break;
            }
        }
        if(pPrev != NULL && pNext != NULL) { //mid
            if(pCur->var < value->var && pNext->var > value->var) {
                listNodePrev(value) = pCur;
                listNodeNext(value) = pNext;
                listNodePrev(pNext) = listNodeNext(pCur)  = value;
                __sync_fetch_and_add(&(lt->len),1);
                break;
            }
            if(pCur->var > value->var && pPrev->var < value->var) {
                listNodePrev(pCur) = value;
                listNodeNext(pPrev) = value;
                listNodePrev(value) = pPrev;
                listNodeNext(value) = pCur;
                __sync_fetch_and_add(&(lt->len),1);
                 break;
            }
        }
        if(pPrev != NULL && pNext == NULL) {  //tail listNode
            if(pCur->var < value->var) {
                listNodeTail(lt) = value;
                listNodePrev(value) =pCur;
                listNodeNext(pCur) = value;
                __sync_fetch_and_add(&(lt->len),1);
                 break;
            }
            if(pCur->var > value->var && pPrev->var < value->var) {
                listNodeNext(value) = pCur;
                listNodePrev(value) = pPrev;
                listNodePrev(pCur) = value;
                listNodeNext(pPrev) = value;
                __sync_fetch_and_add(&(lt->len),1);
                break;
            }
        }
        pCur = listNodeNext(pCur);
    }
    return 0;
}
int listNodeDel(list *lt, int var)
{
    if(lt == NULL) {
        return -1;
    }
    listNode *pHead = listNodeHead(lt);
    listNode *pTail = listNodeTail(lt);
    if(pHead != NULL && pTail != NULL) {
        if(pHead->var > var || pTail->var < var){
            return -1;
        }
    }
    listNode *pCur = pHead;
    while(pCur != NULL) {
        listNode *pNext = listNodeNext(pCur);
        listNode *pPrev = listNodePrev(pCur);
        if(pCur->var == var) {
            if(pPrev == NULL && pNext != NULL){
                listNodeHead(lt) = pNext;
                listNodePrev(pNext) = NULL;
                __sync_fetch_and_sub(&(lt->len),1);
                listNodeNull(pCur);
                free(pCur);
                pCur = NULL;
                return 0;
            }
            if(pPrev != NULL && pNext != NULL){
                listNodePrev(pNext) = pPrev;
                listNodeNext(pPrev) = pNext;
                __sync_fetch_and_sub(&(lt->len),1);
                listNodeNull(pCur);
                pCur = NULL;
                return 0;
            }
            if(pPrev != NULL && pNext == NULL){
                listNodeTail(lt) = pPrev;
                listNodeNext(pPrev) = NULL;
                __sync_fetch_and_sub(&(lt->len),1);
                listNodeNull(pCur);
                free(pCur);
                pCur=NULL;
                return 0;
            }
        }
        pCur =listNodeNext(pCur);
    }
    return -1;
}
listNode *listNodeQuery(list *lt, int var)
{
    listNode *query = NULL;
    if(lt == NULL || listNodeLen(lt) <= 0){
        return NULL;
    }
    listNode *pHead = listNodeHead(lt);
    listNode *pTail = listNodeTail(lt);
    if(pHead->var > var || pTail->var < var) {
        return NULL;
    }
    listNode *pCur = pHead;
    while(pCur !=  NULL) {
        if(pCur->var == var) {
            query = pCur;
            break;
        }
        pCur = listNodeNext(pCur);
    }
    return query;
}
void listNodePrt(list *lt)
{
    if(lt != NULL) {
        listNode *pCur = listNodeHead(lt);
        while(pCur != NULL) {
            listNode *pPrev = listNodePrev(pCur);
            listNode *pNext = listNodeNext(pCur);
            printf("listNode =%p,var=%d,prev=%p,next=%p\n",pCur,pCur->var,pPrev,pNext);
            pCur=pNext;
        }
    }
}
int listNodeRelease(list *lt)
{
    int count=0;
    if(lt == NULL || listNodeLen(lt) == 0) {
        return count;
    }
    listNode *pCur = listNodeHead(lt);
    while(pCur != NULL) {
        count++;
        listNode *pNext = listNodeNext(pCur);
        free(pCur);
        pCur = pNext;
    }
    return count; 
}
void test(int count, double base)
{
    list *lt=listCreate();
    srand((unsigned int) time(NULL));
    int i;
    printf("*************************listNodeAdd*******************\n");
    int ok = 0;
    int fail = 0;
    for(i = 0; i < count; i++) {
        int v =i+ (int)( base *rand()/(RAND_MAX + 1.0));
        listNode *tmp =(listNode *)malloc(sizeof(*tmp));
        tmp->var = v;
        int exec = listNodeAdd(lt, tmp);
        if(exec == 0) {
            ok++;
            printf("var=%d,listNodeAdd =%d\n",v,exec);
        } else {
            fail++;
            printf("var=%d,listNodeAdd =%d\n",v,exec);
        }
    }
    printf("*************************listNodeAdd ok =%d | fail =%d*******************\n\n", ok, fail);
    ok = 0,fail = 0;
    printf("********head=%p,tail=%p,listNodeLen=%d*****\n\n",listNodeHead(lt),listNodeTail(lt),listNodeLen(lt));
    printf("*************************listNodePrt*****************\n");
    listNodePrt(lt);
    printf("*************************listNodeQuery*****************\n");
    for(i = 0; i < count; i++) {
        int v =i+ (int)( base *rand()/(RAND_MAX + 1.0));
        listNode *tmp = listNodeQuery(lt,v);
        if(tmp !=NULL) {
            ok++;
            printf("listNodeQuery(%d) =%p,var=%d\n",v,tmp,tmp->var);
        } else {
            fail++;
            printf("listNodeQuery(%d) =%p\n",v,tmp);
        }
    }
    printf("   ------------>listNodeQuery ok=%d | fail =%d<-------------------\n\n", ok, fail);
    ok = 0,fail = 0;
    printf("*************************listNodeDel*****************\n");
    for(i = 0;i < count; i++){
        int v =i+ (int)( base *rand()/(RAND_MAX + 1.0));
        int exec = listNodeDel(lt,v);
        if(exec == 0){
            ok++;
            printf("listNodeDel(%d) =%d\n",v,exec);
        }else {
            fail++;
            printf("listNodeDel(%d) =%d\n",v,exec);
        }
    }
    printf("   --------------->listNodeDel ok =%d | fail =%d<------------------\n\n", ok, fail);
    printf("*************************listNodeRelease***************\n");
    printf("list len = %d,istNodeRelease(%p) =%d\n",listNodeLen(lt),lt,listNodeRelease(lt));
}
int main(void)
{
    test(30,100.0);
    return 0;
}

运行结果如下：

zhoulin@:~/code_20160101/cas:./ds
*************************listNodeAdd*******************
var=64,listNodeAdd =0
var=52,listNodeAdd =0
var=67,listNodeAdd =0
var=13,listNodeAdd =0
var=41,listNodeAdd =0
var=15,listNodeAdd =0
var=70,listNodeAdd =0
var=15,listNodeAdd =-1
var=43,listNodeAdd =0
var=17,listNodeAdd =0
var=89,listNodeAdd =0
var=52,listNodeAdd =-1
var=99,listNodeAdd =0
var=74,listNodeAdd =0
var=14,listNodeAdd =0
var=82,listNodeAdd =0
var=97,listNodeAdd =0
var=48,listNodeAdd =0
var=49,listNodeAdd =0
var=69,listNodeAdd =0
var=45,listNodeAdd =0
var=73,listNodeAdd =0
var=106,listNodeAdd =0
var=40,listNodeAdd =0
var=30,listNodeAdd =0
var=122,listNodeAdd =0
var=47,listNodeAdd =0
var=64,listNodeAdd =-1
var=62,listNodeAdd =0
var=127,listNodeAdd =0
*************************listNodeAdd ok =27 | fail =3*******************

********head=0x1a62090,tail=0x1a623d0,listNodeLen=27*****

*************************listNodePrt*****************
listNode =0x1a62090,var=13,prev=(nil),next=0x1a621f0
listNode =0x1a621f0,var=14,prev=0x1a62090,next=0x1a620d0
listNode =0x1a620d0,var=15,prev=0x1a621f0,next=0x1a62150
listNode =0x1a62150,var=17,prev=0x1a620d0,next=0x1a62330
listNode =0x1a62330,var=30,prev=0x1a62150,next=0x1a62310
listNode =0x1a62310,var=40,prev=0x1a62330,next=0x1a620b0
listNode =0x1a620b0,var=41,prev=0x1a62310,next=0x1a62130
listNode =0x1a62130,var=43,prev=0x1a620b0,next=0x1a622b0
listNode =0x1a622b0,var=45,prev=0x1a62130,next=0x1a62370
listNode =0x1a62370,var=47,prev=0x1a622b0,next=0x1a62250
listNode =0x1a62250,var=48,prev=0x1a62370,next=0x1a62270
listNode =0x1a62270,var=49,prev=0x1a62250,next=0x1a62050
listNode =0x1a62050,var=52,prev=0x1a62270,next=0x1a623b0
listNode =0x1a623b0,var=62,prev=0x1a62050,next=0x1a62030
listNode =0x1a62030,var=64,prev=0x1a623b0,next=0x1a62070
listNode =0x1a62070,var=67,prev=0x1a62030,next=0x1a62290
listNode =0x1a62290,var=69,prev=0x1a62070,next=0x1a620f0
listNode =0x1a620f0,var=70,prev=0x1a62290,next=0x1a622d0
listNode =0x1a622d0,var=73,prev=0x1a620f0,next=0x1a621d0
listNode =0x1a621d0,var=74,prev=0x1a622d0,next=0x1a62210
listNode =0x1a62210,var=82,prev=0x1a621d0,next=0x1a62170
listNode =0x1a62170,var=89,prev=0x1a62210,next=0x1a62230
listNode =0x1a62230,var=97,prev=0x1a62170,next=0x1a621b0
listNode =0x1a621b0,var=99,prev=0x1a62230,next=0x1a622f0
listNode =0x1a622f0,var=106,prev=0x1a621b0,next=0x1a62350
listNode =0x1a62350,var=122,prev=0x1a622f0,next=0x1a623d0
listNode =0x1a623d0,var=127,prev=0x1a62350,next=(nil)
*************************listNodeQuery*****************
listNodeQuery(30) =0x1a62330,var=30
listNodeQuery(100) =(nil)
listNodeQuery(52) =0x1a62050,var=52
listNodeQuery(99) =0x1a621b0,var=99
listNodeQuery(14) =0x1a621f0,var=14
listNodeQuery(93) =(nil)
listNodeQuery(12) =(nil)
listNodeQuery(81) =(nil)
listNodeQuery(105) =(nil)
listNodeQuery(51) =(nil)
listNodeQuery(92) =(nil)
listNodeQuery(87) =(nil)
listNodeQuery(96) =(nil)
listNodeQuery(83) =(nil)
listNodeQuery(52) =0x1a62050,var=52
listNodeQuery(99) =0x1a621b0,var=99
listNodeQuery(54) =(nil)
listNodeQuery(36) =(nil)
listNodeQuery(33) =(nil)
listNodeQuery(89) =0x1a62170,var=89
listNodeQuery(89) =0x1a62170,var=89
listNodeQuery(61) =(nil)
listNodeQuery(44) =(nil)
listNodeQuery(76) =(nil)
listNodeQuery(81) =(nil)
listNodeQuery(53) =(nil)
listNodeQuery(76) =(nil)
listNodeQuery(106) =0x1a622f0,var=106
listNodeQuery(93) =(nil)
listNodeQuery(114) =(nil)
   ------------>listNodeQuery ok=9 | fail =21<-------------------

*************************listNodeDel*****************
listNodeDel(78) =-1
listNodeDel(97) =0
listNodeDel(86) =-1
listNodeDel(32) =-1
listNodeDel(97) =-1
listNodeDel(100) =-1
listNodeDel(23) =-1
listNodeDel(106) =0
listNodeDel(77) =-1
listNodeDel(23) =-1
listNodeDel(52) =0
listNodeDel(63) =-1
listNodeDel(103) =-1
listNodeDel(39) =-1
listNodeDel(36) =-1
listNodeDel(44) =-1
listNodeDel(27) =-1
listNodeDel(77) =-1
listNodeDel(66) =-1
listNodeDel(45) =0
listNodeDel(51) =-1
listNodeDel(39) =-1
listNodeDel(89) =0
listNodeDel(76) =-1
listNodeDel(95) =-1
listNodeDel(50) =-1
listNodeDel(108) =-1
listNodeDel(49) =0
listNodeDel(33) =-1
listNodeDel(77) =-1
   --------------->listNodeDel ok =6 | fail =24<------------------

*************************listNodeRelease***************
list len = 21,istNodeRelease(0x1a62010) =21
zhoulin@:~/code_20160101/cas:gcc -g ds.h ds_pt.c -O2 -o ds //使用gcc原子操作函数
zhoulin@:~/code_20160101/cas:gcc -g ds1.h ds_pt1.c -O2 -o ds1 -lpthread //使用pthread_mutex_t进行原子操作
zhoulin@:~/code_20160101/cas:time ./ds
*************************listNodeRelease***************
list len = 8008,listNodeRelease(0x1d51010) =8008

real    0m5.809s
user    0m5.770s
sys     0m0.004s
zhoulin@:~/code_20160101/cas:time ./ds1
*************************listNodeRelease***************
list len = 8051,listNodeRelease(0x21cd010) =8051

real    0m6.231s
user    0m6.220s
sys     0m0.002s

 

数据库码农
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux顺序表实现，通过选择实现插入、查找、排序等功能
qq_44470536的博客
08-06 118
1.头文件 #ifndef _MYLIST_H #define _MYLIST_H #include <string.h> #include <stdlib.h> typedef int DATA; typedef struct mylist { DATA *phead; int size; int count; }MYLIST; MYLIST *create(int size); int destroy(MYLIST **pplist); void input(MY
排序(二) 之直接插入排序
qigaohua的博客
10-30 127
文章目录一、直接插入排序二、代码示例   一、直接插入排序 插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。 它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素...
linux C插入排序
CodeHouse的博客
10-14 142
#include <stdio.h> #include <time.h> void insert_sort_print(int array[], int len, int i); #define MAX_NUM 4 int insert_sort(int array[], int len) { int i = 0; int j = 0; int itmp = 0; for (i = 1; i<len; i++) { insert_
Linux下的c基础编程——按原顺序插入元素
goodman_lqifei的博客
09-29 288
我们昨天写了选择法排序，今天我们将用它进行一个小规模的扩展，今天我们写一个插入函数，其中我们先用选择法对数组进行排序，再按照原顺序进行插入一个元素。   首先我们还是来展示一下我们的代码，这个代码的长度相比于前几篇的代码都要长一些。 #include void choic_arrage(int a[10])/*先通过选择法对数组元素进行排序*/ { int i; int j; int
Linux内核链表list方法解析
wo_wuhao
04-18 1008
做内核驱动开发经常会使用linux内核最经典的双向链表 list_head， 以及它的拓展接口(或者宏定义)： list_add , list_add_tail, list_del , list_entry ,list_for_each , list_for_each_entry ...... 每次看到这些接口，感觉都很像，今天专门研究了一下内核，对它们做一些总结，希望为后续开发提...
基于双向链表的基数排序
07-05
基数排序(radix sort)又称桶排序（bucket sort），相对于常见的比较排序，基数排序是一种分配式排序，需要将关键字...为了尽可能少的消耗复制时占用的空间，桶的数据结构选择链表，为了构造队列，选择使用双向列表。
JavaScript实现链表插入排序和链表归并排序
10-21
主要介绍了JavaScript实现链表插入排序和链表归并排序,较为详细的分析了插入排序和归并排序,对于学习JavaScript数据结构具有一定参考借鉴价值,需要的朋友可以参考下。
C#双向链表LinkedList排序实现方法
09-03
主要介绍了C#双向链表LinkedList排序实现方法,涉及C#双向链表的定义与排序技巧,具有一定参考借鉴价值,需要的朋友可以参考下
DuLinkBubbleSort 双向链表实现冒泡排序
06-07
设计算法，在带头结点的双向链表上，实现冒泡排序
yuandaima.zip_插入排序_链表插入排序
09-20
快速排序、倒序输出链表、链表插入排序、插入排序
利用双向循环链表实现快速排序算法
11-06
利用了双向循环链表实现了快速排序算法
使用双向链表实现快速排序，C语言
03-31
使用双向链表实现快速排序，C语言，有详细注释
在双向链表上实现快速排序的递归算法
09-30
在双向链表上实现快速排序的递归算法 输入的形式：元素个数、元素都为整型。 输入值范围：元素个数为非负正整数，需要排序的元素都为整型。 输出的形式：排序前的元素序列和排序后的元素序列。 程序的功能：对用户输入的n个整数元素进行排序。
双向链表的C++实现
11-01
基础数据结构双向链表的C++描述版。实现了双向链表的基本功能。包括拷贝构造函数和IO操作符重载、赋值操作符重载
linux内核双链表实现快速排序
不善挽留
09-22 5393
C语言，linux内核双链表实现快速排序，主要涉及到内核链表的基础操作，基地址转换和内核链表两个任意结点互换的实现。
插入排序
Linux_lv的专栏
09-05 940
插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。 一般来说，插入排序都采用in-place在数组
双向链表的插入排序（交换节点）
m0_46254928的博客
11-16 2808
插入排序需要从后往前遍历寻找可以插入的位置，所以会使用到双向链表 typedef struct Node//定义的结构体 { int data; struct Node* per; //记录前驱 struct Node* next; }*List; 创建带头节点的双链表 List create_list() { List head = (List)malloc(Size);//#define Size sizeof(struct Node) List p, q = head; if (head
链表 操作3 双向链表的 插入排序法
梦想专栏
04-18 2564
昨天做了某公司的数据结构笔试题： 其中一个小功能 是要求对 双向链表进行 快速排序。   思想： 借用了  nginx 链表排序思想  head   prev next  假设： 从小到大排序 从链表的 第二个 元素  head->next ， 开始，          1）首先删除该节点 在链表中的位置（但是不删除该节点）          2）逐次向前遍历链表 如果 比
双向链表list.h升序排序
李迟的专栏
10-20 1930
前一篇文章《整理一个双向链表list.h》介绍了自实现的双向链表list.h，在Linux内核中，常见的是维护全局链表(如i2c板级有一个全局链表)，基本上都是在尾部插入、模块退出时删除，不会涉及到链表中间插入、删除，——这也让我一度认为该链表的实现只具备这些“少许”功能。当然，如果抛开内核场合，其它场合可能会需要到更多的功能，所以前文中做了介绍。这里就说一下如何将链表做成升序（或降序）排列的。
java双向链表的插入排序过程
最新发布
04-13
Java双向链表的插入排序过程如下： 1. 首先，创建一个空的双向链表，并将第一个节点作为已排序部分。 2. 从第二个节点开始，依次将节点插入到已排序部分的正确位置。 3. 对于每个待插入的节点，从已排序部分的最后...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值