6-1 单链表逆转 (20分)

题目链接:6-1 单链表逆转 (20分)

方式一:递归逆置单链表

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <math.h>
 4 #include <string.h>
 5 #include <ctype.h>
 6
 7 #define maxn 5000
 8 #define newline printf("\n")
 9
10
11 typedef int ElemType;
12 typedef struct Node *PtrToNode;
13
14 struct Node{
15     ElemType Data;
16     PtrToNode Next;
17 };
18
19 typedef PtrToNode List;    //定义单链表类型
20
21
22 List Read();
23 void Print(List L);
24
25 List Reverse(List L);
26
27
28 int main(){
29
30     List L1,L2;
31     L1 = Read();
32     L2 = Reverse(L1);
33     Print(L1);
34     Print(L2);
35     return 0;
36 }
37
38
39 List Read(){
40
41     int n;
42     scanf("%d",&n);
43     int i,temp;
44     List newNode = NULL;
45     List L = (List)malloc(sizeof(struct Node));    //投结点
46     List p = L;
47     if(L!=NULL){
48         for(i=0;i<n;i++){
49             scanf("%d",&temp);
50             newNode = (List)malloc(sizeof(struct Node));
51             newNode->Data = temp;
52             p->Next = newNode;
53             p = p->Next;
54         }
55         p->Next = NULL;
56     }
57     return L->Next;    //根据题意推测返回的是不带头结点的单链表
58
59 }
60
61
62 void Print(List L){
63     List p = L;
64     while(p){
65         printf("%d",p->Data);
66         p = p->Next;
67         if(p!=NULL){
68             printf(" ");
69         }else{
70             printf("\n");
71         }
72     }
73
74 }
75
76
77 List Reverse(List L){
78
79     if(L == NULL||L->Next == NULL){
80         return L;
81     }
82     List head = Reverse(L->Next);
83     L->Next->Next = L;        //原来的最后一个结点拼接到新链表的最后一个结点后
84     L->Next = NULL;
85
86     return head;
87 }

方式二:头插法

 1 List Reverse(List L){
 2
 3     if(L == NULL||L->Next == NULL){
 4         return L;
 5     }
 6     List p = L->Next;
 7     L->Next = NULL;
 8     List head = L;
 9     List q = NULL;
10
11     while(p){//考察待插入结点p
12         q=p->Next;    //记录下一个待插入结点
13         p->Next = head;    //连接新链表的首元结点
14         head = p;    //成为新链表的新的首元结点
15         p = q;    //新的待插入结点
16     }
17     return head;
18 }

原文地址:https://www.cnblogs.com/ManOK/p/12585365.html

时间: 2024-07-29 00:45:33

6-1 单链表逆转 (20分)的相关文章

PTA——6-1 单链表逆转 (20分)

题目地址 本题要求实现一个函数,将给定的单链表逆转. 函数接口定义: List Reverse( List L ); 其中List结构定义如下: typedef struct Node *PtrToNode; struct Node { ElementType Data; /* 存储结点数据 */ PtrToNode Next; /* 指向下一个结点的指针 */ }; typedef PtrToNode List; /* 定义单链表类型 */ L是给定单链表,函数Reverse要返回被逆转后的链

6-1 单链表逆转(20 分)

6-1 单链表逆转(20 分) 本题要求实现一个函数,将给定的单链表逆转. 函数接口定义: List Reverse( List L ); 其中List结构定义如下: typedef struct Node *PtrToNode; struct Node { ElementType Data; /* 存储结点数据 */ PtrToNode Next; /* 指向下一个结点的指针 */ }; typedef PtrToNode List; /* 定义单链表类型 */ L是给定单链表,函数Rever

6-1 单链表逆转

本题要求实现一个函数,将给定的单链表逆转. 函数接口定义: List Reverse( List L ); 其中List结构定义如下: typedef struct Node *PtrToNode; struct Node { ElementType Data; /* 存储结点数据 */ PtrToNode Next; /* 指向下一个结点的指针 */ }; typedef PtrToNode List; /* 定义单链表类型 */ L是给定单链表,函数Reverse要返回被逆转后的链表. 裁判

单链表逆转问题

实现对含有n个元素的单链表的逆转,要求运行时间O(n),除了链表本身所需空间外,只使用固定大小的存储空间.(此题来自<算法导论>10.2-7) 从头元素开始循环,将原本指向其后继节点的指针指向其前驱节点,直到循环至哨兵为止.整个过程额外需要三个指针变量的空间,分别保存当前节点及其前驱.后继. 下面是一个简单的C++实现. struct Node { Node* pNext; int key; }; class SingleLinkedList { public: SingleLinkedLis

单链表逆转

参照:http://www.cnblogs.com/bluestorm/p/3167424.html #include <stdio.h> #include <stdlib.h> struct list{ char data; struct list *next; }node; struct list* input() { //p作为新结点,q不断连接新结点,h作为首结点返回 struct list *p,*q,*h = NULL; while(1) { //新创建一个结点 p =

【算法设计-单链表的逆转】单链表逆转实现

1.在Θ(n)时间内将链表转置,而且只能需要少量的额外空间 这里需要用3个指针使得q指向p然后依次后移. 代码: #include<iostream> using namespace std; typedef struct Node { int data; struct Node *next; }LinkList; LinkList* Create_End(); void printLinkList(LinkList *L); LinkList* Create_End() { LinkList

[PTA] 数据结构与算法题目集 6-1 单链表逆转

List Reverse(List L) { List p, q; p = L; q = L; L = NULL; while (p) { p = p->Next; q->Next = L; L = q; q = p; } return L; } 原文地址:https://www.cnblogs.com/ruoh3kou/p/9975225.html

实验11-2-5-链表 链表拼接 (20 分)

懒得放题目了,直接上答案,太难做了 struct ListNode* mergelists(struct ListNode* list1, struct ListNode* list2) { struct ListNode* head, * tmp, * t; head = (struct ListNode)malloc(sizeof(struct ListNode)); head->next = list1; tmp = head; if (list1 == NULL && lis

pta-数据结构与算法题目集(中文)-4-1-单链表逆转

4-1 单链表逆转   (20分) 本题要求实现一个函数,将给定的单链表逆转. 函数接口定义: List Reverse( List L ); 其中List结构定义如下: typedef struct Node *PtrToNode; struct Node { ElementType Data; /* 存储结点数据 */ PtrToNode Next; /* 指向下一个结点的指针 */ }; typedef PtrToNode List; /* 定义单链表类型 */ L是给定单链表,函数Rev