C语言实现链表的逆序的几种方式

最新推荐文章于 2023-07-15 16:51:20 发布
最新推荐文章于 2023-07-15 16:51:20 发布
阅读量1w 收藏 109
点赞数 25
分类专栏： C语言学习 文章标签： 指针 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46544385/article/details/113821728
版权

文章目录

通过头插法实现的

1、通过头插法（两条链表）来实现的。通过遍历原来的链表，将遍历得到的每一个节点都插入到新链表的头结点，然后遍历新链表，得到的就是链表的逆序了。
实现链表逆序的代码：
过程分析：
在这里插入图片描述
看到上面的过程，有些伙伴可能会疑问，为什么每一次遍历的时候，都需要给Node重新分配空间呢？再进行循环之前，给Node分配一次空间不就好了？一开始我也是这样想的，但是运行的结果却是只有一个值，并且陷入了死循环.
在这里插入图片描述
请看下面的过程分析：
在这里插入图片描述

//将节点插入到头结点，从而实现逆序
Node * insertTop(Node *head,Node *root){
   Node *temp,*node;//node表示新节点
   temp = head;
   //将遍历得到的节点插入到root链表的头结点，从而实现逆序
   while(temp != NULL){
        /*
        给新结点分配空间,这一步十分重要的，如果没有重新给node分配空间，那么根据下面的代码，
        得到的就是root==node，即root和Node都指向同一个地址，进行后面的操作时就会形成一个环
        */
      node = (Node *)malloc(sizeof(Node));
      node->number = temp->number;
      node -> next = NULL;
      /*
      if(root == NULL){
        //如果是空链表，那么新节点就是头结点
        root = node;
        printf("由于链表是空的，那么新节点就是头结点\n");
      }else{
          //如果不是空链表，那么原来的头结点就在新节点的后面,新节点就是头结点
        node->next = root;
        root = node;
        Node *t = root->next;
        printf("新头结点的值为%d,原来头结点的值为%d\n",root->number,t->number);
      }
      */
      /*
      上面的代码可以用下面两行代码代替，因为只需要将当前这个新节点作为头结点，这个新节点后面时原
      来头结点的下一个节点即可，而不用再判断root是否为空了
      */
      node->next = root;
      root = node;
      temp = temp->next;
   }
   return root;
}

完整代码：

#include<stdio.h>
#include<stdlib.h>
typedef struct NODE{
  int number;
  struct NODE *next;
}Node;
Node * insert(int number, Node *root);//函数声明，使得这个函数可以定义在main函数的后面
void display(Node *root);
Node * insertTop(Node *head,Node *root);
int main(){
  Node *a,*b;//a表示原来的链表，b表示逆序的链表
  a = b = NULL;//初始化链表(空表)
  //创建链表
  int i,number;
  for(i = 0; i < 5; i++){
    printf("输入第 %d 个节点的值:",i + 1);
    scanf("%d",&number);
    a = insert(number,a);//将新节点插入到链表最后
  }
  display(a);
  b = insertTop(a,b);
  printf("链表a的逆序链表:\n");
  display(b);
  return 0;
}

//将新节点插入在链表的最后
Node * insert(int number,Node *root){
  Node *current,*node;//node表示新节点
  node = (Node *)malloc(sizeof(Node));//给新结点分配空间
  node->number = number;
  node->next = NULL;
  current = root;
  if(current == NULL){
    //如果是空表，那么新节点就是根节点
    root = node;
  }else{
    //否则，将遍历到链表的最后，将新节点插入在链表尾
    while(current -> next != NULL){
        //如果不是最后一个节点，继续遍历
        current = current -> next;
    }
    current -> next = node;
  }
  return root;
}
//将节点插入到头结点，从而实现逆序
Node * insertTop(Node *head,Node *root){
   Node *temp,*node;//node表示新节点
   temp = head;
   //将遍历得到的节点插入到root链表的头结点，从而实现逆序
   while(temp != NULL){
        //给新结点分配空间,这一步十分重要的，如果没有重新给node分配空间，那么根据下面的代码，得到的就是root==node
      node = (Node *)malloc(sizeof(Node));
      node->number = temp->number;
      node -> next = NULL;
      /*
     if(root == NULL){
        //如果是空链表，那么新节点就是头结点
        root = node;
        printf("由于链表是空的，那么新节点就是头结点\n");
      }else{
          //如果不是空链表，那么原来的头结点就在新节点的后面,新节点就是头结点
        node->next = root;
        root = node;
        Node *t = root->next;
        printf("新头结点的值为%d,原来头结点的值为%d\n",root->number,t->number);
      }
      */
      node -> next = root;
      root = node;//这两行代码可以代替上面的代码，不需要判断链表是否为空，因为只要将新节点成为头结点，并且这个新节点接在原来头结点的前面就好了
      temp = temp->next;
   }
   return root;
}
//遍历链表
void display(Node *root){
  Node *current;
  current = root;
  while(current != NULL){
    if(current -> next == NULL){
        //如果是最后一个节点，那么就直接输出他的值，然后换行
        printf("%d\n",current->number);
    }else{
        printf("%d ->",current->number);
    }
    current = current->next;//后移
  }
}

运行结果：
在这里插入图片描述

通过双指针实现链表的逆序

过程分析:
在这里插入图片描述
完整代码:

#include<stdio.h>
#include<stdlib.h> //引入声明，从而可以使用malloc函数
typedef struct NODE{
    int number;
    struct NODE *next;
}Node;
Node * insert(int number,Node *root);//函数声明
Node * reverse3(Node *a);
void display(Node *root);
int main(){
  Node *a,*b;
  int i,number;
  a = b = NULL;//空链表
  for(i = 0; i < 5; i++){
      printf("输入第 %d 个节点:",i + 1);
      scanf("%d",&number);
      a = insert(number,a);
  }
  printf("链表a:");
  display(a);
  printf("链表a的逆序:");
  b = reverse3(a);
  display(b);
  return 0;
}
/*
通过双指针实现链表的逆序
*/
Node * reverse3(Node *a){
   Node *cur = a,*pre = NULL,*t;
   while(cur != NULL){
      t = cur->next;//新建一个临时节点，从而使得这个临时节点是pre的下一个节点
      cur->next = pre;//将当前的节点的下一个节点是前一个节点,从而实现了链表的逆序
      pre = cur;
      cur = t;//将临时变量赋值给当前这个节点cur，从而实现节点的后移
   }
   return pre;

}
//将节点插入到链表尾，从而创建链表
Node * insert(int number,Node *root){
   Node *current,*node;
   //给新结点分配空间
   node = (Node *)malloc(sizeof(Node));
   node->number = number;
   node->next = NULL;
   current = root;
   if(current == NULL){
    //如果空链表，新节点就是头结点
    root = node;
   }else{
     while(current->next != NULL){
        //不是最后一个节点，就继续遍历
        current = current->next;
     }
     current->next = node;
   }
   return root;
}

//遍历链表
void display(Node *root){
  Node *current;
  current = root;
  if(current == NULL){
    printf("链表为空，无法遍历");
    return;
  }
  while(current != NULL){
    if(current->next == NULL){
        //如果是最后一个节点，那么将它的值输出并换行
        printf("%d\n",current->number);
    }else{
        printf("%d ->",current->number);
    }
    count++;
    current = current->next;//后移
  }
}

运行结果:
在这里插入图片描述

通过栈来实现的

2、通过栈来实现的，利用栈先进后出的特性，从而实现链表的逆序，这里通过数组来实现栈的压栈和出栈的相关操作。
下面是完整代码:

/*
通过栈先进后出的特点，从而实现链表的逆序
实现链表的方式有两种方式，通过数组和链表
1）通过链表的时候，只需要将新节点插入到头结点，从而实现了先进后出（上面就相当于通过
链表实现栈，从而实现逆序）
2）通过数组来实现栈的相关操作，从而实现链表的逆序
*/
#include<stdio.h>
#include<stdlib.h> //引入声明，从而可以使用malloc函数
typedef struct NODE{
    int number;
    struct NODE *next;
}Node;
Node * insert(int number,Node *root);//函数声明
Node * reverse(Node *a,Node *b);
void display(Node *root);
int count = 0; //定义一个全局变量，从而可以得到链表的节点个数
int main(){
  Node *a,*b;
  int i,number;
  a = b = NULL;//空链表
  for(i = 0; i < 5; i++){
      printf("输入第 %d 个节点:",i + 1);
      scanf("%d",&number);
      a = insert(number,a);
  }
  printf("链表a:");
  display(a);
  printf("链表a的逆序:");
  b = reverse(a,b);
  display(b);
  return 0;
}
//获取逆序的链表
Node * reverse(Node *a,Node *b){
   if(count == 0){
        printf("链表为空");
        return NULL;
   }
   Node *arr[count];//定义一个长度为count的节点数组
   int top = -1,i;//栈顶指针
   Node *current = a;
   /*
   遍历链表,将遍历得到的节点放到节点数组中，此时从下标为0开始遍历数组，
   得到的是顺序链表
   */
   while(current != NULL){
    /*
     arr[++top] = (Node *)malloc(sizeof(Node));//给新结点分配空间
     arr[++top]->number = current->number;
     arr[++top]->next = NULL;
     注意不可以这样写的，因为本来是想给arr[top]这个节点赋值的，如果是上面那样的话，那么就和本来的
     要求相反了，并且还有可能会出现错误，因为没有给节点分配空间
    */
     top++;
     arr[top] = (Node *)malloc(sizeof(Node));//给新结点分配空间
     arr[top]->number = current->number;
     arr[top]->next = NULL;
     current = current->next;
   }
   /*
   出栈,由于是从数组的最后开始遍历，所以遍历得到的是链表的逆序，然后只
   需要将遍历的节点插入到新链表的尾节点即可
   */
   while(top >= 0){
    b = insert(arr[top--]->number,b);
   }
   return b;
}
//将节点插入到链表尾，从而创建链表
Node * insert(int number,Node *root){
   Node *current,*node;
   //给新结点分配空间
   node = (Node *)malloc(sizeof(Node));
   node->number = number;
   node->next = NULL;
   current = root;
   if(current == NULL){
    //如果空链表，新节点就是头结点
    root = node;
   }else{
     while(current->next != NULL){
        //不是最后一个节点，就继续遍历
        current = current->next;
     }
     current->next = node;
   }
   return root;
}

//遍历链表
void display(Node *root){
  Node *current;
  current = root;
  if(current == NULL){
    printf("链表为空，无法遍历");
    return;
  }
  while(current != NULL){
    if(current->next == NULL){
        //如果是最后一个节点，那么将它的值输出并换行
        printf("%d\n",current->number);
    }else{
        printf("%d ->",current->number);
    }
    count++;
    current = current->next;//后移
  }
}

在这里插入图片描述

通过递归来实现

请看过程分析（这是基于java来分析的，如果是C语言的话，那么应该是head->next,head->next->next，而不是head.next,head.next.next(java的))：
在这里插入图片描述
完整代码：

#include<stdio.h>
#include<stdlib.h> //引入声明，从而可以使用malloc函数
typedef struct NODE{
    int number;
    struct NODE *next;
}Node;
Node * insert(int number,Node *root);//函数声明
Node * reverse2(Node *a);
int main(){
  Node *a,*b;
  int i,number;
  a = b = NULL;//空链表
  for(i = 0; i < 5; i++){
      printf("输入第 %d 个节点:",i + 1);
      scanf("%d",&number);
      a = insert(number,a);
  }
  printf("链表a:");
  display(a);
  printf("链表a的逆序:");
  b = reverse2(a);
  display(b);
  return 0;
}
/*
通过递归来实现链表的逆序
*/
Node * reverse2(Node *head){
    if(head == NULL || head->next == NULL)
        return head;//如果当前节点是NULL，表示是空链表，或者当前的节点是最后一个节点，那么直接返回这个节点
    Node *newHead = reverse2(head->next);//进入递归
    head->next->next = head;
    head->next = NULL;//这一步避免了链表存在环
    return newHead;
}
//将节点插入到链表尾，从而创建链表
Node * insert(int number,Node *root){
   Node *current,*node;
   //给新结点分配空间
   node = (Node *)malloc(sizeof(Node));
   node->number = number;
   node->next = NULL;
   current = root;
   if(current == NULL){
    //如果空链表，新节点就是头结点
    root = node;
   }else{
     while(current->next != NULL){
        //不是最后一个节点，就继续遍历
        current = current->next;
     }
     current->next = node;
   }
   return root;
}

//遍历链表
void display(Node *root){
  Node *current;
  current = root;
  if(current == NULL){
    printf("链表为空，无法遍历");
    return;
  }
  while(current != NULL){
    if(current->next == NULL){
        //如果是最后一个节点，那么将它的值输出并换行
        printf("%d\n",current->number);
    }else{
        printf("%d ->",current->number);
    }
    count++;
    current = current->next;//后移
  }
}

运行结果:
在这里插入图片描述

奋斗的龙猫
关注
  • 25
    点赞
  • 踩
  • 109
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现单链表逆序与逆序输出实例
win_turn的博客
02-19 2万+
这篇文章主要介绍了C语言实现单链表逆序与逆序输出,是数据结构与算法中比较基础的重要内容,有必要加以牢固掌握,需要的朋友可以参考下 单链表的逆序输出分为两种情况，一种是只逆序输出，实际上不逆序；另一种是把链表逆序。本文就分别实例讲述一下两种方法。具体如下：1.逆序输出#include<iostream> #include<stack> #include<assert.h> using namespac
链表逆序
fangyang_000的博客
11-22 2150
链表逆序的思想： 1）遍历链表中的节点，放入栈中，然后进行出栈的操作，即可得到逆序的链表； 2）思想和1）相同，将链表中的元素，存入数组或者队列或者有序集合中，然后逆序去除元素，重新链接成链表； 3）通过交换链表中的元素，从而实现逆序。可以这么理解，顺序取出链表中的根元素，放入新的链表中。 代码如下： step1，构建节点 class Note { p...
链表数据反转、链表逆序输出-C语言实现
Mr.W的博客
01-25 3670
链表逆序输出元素，采用单、双向链表实现  逆序输出方法又好几种，个人认为，在不开辟其他空间的条件下，实现的原理都是差不多的（使用链表的情况），其根本就是改变链表头，下面的代码在不开辟其他空间的条件实现，另外，编写程序时，特别注意特殊情况下是否能正常运行（其实完全用不到双向链表） 双向链表（没有头节点） ​ #include &lt;stdio.h&gt; #include &lt;stdl...
C语言实现--逆序创建链表（头插法）
m0_54158068的博客
03-30 1564
C语言实现--逆序创建链表（头插法）
单向链表基本操作的递归实现
08-10
这几天正在复习一些基本的算法和实现，今天看了看递归的基本原理，发现自己对递归还不是特别清楚，特别是不清楚递归的思想，不能很准确的把握先分解成小事件，在合并的思想，其实也是数学归纳法的程序体现，其实数学...
2022年C语言笔试面试题整理.doc
11-11
5. 写一种函数将一种链表逆序。一种单链表，不懂得长度，写一种函数迅速找到中间节点旳位置。写一种函数找出一种单向链表旳倒数第 n 个节点旳指针。 知识点：链表的操作、算法设计。 6. 用递归算法判断数组 a[N]...
C语言程序试题
03-25
2. 链表逆序排列：问题3要求将一个链表按逆序排列，即将链头当链尾，链尾当链头。这需要使用链表的数据结构和指针运算来实现。 3. C语言数据类型：问题1考察了C语言中的简单数据类型，包括整型、实型、逻辑型和字符...
计算机二级c语言公共基础知识.pdf
09-10
- **冒泡排序法**：一种简单的排序算法，通过不断交换相邻的逆序元素实现排序，时间复杂度为O(n^2)。 在准备考试时，考生应重点掌握算法的时间复杂度和空间复杂度的概念，理解数据结构的逻辑和物理结构，并熟悉...
C语言程序设计100个简单的经典例子.pdf
最新发布
09-22
43. 使用static得另一种用法：掌握如何使用static得另一种用法，了解基本的变量定义技术。 44. 使用external得用法：掌握如何使用external得用法，了解基本的变量定义技术。 45. 使用register定义变量方法：掌握...
C语言实现链表逆序
阿呆的隐秘角落
02-15 4921
        写在前面的是，对于C语言链表逆序的看法：第一感觉是，我擦，这玩意什么时候能用到啊。。。。。。。残念。。。不过在面试中是会经常用到的，如果有需要的小伙伴，可以看看我总结到的一些心得体会吧。        嗯，在做链表逆序的时候先做一个简单的链表出来：#include&lt;stdio.h&gt; #include&lt;malloc.h&gt;typedef int Item;//定...
单向链表逆序-C语言
qq_56564931的博客
07-15 410
链表逆序
C语言实现单链表的逆序
谋天下的博客
06-14 1583
问题描述:：实现单链表的逆序，如输入1 2 3 4 5 6，则输出6 5 4 3 2 1。 #include<stdio.h> #include<stdlib.h> void main(){ struct node { int data; struct node *next; }; struct node *p,*q,*k,*h,*l,*o,*z,*f,*g; int n,m,b=0; printf("请输入序列的长度:"); scanf("%d",&m); printf(
正序逆序生成单链表，正序逆序输出链表（递归法和顺序栈法）
yurhzzu的博客
06-30 4124
1.生成一个单链表 2.逆序输出结点的值（递归法和顺序栈法）
单链表逆序
Fire_Sky_Ho的博客
08-30 990
题目：给定一个带附加头节点的单链表，设first为其头指针，节点的结构为(data,link)，data为数据域，link为指针域，试写出算法：通过遍历一趟链表，将链表中所有节点逆序连接 　　分析：这是很经典的“单链表逆序”问题。很多公司的面试题库中都有这道题，有的公司明确题目要求不能开辟额外的节点空间（否则可以在遍历原链表的同时使用前插法建立一个逆序链表），有的没有明确说明，但是如果面试者
对一个单链表进行逆序排列。
热门推荐
追
12-06 1万+
算法:当建立好一个链表后，指针的方向是固定的，从某种意义上来说只能从head开始，每一个next都是指向下一个，即从左到右，如果要逆序排列，首先很容易想到要访问到尾节点，将其当做新的头结点，然后让它去指向倒数第二个倒数第三个等等。可问题来了，找到新的头结点到时很容易，那如果让它按照倒数第二个，倒数第三个......也就是从右至左的逆序访问呢？毕竟链表里没有哪个指针可以指向反方向的啊，研究了一下午的
c语言如何实现链表逆序输出
09-19
要实现链表逆序输出，可以使用递归或者迭代的方式。以下是分别使用这两种方法的示例代码。 递归方法： ```c #include struct Node { int data; struct Node* next; }; void reversePrint(struct Node* head) {...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值