精华内容
下载资源
问答
  • 双向链表C语言实现

    2018-12-13 13:36:34
    通过双向链表实现按照ID序列插入,可以排序实现插入、删除、更新、修改;
  • 使用双向链表实现快速排序C语言,有详细注释
  • 输入一棵二元查找树,将该二元查找树转换成一个排序双向链表 要求不能创建任何新的节点,只调整指针的指向 微软面试题
  • 本程序主要实现c语言链表冒泡排序的功能,代码如下,需要者可以自取。(你电同学可以借鉴排序功能,但最好还是看懂后自己写) 难点分析:第一个交换需要引出前驱和最后一个的交换需要引出后继节点。 #include <...

    本程序主要实现c语言双向链表冒泡排序的功能,代码如下,需要者可以自取。(你电同学可以借鉴排序功能,但最好还是看懂后自己写)
    难点分析:第一个交换需要引出前驱和最后一个的交换需要引出后继节点。

    #include <time.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    typedef struct Lnode
    {  
          int data;
          struct Lnode *next,*prior;
    }Lnode;
    
    
    typedef struct List{
    	Lnode *head;
    	Lnode *tail;
    	int length;	
    }list;
    
    
    void Creatlist(list *table)  //创建双向链表 
    {
    	int x,i;
    	Lnode *temp,*t,*p;
    	table->head=NULL;
    	table->tail=NULL;
    	table->length=0;
    	x=1;
    	scanf("%d",&x);
    	for(i=0;x!=0;i++)
    	{
    		/*fflush(stdin);*/
    		temp=(Lnode*)malloc(sizeof(Lnode));
    		temp->data=x;
    		temp->next=NULL;
    		temp->next=table->head;
    		table->head=temp;
    		table->length++;
    		scanf("%d",&x);
    	}
    	t=table->head;
    	t->prior=NULL;
    	for(i=2;i<=table->length;i++)
    	{
    		p=t;
    		t=t->next;
    		t->prior=p;
    	}
    }
    
    
    void Show_list(list *table)  //遍历打印双向链表 
    {
    	int x,i;
    	Lnode *temp;
    	printf("\nThe list is %d num:\n",table->length);
    	temp=table->head;
    	while(temp->next!=NULL)
    	{
    		temp=temp->next;
    	}
    	for(i=0;i<table->length;i++)
    	{
    		x=temp->data;
    		printf("%d\n",x);		
    		temp=temp->prior;
    	}
    	
    }
    
    
    void sort(list *table)
     {
        //判空
        if (table == NULL) 
    	{
            return;
        }
    	
        //初始化辅助指针
        Lnode *pPre = table->head;
        Lnode *pCurrent = table->head;
    //  //循环次数
        int num = table->length;
    	int i,j;
        for (i = 1; i < num; i++) 
    	{
            //重置指针位置
            pPre = table->head;
            pCurrent = pPre->next;
            for (j = 1; j <= num-i; j++)/*循环条件*/
    		{
    		
               if(pPre->data > pCurrent->data) 
    			{
    			   	if (pCurrent->next == NULL)     //节点尾节点情况
    				{
                        pPre->next = pCurrent->next;
                        pCurrent->prior = pPre->prior;
                        pCurrent->next = pPre;
                        pPre->prior->next = pCurrent;
                        pPre->prior = pCurrent;
    					break;
                    }
    				if (pPre->prior == NULL)     //节点头节点情况
    				{
    					table->head =  pCurrent;
                       //pPre与新前驱建立联系
    				    /*pPre->prior->next = pCurrent;*/
    				    pCurrent->prior = pPre->prior;
    				
    				    //pCurrent与新后驱建立联系
    				    pCurrent->next->prior = pPre;
    				    pPre->next = pCurrent->next;
    				
    				    //pPre与pCurrent互连
    				    pPre->prior = pCurrent;
    				    pCurrent->next = pPre;
    
                        //pCurrent指针后移到pPre前面
                        pCurrent = pPre->next;
    					continue;
                    }
    			
    			       	//非尾节点情况 
                        //交换节点
                        //指针转换	此处注意6个指针交换
    				    //pPre与新前驱建立联系
    				    pPre->prior->next = pCurrent;
    				    pCurrent->prior = pPre->prior;
    				
    				    //pCurrent与新后驱建立联系
    				    pCurrent->next->prior = pPre;
    				    pPre->next = pCurrent->next;
    				
    				    //pPre与pCurrent互连
    				    pPre->prior = pCurrent;
    				    pCurrent->next = pPre;
    
                        //pCurrent指针后移到pPre前面
                        pCurrent = pPre->next;
                }
                //pPre->data > pCurrent->data非真情况下
            	else
    			{
                    pPre = pPre->next;
                    pCurrent = pCurrent->next;
                }
        }
        }
    }
    
    
    int main()
    {
    	list table;
    	printf("Please input the number to creat the list\n");
    	Creatlist(&table);
    	Show_list(&table);
    	sort(&table);
    	printf("\nAfter sort become:\n");
    	Show_list(&table);
    	
    }
    
    

    代码演示略,输入以0结束
    在这里插入图片描述

    展开全文
  • 双向链表的定义上一节学习了单向链表单链表详解。今天学习双链表。学习之前先对单向链表和双向链表做个回顾。单向链表特点:  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语言实现双向链表

    千次阅读 多人点赞 2018-07-07 12:17:29
    C语言实现双向链表 双向链表主要实现以下功能: 双向链表创建 节点头插 节点尾插 指定位置插入节点 节点删除 链表排序 链表求长 /********************************************************************...

    C语言实现双向链表

    双向链表主要实现以下功能:

    • 双向链表创建
    • 节点头插
    • 节点尾插
    • 指定位置插入节点
    • 节点删除
    • 链表排序
    • 链表求长
    /****************************************************************************************************** 
     *   function:自定义一个双向链表,并完成一些双向链表的操作:创建链表、数据插入、数据删除、链表排序 
     *   author:yahai.zhang 
     *   time: 2018.7.15
     *   File Name:DList.c
     ******************************************************************************************************/ 
    
    #include <stdio.h>
    
     /* 定义数据结构 */
    struct DouLinkNode {
        int data ;               //链表中存放的数据,可以自定义数据结构 
        struct DouLinkNode *pre ,*next;
    };
    
    /* 双向链表创建 */ 
    struct DouLinkNode *create(int n)
    {   
        int x;
        struct DouLinkNode *head = (struct DouLinkNode *)malloc(sizeof(struct DouLinkNode));
        struct DouLinkNode *p,*s;
        p = head;
        p->pre = NULL;
        while(n) {
            s = (struct DouLinkNode*)malloc(sizeof(struct DouLinkNode));
            printf("input data of the node:data=");
            scanf("%d",&x);
            s->data = x;
            p->next = s;
            s->pre = p;
            p = s;
            n--;
        }
        s->next = NULL;
        return head;
    }
    
     /* 双向链表打印 */
    void display(struct DouLinkNode *head)
    {
        struct DouLinkNode *p = head->next;
        while(p->next) {
            printf("%d <---> ",p->data);
            p = p->next;
        }
        printf("%d \n",p->data);
    }
    
    /* 链表头插节点 */
    void insertListHead(struct DouLinkNode *pList, int data)
    {
        struct DouLinkNode *pNode = (struct DouLinkNode *)malloc(sizeof(struct DouLinkNode));
        pNode->data = data;
        pNode->next = pList->next;
        pNode->pre = pList;
        if (NULL != pNode->next) {
            pNode->next->pre = pNode;
        }
        pList->next = pNode;
    }
    
    /* 链表尾插节点 */ 
    void insertListTail(struct DouLinkNode *pList, int data)
    {
        struct DouLinkNode *pNode = (struct DouLinkNode *)malloc(sizeof(struct DouLinkNode));
        pNode->data = data;
        struct DouLinkNode *pCur = pList; 
        while(NULL != pCur->next) {
            pCur = pCur->next;
        }
        pCur->next = pNode;
        pNode->pre = pCur;
        pNode->next = NULL;
    }
    
    /* 在链表的指定位置插入节点: index = 0 ---> 头插; index = length ---> 尾插 */
    int insertList(struct DouLinkNode *pList, int data, int index)
    {
        struct DouLinkNode *pCur = pList; 
        int len =  get_List_Length(pCur);
        if(index > len) {
            return -1;
        } else if (index == 0) {
            insertListHead(pList, data);
            return 0;
        } else if(index == len) {
            insertListTail(pList, data);
            return 0;
        }
    
        struct DouLinkNode *pNode = (struct DouLinkNode *)malloc(sizeof(struct DouLinkNode));
        pNode->data = data;
        pCur = pList;
        int i = 0;
        while( index--) {
            pCur = pCur->next;
        }
        pNode->next = pCur->next;
        pCur->next = pNode;
        pNode->pre = pCur;
        pNode->next->pre = pNode;   
    }
    
    /* 删除链表中的指定值 */
    int deleteListNode(struct DouLinkNode *pList, int key)
    {
        struct DouLinkNode *pPre = pList;
        struct DouLinkNode *pCur = pList->next;
        int count = 0; //记录删除节点个数 
        while(NULL!=pCur) {
            if(pCur->data == key) {
                if(NULL != pCur->next) {
                    pCur->next->pre = pCur->pre;
                }
                pCur->pre->next = pCur->next;
                pPre = pCur; 
                pCur = pCur->next;
                free(pPre);
                count ++;
            } else {
                pPre = pCur;
                pCur = pCur->next;
            }
        }
        return count; 
    }
    
    /* 链表求长 */
    int get_List_Length(struct DouLinkNode *head)
    {
        struct DouLinkNode *p;
        int len = 0;
        p = head;
        for (p; p->next!=NULL; p=p->next) {
            len++;
        }
        return len;
    }
    
    /* 双向链表排序 */
    struct DouLinkNode *sort(struct DouLinkNode *head)
    {
        struct DouLinkNode *p,*s,*min;
        int tmp;
    
        for(p = head->next ;p->next!=NULL ;p=p->next) {
            min = p ;
            for(s= p->next ; s!=NULL ;s=s->next) {
                if(s->data <min->data)
                    min = s;               //找到每次排序中最小的节点,然后记住这个节点
            } if(min != p) {               //把这个节点与前面的节点的数据进行交换,把最小的数据放在前面的节点内。
                tmp = min->data;
                min->data = p->data;
                p->data = tmp;
            }
        }
        return head;
    }
    
    int main()
    {
        struct DouLinkNode  *head,*head1;
        int n;
        int data;
        printf("input n:");
        scanf("%d",&n);
        head = create(n);
        display(head);
        printf("insert node from head: data=");
        scanf("%d", &data);
        insertListHead(head, data);
        display(head);
        printf("insert node from tail: data=");
        scanf("%d", &data);
        insertListTail(head, data);
        display(head);
        printf("insert the data(100) into the list:\n");
        insertList(head, 100, 4);
        display(head);
        printf("please input the data you want to delete: data=");
        scanf("%d", &data);
        int k = deleteListNode(head, data);
        printf("success! delete nodes:%d\n", k);
        display(head);
        printf("the list length:%d\n", get_List_Length(head));
        printf("sort the list:\n");
        head1 = sort(head);
        display(head1);
    
        return 0;
    }
    

    运行结果如下所示:

    实验目标

    图1 运行结果

    展开全文
  • //保存P的前一个节点,在P=NULL的时候,P的前一个节点就代表是这个链表的最大值,如果data还大于目前最大值,则把data的节点设置为最大值 while (p!=NULL&&data > p->data) { pPrev = p; p = p->next; } ...
    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct Node* NodePtr;
    
    typedef struct Node
    {
    	int data;
    	NodePtr prev;
    	NodePtr next;
    } Node;
    
    void putPrev(int data, NodePtr head) {
    	NodePtr node = (NodePtr)malloc(sizeof(Node));
    	if (node==NULL)
    	{
    		printf("node==NUll");
    		return;
    	}
    	node->data = data;
    	node->next = NULL;
    	node->prev = NULL;
    	NodePtr p = head;
    	while (p->prev!=NULL)
    	{
    		p = p->prev;
    	}
    	node->next = p;
    	p->prev = node;
    }
    
    void putNext(int data, NodePtr head) {
    	NodePtr node = (NodePtr)malloc(sizeof(Node));
    	if (node == NULL)
    	{
    		printf("node==NUll");
    		return;
    	}
    	node->data = data;
    	node->next = NULL;
    	node->prev = NULL;
    	NodePtr p = head;
    	while (p->next != NULL)
    	{
    		p = p->next;
    	}
    	node->prev = p;
    	p->next = node;
    }
    
    //插入并排序
    void putBySort(int data, NodePtr head) {
    
    	NodePtr node = (NodePtr)malloc(sizeof(Node));
    	if (node == NULL)
    	{
    		printf("node==NUll");
    		return;
    	}
    	node->data = data;
    	node->next = NULL;
    	node->prev = NULL;
    	NodePtr p = head;
    	if (data>p->data)
    	{
    		NodePtr pPrev = p;//保存P的前一个节点,在P=NULL的时候,P的前一个节点就代表是这个链表的最大值,如果data还大于目前最大值,则把data的节点设置为最大值
    		while (p!=NULL&&data > p->data) {
    			pPrev = p;
    			p = p->next;
    		}
    		if (p == NULL)
    		{
    			pPrev->next = node;
    			node->prev = pPrev;
    		}
    		else {
    			pPrev->next = node;
    			node->prev = pPrev;
    			node->next = p;
    			p->prev = node;
    		}
    		
    	}
    	else {
    		NodePtr pNext = p;//保存P的后一个节点,在P=NULL的时候,P的后一个节点就代表是这个链表的最小值,如果data还小于目前最小值,则把data的节点设置为最大值
    		while (p != NULL&&data < p->data) {
    			pNext = p;
    			p = p->prev;
    		}
    		if (p == NULL)
    		{
    			pNext->prev = node;
    			node->next = pNext;
    		}
    		else {
    			pNext->prev = node;
    			node->next = pNext;
    			node->prev = p;
    			p->next = node;
    		}
    	}
    }
    
    //冒泡排序
    void sort(NodePtr head) {
    
    	NodePtr p = head;
    	NodePtr pNext = p->next;
    
    	if (pNext == NULL)//只有一个参数
    	{
    		return;
    	}
    	if (pNext->next ==NULL && p->data > pNext->data)//只有两个参数
    	{
    		p->next = NULL;
    		p->prev = pNext;
    		pNext->next = p;
    		pNext->prev = NULL;
    		return;
    	}
    	NodePtr q;
    	int tmp;
    	for (; p->next!=NULL; p=p->next)
    	{
    		for (q=p->next; q!=NULL; q = q->next)
    		{
    			if (q->data < p->data)
    			{
    				tmp = q->data;
    				q->data = p->data;
    				p->data = tmp;
    			}
    		}
    	}
    }
    
    
    //查
    NodePtr getNode(int position, NodePtr head) {
    	NodePtr p = head;
    	int i = 0;
    	for (; p != NULL; p = p->next) {
    		i++;
    		if (i == position)
    		{
    			break;
    		}
    	}
    	return p;
    }
    
    //增
    void insertNode(int data, int position,NodePtr head) {
    	
    	NodePtr node = (NodePtr)malloc(sizeof(Node));
    	node->data = data;
    	node->next = NULL;
    	node->prev = NULL;
    
    	NodePtr p = getNode(position, head);
    	NodePtr pNext = p->next;
    	NodePtr pPrev = p->prev;
    	pPrev->next = node;
    	node->prev = pPrev;
    	node->next = p;
    	p->prev = node;
    }
    
    //删除节点
    void deleteNode(int position, NodePtr head) {
    	NodePtr p = getNode(position, head);
    	NodePtr pNext = p->next;
    	NodePtr pPrev = p->prev;
    	pPrev->next = pNext;
    	pNext->prev = pPrev;
    	p->next = NULL;
    	p->prev = NULL;
    	p->data = 0;
    }
    
    //改
    void modifyNode(int data,int position, NodePtr head) {
    	NodePtr p = getNode(position, head);
    	p->data = data;
    }
    
    //打印链表
    void printNode(NodePtr list) {
    	//找到最前面的节点
    	NodePtr nodePrev = list;
    	while (nodePrev->prev != NULL)
    	{
    		nodePrev = nodePrev->prev;
    	}
    	NodePtr node = nodePrev;
    	while (node != NULL)
    	{
    		printf("%d ", node->data);
    		node = node->next;
    		if (node!=NULL)
    		{
    			printf(",");
    		}
    	}
    	printf("\n");
    }
    
    void main() {
    
    	int i = 0;
    	NodePtr list= (NodePtr)malloc(sizeof(Node));
    	list->data = 10;
    	list->next = NULL;
    	list->prev = NULL;
    
    	int intArr[] = {5,1,20,15,22,11,19,50,18,40,45,30,65};
    	int length = sizeof(intArr) / sizeof(intArr[0]);
    
    	//插入的时候排序
    	/*for (i = 0; i < length; i++)
    	{
    		putBySort(intArr[i], list);
    	}*/
    
    	//插入数据
    	for (i = 0; i < length; i++)
    	{
    		putNext(intArr[i], list);
    	}
    
    	//首次插入数据后
    	printf("首次插入数据后:\n");
    	printNode(list);
    
    	//增
    	int position = 5;
    	int addNum = 6;
    	insertNode(addNum, position, list);
    	//添加数字后
    	printf("在第%d位插入数据%d后:\n",position,addNum);
    	printNode(list);
    
    	//删
    	position = 10;
    	deleteNode(position, list);
    	printf("删除第%d位数据后:\n", position);
    	printNode(list);
    
    	//改
    	position = 4;
    	int modifyNum = 12;
    	modifyNode(modifyNum, position, list);
    	printf("将第%d位数据改为%d后:\n", position,modifyNum);
    	printNode(list);
    
    	//查
    	position = 9;
    	NodePtr p = getNode(position,list);
    	printf("第%d位数据为%d。\n", position, p->data);
    
    	//冒泡排序
    	sort(list);
    	printf("冒泡排序后:\n");
    	printNode(list);
    
    	system("pause");
    }


    展开全文
  • C语言实现双向循环链表 题目:要求实现根据要求的数字,使26个字母排序发生变化,例如数字为3,输出结果: DEFGHIJKLMNOPQRSTUVWXYZABC 同时支持负数,如-3 XYZABCDEFGHIJKLMNOPQRSTUVW 代码 /* * @Author: xgh * ...
  • C语言实现链表之双向链表(十五)测试用例  上一篇文章给出了最后的两个函数,即链表打印和排序,这篇文章将给出所有函数的测试用例,即ListTestTop.c文件。 /* ********************************************...
  • C语言实现双向列表的创建,删除,添加节点,删除节点,插入节点,遍历节点,打印节点,并结合插入排序法实现了基于双向链表的升序排序
  • 实现通用的双向链表c语言实现) 读李先静《系统程序员成长计划》内容总结 这几篇文章。向其表示感谢。 首先,我们要创建一个链表,然后对于链表中的一些操作(创建链表,插入数据,查找数据)等等基本的操作进行...
  • 代码实现 /* head 和 tail 的指针的排序的时候,都有可能发生变化,所以这里使用二级指针 */ int quickSortDoubList(st_doubNode** phead, st_doubNode ** ptail){ if(NULL == phead || NULL == *phead || NULL =...
  • 实现双向链表中删除一个指定元素。  4.在非递减有序双向链表实现插入元素e仍有序算法。  5.判断双向链表中元素是否对称若对称返回1否则返回0。  6.设元素为正整型,实现算法把所有奇数排列在偶数之前。  ...
  •   最近感觉自己对数据结构的理解比较薄弱,所以重新思考并设计了双向链表,在此详细记录一下,方便日后回看,在这里推荐一本书籍《系统程序员成长计划》 李先静 著,多学多思考,好的代码是给人看的,其次才是给...
  • 尝试用链表代替数组来完成一个简易的系统设计,不过一开始没构思好,干脆用了单向链表加双向链表,稍显有点麻烦。 void show_main_menu(){ printf("1.添加用户\n"); printf("2.删除用户\n"); printf("3.查找...
  • 题目:输入一棵二元查找树,将该二元查找树转换成一个排序双向链表。 要求不能创建任何新的结点,只调整指针的指向。 本题目是微软的算法题,正好之前做过二叉树的遍历算法。就在之前的基础上面研究,发现之前的...
  • C语言实现链表(三)

    2017-05-23 17:18:59
    如下是实现双向链表的源代码,主要包括:创建链表、插入结点(头插法、尾插法)、遍历链表、删除结点、排序(插入、快速)、主函数(验证函数功能),源代码如下: #include #include #include #include #include //...
  • 上次写的一个双向链表有位朋友给我留言说希望能让我帮忙实现连表排序,但是不是值交换而是节点交换,今天终于有时间来分享了,晚了点实在不好意思。上次的文章链表我是用结构体struct封装的,用起来不是很方便,这边...
  • 之前也写过一篇C语言实现简单的双向循环链表,现在使用C++再来扩展一下内容。除了节点的插入、删除,还增加了一些链表的其他操作,包括节点修改、节点替换、节点查找、值查找、值排序等等。内容还是挺丰富的,废话不...
  • 常见基础算法大集合(C语言实现

    千次阅读 2011-11-15 15:42:54
    (1) 排序算法  快速排序    合并排序 ... 链表排序  (2) 数据结构  线性队列  线性堆栈  单向链表  双向链表  循环单向链表  排序二叉树(插入,删除上、中、下、保存
  • 链表表示多项式,分别在对指数排序和不排序的情况下,写出求两个给定多项式的乘法的函数。并分析其复杂度 二、实验设计 Josephus环问题:用游标构造双向循环链表。首先创建全局的结构体数组,每个结构体包括元素...
  • 《妙趣横生的算法(C语言实现)》可作为算法入门人员的教程,也可以作为学习过C语言程序设计的人士继续深造的理想读物,也可作为具有一定经验的程序设计人员巩固和提高编程水平,查阅相关算法实现和数据结构知识的参考...
  • 在书上载录下面的代码,进行学习。   #include <studio.h> /*头文件*/ /*自定义数据类型 NODE, 用于表示每一个待排序的数据*/ .../*插入新节点node至双向链表 head中*/ insertLt(NODE *head, NO
  • 链表

    2020-05-02 13:00:21
    C语言实现双向循环链表,并完成头插、尾插、头删、尾删、查找、打印、排序、逆序、按值插入等…… testMain.c /*双链表*/ #include"list.h" int main() { DCList mylist; DCListInit(&mylist); ...
  • 18. C语言实现动态数组 100 19. C语言笔试-运算符和表达式 104 20. C语言编程准则之稳定篇 107 21. C语言编程常见问题分析 108 22. C语言编程易犯毛病集合 112 23. C语言缺陷与陷阱(笔记) 119 24. C语言防止缓冲区...
  • 高级C语言详解

    2012-08-18 09:49:27
    18. C语言实现动态数组 100 19. C语言笔试-运算符和表达式 104 20. C语言编程准则之稳定篇 107 21. C语言编程常见问题分析 108 22. C语言编程易犯毛病集合 112 23. C语言缺陷与陷阱(笔记) 119 24. C语言防止缓冲区...
  • 免费下载:C语言难点分析整理.doc

    千次下载 热门讨论 2012-02-29 15:30:53
    18. C语言实现动态数组 100 19. C语言笔试-运算符和表达式 104 20. C语言编程准则之稳定篇 107 21. C语言编程常见问题分析 108 22. C语言编程易犯毛病集合 112 23. C语言缺陷与陷阱(笔记) 119 24. C语言防止缓冲区...
  • C语言难点分析整理

    2013-07-19 15:09:14
    18. C语言实现动态数组 100 19. C语言笔试-运算符和表达式 104 20. C语言编程准则之稳定篇 107 21. C语言编程常见问题分析 108 22. C语言编程易犯毛病集合 112 23. C语言缺陷与陷阱(笔记) 119 24. C语言防止缓冲区...
  • 史上最强的C语言资料

    2010-06-17 18:43:14
    18. C语言实现动态数组 100 19. C语言笔试-运算符和表达式 104 20. C语言编程准则之稳定篇 107 21. C语言编程常见问题分析 108 22. C语言编程易犯毛病集合 112 23. C语言缺陷与陷阱(笔记) 119 24. C语言防止缓冲区...

空空如也

空空如也

1 2 3 4
收藏数 70
精华内容 28
关键字:

双向链表排序c语言实现

c语言 订阅