C语言经典例73-反向输出一个链表

女爷i 2023-07-06 11:40 91阅读 0赞

目录

  • 1 题目
  • 2 分析
    • 2.1 方法1-原地逆置
    • 2.2 方法2-递归
  • 3 实现
    • 3.1 实现1-原地逆置
    • 3.2 实现2-递归
  • 4 运行结果

1 题目

反向输出一个链表，链表结构为：

  1. typedef int ElementType;
  2. typedef struct node { 
  3.     ElementType data;
  4.     struct node *Next;
  5. } *List;

2 分析

2.1 方法1-原地逆置

原地逆置链表的思路是将原链表的头节点和其余节点分成两个部分，然后将其余节点逐个取下节点进行头插法插入到原链表的头结点前面，这样就实现了链表原地逆置，且空间复杂度为 O ( 1 ) O(1) O(1)。

  1. List reverse(List L)
  2. { 
  3.     List prep;
  4.     List p;
  5.     List q;
  6.     p = L->Next;
  7.     q = p->Next;
  8.     p->Next = NULL;
  9.     while (q) { 
  10.         prep = p;
  11.         p = q;
  12.         q= q->Next;
  13.         p->Next = prep;
  14.     }
  15.     L->Next = p;
  16.     return L;
  17. }

2.2 方法2-递归

上面的一种情况是强制改变链表原有顺序，那么也可以不改变链表的顺序，只逆序输出，那么可以使用递归，采用栈的思想，当链表的下一节点不为空NULL时进行递归，当链表的下一节点为NULL时返回递归输出节点数据，如下：

  1. void reverse_2(List L) { 
  2.     if (L->Next != NULL) { 
  3.         reverse_2(L->Next);
  4.     }
  5.     printf("%d ", L->data);
  6. }

调用方法为：

  1. reverse_2(L->Next);

3 实现

3.1 实现1-原地逆置

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  5. typedef int ElementType;
  6. typedef struct node { 
  7.     ElementType data;
  8.     struct node *Next;
  9. } *List;
  11. // 创建链表
  12. List CreateList(void) { 
  13.     List L = (List)malloc(sizeof(struct node));
  14.     L->data = 0;
  15.     L->Next = NULL;
  16.     return L;
  17. }
  19. // 初始化链表节点数据
  20. void InitList(List L) { 
  21.     srand((unsigned)time(NULL)); // 随机数种子
  22.     for (int i = 0; i < 10; i++) { 
  23.         List p = (List)malloc(sizeof(struct node));
  24.         p->data = rand() % 100; // 节点数据采用随机数，随机数范围为0~99
  25.         p->Next = L->Next;
  26.         L->Next = p;
  27.     }
  28. }
  30. // 打印链表
  31. void PrtList(List L) { 
  32.     List p = L->Next;
  33.     while (p) { 
  34.         printf("%d ", p->data);
  35.         p = p->Next;
  36.     }
  37.     printf("\n");
  38. }
  40. // 逆置链表 
  41. List reverse(List L)
  42. { 
  43.     List prep;
  44.     List p;
  45.     List q;
  46.     p = L->Next;
  47.     q = p->Next;
  48.     p->Next = NULL;
  49.     while (q) { 
  50.         prep = p;
  51.         p = q;
  52.         q= q->Next;
  53.         p->Next = prep;
  54.     }
  55.     L->Next = p;
  56.     return L;
  57. }
  59. int main(void) { 
  60.     List L = CreateList(); // 创建链表
  61.     InitList(L); // 初始化链表数据
  62.     printf("原链表为：");
  63.     PrtList(L);
  64.     reverse(L); // 逆置链表
  65.     printf("逆置后为：");
  66.     PrtList(L);
  67.     return 0;
  68. }

3.2 实现2-递归

见2.2 方法2-递归中的程序段。

4 运行结果

  1. 原链表为：50 6 12 12 55 60 57 47 85 29
  2. 逆置后为：29 85 47 57 60 55 12 12 6 50

发表评论

表情：
评论列表 （有 0 条评论，91人围观）

还没有评论，来说两句吧...

相关阅读