精华内容
下载资源
问答
  • // 双向链表排序.cpp : 定义控制台应用程序的入口点。//#include &ltstdio.h&gt#include &ltstdlib.h&gt#include &ltstring.h&gt#define len sizeof(struct node)struct node{int data;...

    // 双向链表排序.cpp : 定义控制台应用程序的入口点。

    //

    #include &ltstdio.h&gt

    #include &ltstdlib.h&gt

    #include &ltstring.h&gt

    #define len sizeof(struct node)

    struct node

    {

    int data;

    struct node *next;

    struct node *last;

    };

    struct list

    {

    struct node *head,*tail;

    int l;

    };

    void main()

    {

    struct list a;

    printf("请输入A链表的元素个数\n");

    scanf("%d",&a.l);

    int i,x=1;

    struct node *p1,*p2,*p3;

    printf("请输入A链表的第1个数据\n");

    p1=p2=(struct node*)malloc(len);

    scanf("%d",&p1-&gtdata);

    a.head=p1;

    p1-&gtlast=NULL;

    for(i=2;i&lt=a.l;i++)

    {

    p2=(struct node*)malloc(len);

    p1-&gtnext=p2;

    p2-&gtlast=p1;

    p1=p2;

    printf("请输入A链表的第%d个数据\n",i);

    scanf("%d",&p1-&gtdata);

    }

    p1-&gtnext=NULL;

    a.tail=p1;//链表A生成完毕//

    for(p2=a.tail;p2-&gtlast-&gtlast;p2=p2-&gtlast)//考虑第一个链点进行交换的情况//

    {

    if(p2-&gtdata&ltp2-&gtlast-&gtdata)

    {

    p3=p2-&gtlast;

    if(p2-&gtnext)

    {

    p3-&gtlast-&gtnext=p2;

    p2-&gtlast=p3-&gtlast;

    p2-&gtnext-&gtlast=p3;

    p3-&gtnext=p2-&gtnext;

    p3-&gtlast=p2;

    p2-&gtnext=p3;

    p2=p3;

    }

    else

    {

    p3-&gtnext=NULL;

    p2-&gtlast=p3-&gtlast;

    p3-&gtlast-&gtnext=p2;

    p2-&gtnext=p3;

    p3-&gtlast=p2;

    p2=p3;

    a.tail=p2;//考虑最后两个链点交换的情况//

    }

    }

    }

    if(p2-&gtlast-&gtdata&gtp2-&gtdata)

    {

    p3=p2-&gtlast;

    p2-&gtlast=NULL;

    p3-&gtnext=p2-&gtnext;

    p2-&gtnext-&gtlast=p3;

    p3-&gtlast=p2;

    p2-&gtnext=p3;

    p2=p3;

    a.head=p2-&gtlast;

    }

    p1=a.head;

    while(p1-&gtnext)

    {

    for(p2=a.tail;p2-&gtlast!=p1;p2=p2-&gtlast)

    {

    if(p2-&gtdata&ltp2-&gtlast-&gtdata)

    {

    p3=p2-&gtlast;

    if(p2-&gtnext)

    {

    p3-&gtlast-&gtnext=p2;

    p2-&gtlast=p3-&gtlast;

    p2-&gtnext-&gtlast=p3;

    p3-&gtnext=p2-&gtnext;

    p3-&gtlast=p2;

    p2-&gtnext=p3;

    p2=p3;

    }

    else

    {

    p3-&gtnext=NULL;

    p2-&gtlast=p3-&gtlast;

    p3-&gtlast-&gtnext=p2;

    p2-&gtnext=p3;

    p3-&gtlast=p2;

    p2=p3;

    a.tail=p2;//考虑最后两个链点交换的情况//

    }

    }

    }

    p1=p1-&gtnext;

    }

    p1=a.head;

    printf("%d\t",p1-&gtdata);

    do

    {

    p1=p1-&gtnext;

    printf("%d\t",p1-&gtdata);

    }

    while(p1-&gtnext);//新链表输出//

    }

    展开全文
  • 双向链表C语言实现

    2018-12-13 13:36:34
    通过双向链表实现按照ID序列插入,可以排序实现插入、删除、更新、修改;
  • 使用双向链表实现快速排序C语言,有详细注释
  • 双向链表的定义上一节学习了单向链表单链表详解。今天学习双链表。学习之前先对单向链表和双向链表做个回顾。单向链表特点:  1.我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的.   2.只能从头遍历到...

    @[TOC]

    1.双向链表的定义

    上一节学习了单向链表单链表详解。今天学习双链表。学习之前先对单向链表和双向链表做个回顾。单向链表特点:  1.我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的.   2.只能从头遍历到尾或者从尾遍历到头(一般从头到尾)双向链表特点  1.每次在插入或删除某个节点时, 需要处理四个节点的引用, 而不是两个. 实现起来要困难一些  2.相对于单向链表, 必然占用内存空间更大一些.  3.既可以从头遍历到尾, 又可以从尾遍历到头双向链表的定义:  双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点。下图为双向链表的结构图。560d47830c54988e21400d5b2c08a7ec.png  从上中可以看到,双向链表中各节点包含以下 3 部分信息:  指针域:用于指向当前节点的直接前驱节点;  数据域:用于存储数据元素。  指针域:用于指向当前节点的直接后继节点;a47c467794ed8793dd2e3094e67cb02d.png双向循环链表的定义:  双向链表也可以进行首尾连接,构成双向循环链表,如下图所示在创建链表时,只需要在最后将收尾相连即可(创建链表代码中已经标出)。其他代码稍加改动即可。ddfd967d68c3430995841a3b9ac1aebc.png双链表的节点结构用 C 语言实现为:

    /*随机数的范围*/#define MAX 100/*节点结构*/typedef struct Node{    struct Node *pre;    int data;    struct Node *next;}Node;

    2.双向链表的创建

      同单链表相比,双链表仅是各节点多了一个用于指向直接前驱的指针域。因此,我们可以在单链表的基础轻松实现对双链表的创建。  需要注意的是,与单链表不同,双链表创建过程中,每创建一个新节点,都要与其前驱节点建立两次联系,分别是:  将新节点的 prior 指针指向直接前驱节点;  将直接前驱节点的 next 指针指向新节点;  这里给出创建双向链表的 C 语言实现代码:

    Node* CreatList(Node * head,int length){    if (length == 1)    {        return( head = CreatNode(head));    }    else    {        head = CreatNode(head);        Node * list=head;        for (int i=1; ipre=NULL;            body->next=NULL;            body->data=rand()%MAX;            /*直接前趋结点的next指针指向新结点*/            list->next=body;            /*新结点指向直接前趋结点*/            body->pre=list;            /*把body指针给list返回*/            list=list->next;        }    }    /*加上以下两句就是双向循环链表*/    // list->next=head;    // head->prior=list;    return head;}

    3.双向链表的插入

      根据数据添加到双向链表中的位置不同,可细分为以下 3 种情况:1.添加至表头  将新数据元素添加到表头,只需要将该元素与表头元素建立双层逻辑关系即可。  换句话说,假设新元素节点为 temp,表头节点为 head,则需要做以下 2 步操作即可:  temp->next=head; head->prior=temp;  将 head 移至 temp,重新指向新的表头;  将新元素 7 添加至双链表的表头,则实现过程如下图所示:a3beafa0f0e6955599e4199e32d9fd19.png2.添加至表的中间位置  同单链表添加数据类似,双向链表中间位置添加数据需要经过以下 2 个步骤,如下图所示:  新节点先与其直接后继节点建立双层逻辑关系;  新节点的直接前驱节点与之建立双层逻辑关系;1845aedce16d7ca7471d25db4d06e386.png3.添加至表尾  与添加到表头是一个道理,实现过程如下:  找到双链表中最后一个节点;  让新节点与最后一个节点进行双层逻辑关系;5c66f10f295c964445cb47f1d17b1dc3.png

    /*在第add位置的前面插入data节点*/Node * InsertListHead(Node * head,int add,int data){    /*新建数据域为data的结点*/    Node * temp=(Node*)malloc(sizeof(Node));    if(head == NULL)    {        printf("malloc error!");        return NULL;    }        else    {        temp->data=data;        temp->pre=NULL;        temp->next=NULL;     }    /*插入到链表头,要特殊考虑*/    if (add==1)    {        temp->next=head;        head->pre=temp;        head=temp;    }    else    {        Node * body=head;        /*找到要插入位置的前一个结点*/        for (int i=1; inext;        }        /*判断条件为真,说明插入位置为链表尾*/        if (body->next==NULL)        {            body->next=temp;            temp->pre=body;        }        else        {            body->next->pre=temp;            temp->next=body->next;            body->next=temp;            temp->pre=body;        }    }    return head;}```c/*在第add位置的后面插入data节点*/Node * InsertListEnd(Node * head,int add,int data){    int i = 1;    /*新建数据域为data的结点*/    Node * temp=(Node*)malloc(sizeof(Node));    temp->data=data;    temp->pre=NULL;    temp->next=NULL;    Node * body=head;    while ((body->next)&&(inext;        i++;    }    /*判断条件为真,说明插入位置为链表尾*/    if (body->next==NULL)    {        body->next=temp;        temp->pre=body;        temp->next=NULL;    }    else    {        temp->next=body->pre->next;        temp->pre=body->pre;        temp->pre=body->pre;        body->pre->next=temp;    }    return head;}

    4.双向链表的删除

      双链表删除结点时,只需遍历链表找到要删除的结点,然后将该节点从表中摘除即可。  例如,删除元素 2 的操作过程如图 所示:5b63020ad64207975742b40bd6dcaa85.png

    Node * DeleteList(Node * head,int data){    Node * temp=head;    /*遍历链表*/    while (temp)    {        /*判断当前结点中数据域和data是否相等,若相等,摘除该结点*/        if (temp->data==data)         {            /*判断是否是头结点*/            if(temp->pre == NULL)            {                head=temp->next;                temp->next = NULL;                free(temp);                return head;            }            /*判断是否是尾节点*/            else if(temp->next == NULL)            {                temp->pre->next=NULL;                free(temp);                return head;            }            else            {                temp->pre->next=temp->next;                temp->next->pre=temp->pre;                free(temp);                return head;               }        }        temp=temp->next;    }    printf("Can not find %d!",data);    return head;}

    5.双向链表更改节点数据

      更改双链表中指定结点数据域的操作是在查找的基础上完成的。实现过程是:通过遍历找到存储有该数据元素的结点,直接更改其数据域即可。

    /*更新函数,其中,add 表示更改结点在双链表中的位置,newElem 为新数据的值*/Node *ModifyList(Node * p,int add,int newElem){    Node * temp=p;    /*遍历到被删除结点*/    for (int i=1; inext;    }    temp->data=newElem;    return p;}

    6.双向链表的查找

      通常,双向链表同单链表一样,都仅有一个头指针。因此,双链表查找指定元素的实现同单链表类似,都是从表头依次遍历表中元素。

    /*head为原双链表,elem表示被查找元素*/int FindList(Node * head,int elem){/*新建一个指针t,初始化为头指针 head*/    Node * temp=head;    int i=1;    while (temp)     {        if (temp->data==elem)        {            return i;        }        i++;        temp=temp->next;    }    /*程序执行至此处,表示查找失败*/    return -1;}

    7.双向链表的打印

    /*输出链表的功能函数*/void PrintList(Node * head){    Node * temp=head;    while (temp)     {        /*如果该节点无后继节点,说明此节点是链表的最后一个节点*/        if (temp->next==NULL)         {            printf("%d",temp->data);        }        else        {            printf("%d->",temp->data);        }        temp=temp->next;    }}

    8.测试函数及结果

    int main() {    Node * head=NULL;    //创建双链表    head=CreatList(head,5);    printf("新创建双链表为");    PrintList(head);    //在表中第 5 的位置插入元素 1    head=InsertListHead(head, 5,1);    printf("在表中第 5 的位置插入元素 1");    PrintList(head);    //在表中第 3 的位置插入元素 7    head=InsertListEnd(head, 3, 7);    printf("在表中第 3 的位置插入元素 7");    PrintList(head);    // //表中删除元素 7    head=DeleteList(head, 7);    printf("表中删除元素 7");    PrintList(head);    printf("元素 1 的位置是:%d",FindList(head,1));    //表中第 3 个节点中的数据改为存储 6    head = ModifyList(head,3,6);    printf("表中第 3 个节点中的数据改为存储6");    PrintList(head);    return 0;}

    12a6c55f4c81d245ba292ed8f4e53a92.png  大家的鼓励是我继续创作的动力,如果觉得写的不错,欢迎关注,点赞,收藏,转发,谢谢!以上代码均为测试后的代码。如有错误和不妥的地方,欢迎指出。部分内容参考网络,如有侵权,请联系删除。

    展开全文
  • 输入一棵二元查找树,将该二元查找树转换成一个排序双向链表 要求不能创建任何新的节点,只调整指针的指向 微软面试题
  • 给同学们的C语言课程设计练习作业一下难了不止一个档次,很多小伙伴第一次接触到了C语言的框架开发,了解了View(界面层)、Service(业务逻辑层)、Persistence(持久化层)的分离和耦合,一种面向过程的MVC的感觉...

    3dd64fd299597cb2b599cc1d28534b69.png

    给同学们的C语言课程设计练习作业一下难了不止一个档次,很多小伙伴第一次接触到了C语言的框架开发,了解了View(界面层)、Service(业务逻辑层)、Persistence(持久化层)的分离和耦合,一种面向过程的MVC的感觉。

    而这一切的基础就在于对链表的创建、删除、输出、写入文件、从文件读出......

    一、链表结构和静态/动态链表

    二、单链表的建立与遍历

    三、单链表的插入与删除

    四、双向链表的概念

    五、双向链表的建立与遍历

    六、双向链表的元素查找

    七、循环链表的概念

    八、合并两个链表的实例

    九、链表实战

    拓展思维、拉到最后去看看 (•̀ᴗ•́) ̑̑

    ============================================

    一、链表结构和静态/动态链表

    链表是一种常见的数据结构——与数组不同的是:

    1.数组首先需要在定义时声明数组大小,如果像这个数组中加入的元素个数超过了数组的长度时,便不能正确保存所有内容;链表可以根据大小需要进行拓展。

    2.其次数组是同一数据类型的元素集合,在内存中是按一定顺序连续排列存放的;链表常用malloc等函数动态随机分配空间,用指针相连。

    链表结构示意图如下所示:

    1cbc970f0c9dd2993327735cdbe990bf.png

    在链表中,每一个元素包含两个部分;数据部分和指针部分。数据部分用来存放元素所包含的数据,指针部分用来指向下一个元素。最后一个元素的指针指向NULL,表示指向的地址为空。整体用结构体来定义,指针部分定义为指向本结构体类型的指针类型。

    静态链表需要数组来实现,即把线性表的元素存放在数组中。数组单元存放链表结点,结点的链域指向下一个元素的位置,即下一个元素所在数组单元的下标。这些元素可能在物理上是连续存放的,也有可能是不连续的,它们之间通过逻辑关系来连接——这就要涉及到数组长度定义的问题,实现无法预知定义多大的数组,动态链表随即出现。

    动态链表指在程序执行过程中从无到有地建立起一个链表,即一个一个地开辟结点和输入各结点的数据,并建立起前后相连的关系。

    二、单链表的建立与遍历

    单链表中,每个结点只有一个指针,所有结点都是单线联系,除了末为结点指针为空外,每个结点的指针都指向下一个结点,一环一环形成一条线性链。

    链表的创建过程:

    2ec7b96e36b5f17355c19b130dd56d6e.png

    接下来在源码中建立并遍历输出一个单链表。

    d0ee08f4d85773f3bfadd6d300071ca3.png

    58f286832ed6292f5e89eef9dffc519f.png

    三、单链表的插入与删除

    在本实例中,插入时根据传递来的学号,插入到其后。

    删除时根据其所在链表的位置,删除并释放该空间。

    主函数增加如下:

    460ad62417fd301510135fae20b60d1c.png

    插入函数:

    fecfb78eb2d1d70990cc8d8f2466e2bc.png

    删除函数:

    dc807f033cca98b4eeefdc8e19a7a3de.png

    四、双向链表的概念

    双向链表基于单链表。单链表是单向的,有一个头结点,一个尾结点,要访问任何结点,都必须知道头结点,不能逆着进行。而双链表添加了一个指针域,通过两个指针域,分别指向结点的前结点和后结点。这样的话,可以通过双链表的任何结点,访问到它的前结点和后结点。

    在双向链表中,结点除含有数据域外,还有两个链域,一个存储直接后继结点的地址,一般称为右链域;一个存储直接前驱结点地址,一般称之为左链域。

    双向链表结构示意图:

    0c403e1285d4cad555acbf0d28b3d819.png

    446ad702313a8bdc26ae48f3acc005d4.png

    五、双向链表的建立与遍历

    双向链表的源码实战和单链表类似,只是多了第二个指针域的控制,这里直接贴上没有注释的源代码。

    9f61e8dd67398c7069fc6d7b8635ae62.png

    45b78ecc16aed61aa12abed9cc06dd00.png

    六、双向链表的元素查找

    查找函数 STUD *search(STUD *,char *);

    4dd387bbea54e77eb88b352dfa3543a6.png

    七、循环链表的概念

    类似于单链表,循环链表也是一种链式的存储结构,由单链表演化而来。

    单链表的最后一个结点的指针指向NULL,而循环链表的最后一个结点的指针指向链表头结点。

    这样头尾相连,形成了一个环形的数据链。

    循环链表的建立不需要专门的头结点。

    判断循环链表是否为尾结点时,只需判断该节点的指针域是否指向链表头节点。

    八、合并两个链表的实例

    建立两个带头节点的学生链表,每个节点包含学号、姓名和成绩,链表都按学号升序排列,将它们合并为一个链表仍按学号升序排列。

    算法分析:

    合并链表用merge()函数实现。函数中定义3个工作指针a、b、c,其中a、b分别指向La链表、Lb链表的当前结点,C指向合并后的链表尾结点。合并后链表的头结点共用La链表的头结点。

    ①合并前,先让a和b分别指向两个链表的第一个结点,c指向La链表的头结点。

    ②合并时应该分3种情况讨论,即La和Lb都没有处理完;La没处理完,但Lb处理完毕;Lb没处理完,但La处理完毕。

    ③合并过程中应始终将La和Lb链表中较小的一个链接在Lc中,方能保持有序。

    1eb7cb2961a663a2837755cf4aebfd92.png

    九、实战

    实战项目是一个“课程设计·账号系统”可以私信找我拿

    拓展思维、(•̀ᴗ•́) ̑̑

    既然双向链表可以多出一个指针域用来指向前一个结点,用llink和rlink区分这两个指针域;

    那么有没有可能再多几个指针域来放ulink和dlink呢(指向上面的结点和指向下面的结点)?

    这样就构成了形象的二维链表而不是一维链表了。

    当然,在物理内存上这些链表依然是线性关系。

    理论可以实现,那么三维链表呢?

    建议你们学数据结构的时候再拓展。

    “我是一名从事了10年开发的老程序员,最近我花了一些时间整理关于C语言、C++,自己有做的材料的整合,一个完整的学习C语言、C++的路线,学习材料和工具。全球最大的C/C++、编程爱好者的聚集地就在我这里<专栏里面>!欢迎初学和进阶中的小伙伴。希望你也能凭自己的努力,成为下一个优秀的程序员。工作需要、感兴趣、为了入行、转行需要学习C/C++的伙伴可以跟我一起学习!”

    关注我和我的专栏,带你遨游代码世界!

    程序猿zhuanlan.zhihu.com
    27640723a266d3b654bbb6e94a573faa.png

    最后分享一张C/C++学习路线图给爱学习的小伙伴们

    428a2ddfab858ca99e4d85c4e2ade53f.png

    ba5707715d1fff9888e5d14fe140e76b.png

    f4713081efb86773dffccfbdab15a63c.png

    89ae52a151a1a213ddde81b397fb1301.png

    7aa397fa1c3da81ca2c7aa60d6b612a9.png
    展开全文
  • /* head 和 tail 的指针的排序的时候,都有可能发生变化,所以这里使用二级指针 */ int quickSortDoubList(st_doubNode** phead, st_doubNode ** ptail){ if(NULL == phead || NULL == *phead || NULL == ptail || ...

    算法草稿

    代码实现

    /* head 和 tail 的指针的排序的时候,都有可能发生变化,所以这里使用二级指针 */
    int quickSortDoubList(st_doubNode** phead, st_doubNode ** ptail){
    	if(NULL == phead || NULL == *phead || NULL == ptail || NULL == *ptail){
    		printf("%s: param error\n",__func__);
    		return PARAM_ERR;
    	}
    
    	st_doubNode * head = NULL;
    	st_doubNode * tail = NULL;
    	st_doubNode * p = NULL;
    	st_doubNode * mov = NULL;
    	st_doubNode * prev = NULL;
    	st_doubNode * next = NULL;
    	st_doubNode * pivotpos = NULL;
    	int pivot = 0;
    
    	head = *phead;
    	tail = *ptail;
    
    	/*迭代退出的条件, 只有一个元素,或者没有元素*/
    	if(head == tail)
    {
    		printf("\t exit resc head = %d \n", head->data);
    		return SUCCESS;
    	}
    	
    	pivotpos = head;
    	pivot = pivotpos->data;
    	p = head;
    
    	while(NULL != p){
    		/*小于的移动到pivot之前*/
    		if(p->data < pivot){
    			mov = p; /*要移动的变量*/
    			p = p->next; /*下一轮位置变量*/
    
    			/*摘除*/
    			mov->prev->next = mov->next;
    			if(NULL != mov->next){ 
    				mov->next->prev = mov->prev;
    			} else { /*尾结点处理,mov是尾结点的时候*/
    				/*更新tail, 为新的尾结点*/
    				tail = mov->prev;
    			}
    			
    			/*挂载*/
    			mov->next = head;
    			mov->prev = NULL;
    			head->prev = mov;
    
    			/*更新新的head*/
    			head = mov;
    			continue;
    		}
    		/*大于pivot不变*/
    		p = p->next;
    	}
    
    #ifdef DEBUG
    	st_doubNode * q = NULL;
    	printf("\n---------------------------\n");
    	printf("\t[ ");
    	q = head;
    	while(q != pivotpos){
    		printf(" %d ", q->data);
    		q = q->next;
    	}
    	printf("] ");
    	printf(" pivot = %d ", q->data);
    	printf(" [ ");
    	q = pivotpos->next;
    	while(q != tail){
    		printf(" %d ", q->data);
    		q = q->next;
    	}
    	printf(" %d ", tail->data);
    	printf("] \n");
    	
    	printf("---------------------------\n");
    	
    #endif
    
    	prev = pivotpos->prev;
    	next = pivotpos->next;
    	
    	/*
    	 * 对小的子链排序
    	 * 注意 排序后,pivot 是第一个元素的时候,前面就没有元素了,不用排序了
    	 * 这时候 prev 为 NULL,就不用在排序了
    	 */	
    	if(prev != NULL){
    		quickSortDoubList(&head, &prev);
    	}
    	
    	/*
    	 * 对大的子链排序
    	 * 注意 排序后,pivot 是最后一个元素的时候,后面就没有元素了,不用排序了
    	 * 这时候 next 为 NULL,就不用在排序了
    	 */
    	if (next != NULL){
    		quickSortDoubList(&next, &tail);
    	}
    
    	/*因为next可能变化,重新连接*/
    	pivotpos->next = next;
    	next->prev = pivotpos;
    
    	*phead = head;
    	*ptail = tail;
    		
    	return SUCCESS;
    }
    
    
    void testquickSortDoubList(void){
    	printf("\n************  testquickSortDoubList ************ \n");
    	st_doubNode * tail = NULL;
    	tail = getDouListTail(gDoubHead);
    	
    	quickSortDoubList(&gDoubHead, &tail);
    	
    	dumpDoubList(gDoubHead);
        dumpDoubListReverse(gDoubHead);
    	return;
    }

    调试编译

    gcc listMain.c doublist.c -o a.exe -DDEBUG

    调试输出

    ========= Dump Double List 0x25ac010 ===========
             22  32  19  53  0  47  29  116  4  6
    ===================================
    ========= dump DoubList Reverse 0x25ac130 ===========
             6  4  116  29  47  0  53  19  32  22
    ================================================
    
    ************  testquickSortDoubList ************
    
    ---------------------------
            [  6  4  0  19 ]  pivot = 22  [  32  53  47  29  116 ]
    ---------------------------
    
    ---------------------------
            [  0  4 ]  pivot = 6  [  19 ]
    ---------------------------
    
    ---------------------------
            [ ]  pivot = 0  [  4 ]
    ---------------------------
             exit resc head = 4
             exit resc head = 19
    
    ---------------------------
            [  29 ]  pivot = 32  [  53  47  116 ]
    ---------------------------
             exit resc head = 29
    
    ---------------------------
            [  47 ]  pivot = 53  [  116 ]
    ---------------------------
             exit resc head = 47
             exit resc head = 116
    ========= Dump Double List 0x25ac090 ===========
             0  4  6  19  22  29  32  47  53  116
    ===================================
    ========= dump DoubList Reverse 0x25ac0f0 ===========
             116  53  47  32  29  22  19  6  4  0
    ================================================
    

     

     

     

    展开全文
  • C语言实现双向列表的创建,删除,添加节点,删除节点,插入节点,遍历节点,打印节点,并结合插入排序法实现了基于双向链表的升序排序
  • 之前一直想用双向链表来快排,想像数组快排一样给第一个数组下标(第一个有值节点的指针)和最后一个数组下标(最后一个有值节点指针),结果运行时经常有问题,程序有时会出错,于是纸上演算了几次发现会访问到未知的内存. ...
  • C语言双向链表 快速排序

    万次阅读 2007-05-17 13:06:00
    * Description : 对双向链表进行快速排序 *********************************************************************/ #include #include #include //定义类型 所有的排序例子中都是用的int作为data...
  • C语言双向链表

    2019-05-27 15:15:07
    包含双向链表的创建,插入,遍历,查找,排序,删除,销毁。 #include <stdio.h> typedef struct node { int data; struct node *next; struct node *pre; }Node; Node *creatList() { Node *head = ...
  • 双向链表的基本操作  1.利用尾插法建立一个双向链表。  2.遍历双向链表。  3.实现双向链表中删除一个指定元素。  4.在非递减有序双向链表中实现插入元素e仍有序算法。  5.判断双向链表中元素是否对称...
  • 本程序主要实现c语言链表冒泡排序的功能,代码如下,需要者可以自取。(你电同学可以借鉴排序功能,但最好还是看懂后自己写) 难点分析:第一个交换需要引出前驱和最后一个的交换需要引出后继节点。 #include <...
  • 数据结构之C语言实现双向链表

    千次阅读 多人点赞 2018-07-07 12:17:29
    C语言实现双向链表 双向链表主要实现以下功能: 双向链表创建 节点头插 节点尾插 指定位置插入节点 节点删除 链表排序 链表求长 /********************************************************************...
  • 题目:输入一棵二元查找树,将该二元查找树转换成一个排序双向链表。 要求不能创建任何新的结点,只调整指针的指向。 本题目是微软的算法题,正好之前做过二叉树的遍历算法。就在之前的基础上面研究,发现之前的...
  • 几乎每一位码士的编程起点都是C,在玩过了Java、C#、PHP、Python之后,...如何创建二叉树如何遍历二叉树如何创建二叉链表怎样使用递归算法 这是一道非常老土但又十分经典的数据结构题,或许很多人会说自己...
  • 使用C语言来实现一个通用的双向链表。利用这个链表来统计一篇文章的不同词数,针对不同单词和同一单词的不同拼写形式进行排序 本文利用了C语言来实现了一个通用的双向链表,其中双向链表的实现借鉴了 实现通用的双向...
  • 从txt文件中读取5 4 2 3 1 10 6 8 7 9 到数组中,建立了两个递增排序双向链表,内容分别为 1 2 3 4 5和6 7 8 9 10,现在想将两个链表合并输出一个递增的双向链表,输出时少了1和6 两个数字,双向链表创建时没有...
  • //保存P的前一个节点,在P=NULL的时候,P的前一个节点就代表是这个链表的最大值,如果data还大于目前最大值,则把data的节点设置为最大值 while (p!=NULL&&data > p->data) { pPrev = p; p = p->next; } ...
  • C语言链表节点排序

    千次阅读 2019-05-07 19:54:45
    我的课程设计项目为“学生成绩管理系统”,所用链表为双向链表链表。 涉及到成绩管理则避免不了成绩的排序。 结构体中的项目包括: 学生成绩; 学生姓名; 学生学号; 结构体的头指针与尾指针; 先创建结构体: #...
  • C语言实现链表之双向链表(十五)测试用例  上一篇文章给出了最后的两个函数,即链表打印和排序,这篇文章将给出所有函数的测试用例,即ListTestTop.c文件。 /* ********************************************...
  • 双向链表的增、删、查、改、销毁、快速排序Main.cDoubleList.hDoubleList.c Main.c #include &amp;amp;quot;DoubleList.h&amp;amp;quot; #include &amp;amp;amp;lt;time.h&amp;amp;amp;gt; ...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 136
精华内容 54
关键字:

双向链表排序c语言

c语言 订阅