精华内容
下载资源
问答
  • C语言 单向链表倒序

    2012-07-09 11:18:35
    #include #include typedef struct _ListElement ListElement; struct _ListElement{  ListElement* next;  int x;  }; ListElement* reservet( ListElement* ele ) {  ListElement* curEle = ... Lis

    #include <stdio.h>
    #include <malloc.h>

    typedef struct _ListElement ListElement;

    struct _ListElement{

     ListElement* next;
     int x; 

    };

    ListElement* reservet( ListElement* ele )
    {

     ListElement* curEle = ele;
     ListElement* lastEle = ele;
     ListElement* tmpEle = NULL;

     while (curEle)
     {
      tmpEle = curEle->next;
      curEle->next = lastEle;
      lastEle = curEle;
      curEle = tmpEle;
     }

     ele->next = NULL;

     return lastEle;

    }

    int main()
    {

     ListElement* tmpEle = NULL;
     ListElement* firstEle = NULL;
     int i;
     for ( i = 0; i < 10; ++i)
     {
      ListElement* newEle = (ListElement*)malloc(sizeof(ListElement));
      newEle->x = i;
      newEle->next = NULL;
      if (tmpEle)
      {
       tmpEle->next = newEle;
      }
      else
      {
       firstEle = newEle;
      }
      tmpEle = newEle;
     }

     tmpEle = reservet( firstEle );
     firstEle = tmpEle;

     while(tmpEle)
     {
      printf( "%d\n", tmpEle->x);
      tmpEle = tmpEle->next;
     }

     tmpEle = firstEle;
     while(tmpEle)
     {
      firstEle = tmpEle;
      tmpEle = tmpEle->next;
      free(firstEle);
     }

     getchar();

     return 0;
    }

    展开全文
  • C语言链表倒序

    nhead 与 a的前后前后
    不是很搞明白 先藏着

    plist Reverse(plist head)       ///实现链表倒序的函数
    {
        plist nhead = NULL, a = NULL, b = NULL;
        a = head;  ///给一个头指针给a  a 是在前头的
        while(a)
        {
            b = a->next;
            a->next = nhead; 
            nhead = a;  ///nhead 在后头
            a = b;     ///a 在前头
        }
        return nhead;
    }
    展开全文
  • ![图片说明](https://img-ask.csdn.net/upload/201612/04/1480814503_859517.jpg) P3=P2->next;P2->next=P1; 这两句怎么理解。。P2->next=P1不会出现P2->P1->P2的循环吗? C语言刚入门。
  • #include<stdio.h> #include<stdlib.h> typedef struct Node{ ...为什么输出的姓名与年龄是倒序的?求大神指导谢谢[img=https://img-bbs.csdn.net/upload/201604/06/1459942664_517347.png][/img]
  • CSDN第一篇博客-C语言链表操作

    千次阅读 多人点赞 2019-03-31 11:26:24
    一个小白的C语言学习成长 ...用C语言首先构建链表的一系列的操作,其中包括链表的生成,链表的排序,链表倒序,改变两两节点指向,头插法,尾插法等基本操作。直接上代码。代码中有详细的注解 5. typ...

    一个小白的C语言学习成长

    第一次写博客,也是一个小白,非计算机专业的小白,想通过一个平台慢慢提高自己,慢慢记录自己的成长,也希望CSDN社区的小伙伴们能够宽容我这样的小白,有什么不对的地方希望各位能见谅。

    C语言实现链表的操作

    用C语言首先构建链表的一系列的操作,其中包括链表的生成,链表的排序,链表的倒序,改变两两节点指向,头插法,尾插法等基本操作。直接上代码。代码中有详细的注解

    #include <stdio.h>
    #include<stdlib.h>
    #if 0
    头插法
    1.让新来的节点,有所指向,新来的节点不会打断原有的指向关系
    尾插法
    
    
    #endif
    
    
    #if 0
    void test()
    {
        Node a,b,c,d;
        a.data=1;
        b.data=2;
        c.data=3;
        d.data=4;
        Node *head=&a;
        a.next=&b;
        b.next=&c;
        c.next=&d;
        d.next=NULL;
        Node *p =head;
        while (p) {
            printf("%d\n",p->data);
            p=p->next;
    
        }
        Node *p1=head;
        Node *p2 =p1->next;
        Node *p3;
        while (p2) {
        p3=p2->next;
        p2->next=p1;
        p1=p2;
        p2=p3;
        }
        head->next=NULL;
        while (p1) {
            printf("%d\n",p1->data);
            p1=p1->next;
    
        }
    
    }
    #endif
    typedef struct Link
    {
        int data;
        struct Node * next;
    }Node;
    //创建一个空链表
    Node * createLink()
    {
       Node *head = (Node*)malloc(sizeof(Node));
       head->next=NULL;
       return head;
    }
    //头插法创建链表
    Node * addHeadLink(Node*head)
    {
        for (int i=0;i<10;i++)
        {
            Node *cur=(Node*)malloc(sizeof(Node));
            cur->data=rand()%100;
            cur->next=head->next;
            head->next=cur;
        }
        return head;
    
    
    }
    //判断一个链表的长度
    int lenLink(Node *head)
    {
        int len = 0;
        Node *p=head->next;
    
        while (p) {
            len+=1;
            p=p->next;
    
        }
        return len ;
    }
    //尾插法添加链表元素
    Node * addEndLink(Node*head)
    {
        Node *p = head;
        for(int i=0;i<10;i++)
        {
            Node *cur =(Node*)malloc(sizeof(Node));
            cur->data=rand()%80;
            cur->next=NULL;
            p->next=cur;
            p=p->next;
    
        }
        return head;
    }
    //指定位置插入链表元素
    Node * addLink(Node*head,int n,int m)
    {
        Node *cur =head;
        int num=0;
        while(num!=n-1)
        {
            cur=cur->next;
            num++;
        }
        Node *q=(Node*)malloc(sizeof(Node));
        q->data=m;
        q->next=cur->next;
        cur->next=q;
        return head;
    }
    //排序该表值法
    void sortPopLink(Node *head,int len)
    {
        for(int i=0; i<len-1; i++)
        {
            Node * r = head->next;
            for (int j=0;j<len-1-i;j++)
            {
                Node * p=r->next;
                if(r->data>p->data)
                {
                    r->data=r->data^p->data;
                    p->data=r->data^p->data;
                    r->data=r->data^p->data;
                }
                r=r->next;
            }
    
        }
    
    }
    //排序改变地址法
    void sortPopAdressLink(Node*head,int len)
    {
        for (int i=0;i<len-1;i++)
        {
            Node *cur =head;
            Node *p = cur->next;
            Node *q =p->next;
            for (int j=0;j<len-1-i;j++)
            {
                if(p->data>q->data)
                {
                  cur->next=p->next;
                  p->next=q->next;
                  q->next=p;
                  Node *temp =p;//改变P和q的次序非常重要。第一次改变之后为cur->q->p;所以需要改变次序
                  p=q;
                  q=temp;
    
                }
                cur=cur->next;
                p=p->next;
                q=q->next;
    
            }
        }
    }
    //倒序eg 5->4->3->2->1->NULL  NULL->1->2->3->4->5
    Node * inverseLink(Node *head)
    {
        Node *p = head->next,*q;//先定义一个指针q存储
        head->next = NULL;//打断整个链表。创建一个空链表
        while(p != NULL)
        {
            q = p->next;//q先记录p的下一个节点
            p->next = head->next;//头插法(先来的节点有所指向,指向head->next)
            head->next = p;      //头部节点指向新来的节点
            p = q;               //节点向后移位
        }
        return head;
    }
    //两两交换eg 5->4->3->2->1->NULL  4->5->2->3->1->NULL
    Node *changeTwoLink(Node*head)
    {
        Node *cur = head;
        Node *m=cur->next;
    
        while (((cur!=NULL)&&(cur->next!=NULL))&&(m->next!=NULL))
         {
             Node* node1 = cur->next;  //指针移动
             Node* node2 = node1->next;
             Node* rear = node2->next;
    
             cur->next = node2;       //指针交换
             node2->next = node1;
             node1->next = rear;
             cur = node1;
             m=cur->next;
            }
        return head;
    }
    //查找指定元素的地址
    char * findLink(Node*head,int data)
    {
        Node *p=head->next;
        while (p)
        {
            if(p->data==data)
            {
                break;
            }
            p=p->next;
        }
        return p;
    }
    //删除指定元素
    void deleteLink(Node*head,int n)
    {
        Node*p=head->next;
        int m=1;
        while (m!=n-1) {
            p=p->next;
            m++;
        }
        Node *q=p->next;
        p->next=q->next;
        free(q);
    }
    //把所有的链表元素输出
    void printLink(Node*head)
    {
        Node *p=head->next;
        while (p) {
            printf("%d\n",p->data);
            p=p->next;
        }
    }
    //释放链表
    void releaseLink(Node *head)
    {
        Node * p;
        while(head)
        {
            p = head->next;
            free(head);
            head = p;
        }
        printf("the link have been released!\n");
    }
    
    int main()
    {
        Node *head = createLink();
        head = addEndLink(head);
        printLink(head);
        int len =lenLink(head);
    
        printf("the length of link is %d\n",len);
        sortPopAdressLink(head,len);
        printf("after pop sort\n");
        printLink(head);
        addLink(head,2,10);
        printf("====================\n");
        printLink(head);
        printf("=========inverse========\n");
        inverseLink(head);
        printLink(head);
        printf("=========change========\n");
        changeTwoLink(head);
        printLink(head);
        printf("adress = %p\n",findLink(head,78));
        deleteLink(head,3);
        printf("===============after delete======\n");
        printLink(head);
        releaseLink(head);
        return 0;
    }
    
    

    链表操作的几个小结

    1.采用头插法构建链表记住:让新来的节点有所指向,头节点下一个节点指向新来的节点。即cur->next = head->next;head->next = cur;
    2.链表反转的核心思想:先把头节点打断,让头节点指向NULL,然后用头插法的原则将元素一个个往头部插入,如此一来第一个节点就到最后的节点,即让链表反转。
    3.mallco从堆上申请空间后一定记住释放,遵守先申请后释放,后申请先释放的原则,类似栈原理。

    展开全文
  • 去面试被问到一个问题...方法一:将链表数据全部读到数组中,然后在倒序输出。 方法二:就是我下面要讲的。 方法三:从第二个结点开始,把之后的每个结点都插入到第一个结点之后,最后在把第一个结点挪到表尾。 ...

    去面试被问到一个问题,怎么把一个链表反转(用原链表),自己在网上找了到了一篇文章,http://blog.csdn.net/sicofield/article/details/8850269,原作者给出了三种方法,

    方法一:将链表数据全部读到数组中,然后在倒序输出。

    方法二:就是我下面要讲的。

    方法三:从第二个结点开始,把之后的每个结点都插入到第一个结点之后,最后在把第一个结点挪到表尾。

    第二种方法的思路是:从第二个结点开始,记录它的下个结点,把它挪到第一个结点之前,成为新表头,然后下个结点继续这个过程。

     1 struct stu *reserve(struct stu *head)
     2 {
     3         struct stu *p1,*p2,*p3;        
     4         p1=head;
     5         p2=p1->next;            // 这个结点为要移动的结点
     6         while(p2)
     7         {
     8                 p3=p2->next;       //记录的为要移动的结点的下一个结点
     9                 p2->next=p1;       //移动结点到最前
    10                 p1=p2;          //移动的结点变为新表头
    11                 p2=p3;          //下个结点变为要移动的结点
    12         }
    13         head->next=NULL;        //移动完毕后head变为表尾,让它指向为空
    14         head=p1;              
    15         return head;
    16 }

     

    方法三的贴下原作者的代码加上自己的思路:

     1 struct stu *reserve(struct stu *head)
     2 {
     3         struct stu *p,*q;
     4         p=head->next;                           //记录第二个结点   
     5         while(p->next!=NULL)
     6         {
     7                 q=p->next;                      //记录要移动的结点
     8                 p->next=q->next;                //把该结点从原链表中移除
     9                 q->next=head->next;             //把该结点连接到head之后
    10                 head->next=q;
    11         }
    12         p->next=head;                           //把head移动到新表尾,此时链表成环
    13         head=p->next->next;                     //找到移动完之后的新head
    14         p->next->next=NULL;                     //断开环
    15         return head;
    16 
    17 }



     

    转载于:https://www.cnblogs.com/kingos/p/4498224.html

    展开全文
  • 代码如下: ...*功能:随机数插入链表,实现单条链表排序和倒序 *作者:lml 时间:2020年4月15日20:25:40 ****************************************************/ #include <stdio.h> #inc...
  • 链表倒序函数设计

    2014-11-20 01:17:33
    今天下午去一家公司去面试,他们面试题中设计出了我从没涉及的C语言链表的问题,我想了很久脑子有了概念,却没有计算机、 没有办法进行实践操作,无奈写了一黑板的辅助图,最终还是放弃了。原因是:这是一家中介...
  • printf("倒序的结果是:"); for(i=0;head!=NULL;i++) { printf("%d ",head->num); head=head->next; } printf("\n"); } 转载于:https://www.cnblogs.com/shaoshao/archive/2013/01/07/2849719.html
  • C语言 -- 链表操作

    2014-07-04 12:28:00
    C语言单链倒序遍历递归方法和非递归方法 一 递归方法 struct list { void *data; int len; struct list *next; }; void reverse_deal_list(struct list *lst) { if(lst->next == NULL) { .....
  • C语言链表反转

    2015-07-09 09:51:00
    倒序思路:依次把后面的节点移往头部。struct Node{ struct Node* next; int data; }; typedef struct Node NODE; NODE* invert_link_list2(NODE* head) { if(head == 0){ return 0; } ...
  • 构建单链表(头部插入法) 头部插入法,就是每个新结点插入链表的头部,因此跟你输入的顺序相反。这两个函数分别是头部插入和尾部插入,你可以把主函数里的调用改为尾部插入法。
  • C语言实现文件按行倒序存储

    千次阅读 2014-03-25 15:17:28
    从A文件读取文本存储到B文件里,但是B文件里的文本顺序要和A文件里的顺序...采用了双向链表实现这一功能,C语言的实现代码如下: #include #include int main() { FILE *file_in,*file_out; struct st{ char c
  • 本篇是第5题_从尾到头打印...解法1:链表倒序的数组实现 #include<stdio.h> #include<stdlib.h> #define N 1000 typedef struct node // 复习typedef的基础知识!!!!!!! { int data; struct ...
  • 将线性列表倒序 */ list *over(list *H){ printf("\n\n over list \n "); list *r,*q,*p; r = H; p = r->next; q = p->next; if(NULL==p){ printf("\n list is null !\n"); return NULL; } while((NULL!...
  • C语言的一点复习

    2019-09-27 12:32:33
    都忘光了,拿来复习一小下 运行环境Win7 VS2010 ...就是实现一个方法,将链表倒序。 #include "stdafx.h" #include<iostream> typedef struct tagListNode{ int value; struct tagLi...
  • C语言反转字符串

    2021-02-23 08:45:14
    C语言反转字符串 最近看了好多开发中的奇技淫巧,于是有了这样的思路 反转字符串虽然简单但应用范围却很广,一般的套路是先用字符串数组读入字符串,然后循环并倒序输出每一位字符。 我又想到了在做链表反转时用到的...
  • 单链表倒序.txt 单链表的处理全集.txt 双链表正排序.txt 反出字符.txt 叠代整除.txt 各种排序法.txt 哈夫曼算法.txt
  • 链表实现两数相加,简单的是这道题的数字使倒序给我们的,所以直接从第一结点开始相加,若大于10则进位即可,我想的是只要到达的两个链表的结点都不为空,则相加取余存在新的结点中,加在新链表上,用sum储存取整...
  • 16进制10进制.txt 32.txt asm.txt ... 单链表倒序.txt 单链表的处理全集.txt 双链表正排序.txt 反出字符.txt 叠代整除.txt 各种排序法.txt 哈夫曼算法.txt 哈慢树.txt 四分砝码.txt 四塔1.txt

空空如也

空空如也

1 2 3
收藏数 44
精华内容 17
关键字:

c语言链表倒序

c语言 订阅