反转链表(递归与非递归)

 1 #include<iostream>
 2 using namespace std;
 3
 4 typedef struct LNode{
 5     int data;
 6     LNode* next;
 7 }LNode;
 8 //非递归方法,
 9 LNode* reverse(LNode* head)
10 {
11     if(!head||!head->next)
12         return head;
13     LNode *pre,*cur,*next;
14     pre = head;
15     cur = head->next;
16     next = cur->next;
17     pre->next = NULL;
18     while(next!=NULL)
19     {
20         next = cur->next;
21         cur->next = pre;
22         pre = cur;
23         cur = next;
24     }
25     head = pre;
26     return head;
27 }
28 //递归反转链表
29 LNode* reverseRecursion(LNode* currnode)
30 {
31     if(!currnode->next||!currnode)
32     {
33         return currnode;
34
35     }
36     else{
37
38         LNode* temp = reverseRecursion(currnode->next);
39         LNode* nextnode = currnode->next;
40         nextnode->next = currnode;
41         currnode->next = NULL;
42         return temp;//返回当前节点
43     }
44
45 }
46 //创建链表
47 LNode* createList(int n)
48 {
49     LNode* head, *temp,*pre;
50     head = NULL;
51     head = new LNode;
52     head->data = n;
53     pre = head;
54     while(n--)
55     {
56         temp = new LNode;
57         temp->data = n;
58         pre->next = temp;
59         pre = temp;
60     }
61     pre->next = NULL;
62     return head;
63
64 }
65
66 int main(){
67     int n =6;
68     LNode * list1,*list2,*temp1,*temp2;
69     list1 = createList(n);//初始链表
70     temp1 = list1;
71     while(n--)
72     {
73         cout<<"init node data:"<<temp1->data<<endl;
74         temp1 = temp1->next;
75     }
76     cout<<"head node data:"<<list1->data<<endl;
77     //list2 = reverse(list1);
78     list2 = reverseRecursion(list1);
79     n = 6;
80     temp2 = list2;
81     while(n--)
82     {
83         cout<<"reverse node data:"<<temp2->data<<endl;
84         temp2 = temp2->next;
85     }
86     return 0;
87 }
时间: 2024-08-13 04:12:34

反转链表(递归与非递归)的相关文章

链表反转的递归和非递归实现方式

链表反转是数据结构的基本功,主要有递归和非递归两种实现方式.我们一一介绍如下: 1. 非递归实现 主要包括如下4步: 1)如果head为空,或者只有head这一个节点,return head即可: 2)从头到尾遍历链表,把reversedHead赋值给当前节点的next: 3)当前节点赋值给reversedHead: 4)遍历结束,return reversedHead. 下图试图来辅助说明: 代码如下: node* reverseList(node* head) { if(head == NU

单链表的合并(递归、非递归)

递归方法将两个链表合并成一个链表 例:已知两个单链表head1和head2各自有序升序排列,请把他们合并成一个连表并依然有序,并保留原来所有节点 假设以下两个链表: 链表1:1->3->5 链表2:2->4->6 (1)比较1和链表2的第一个节点数据,由于1<2,因此把结果链表头结点指向链表1中的第一个节点,即数据1所在的节点 (2)对剩余的链表1(3->5)和链表2在调用本过程,比较得到结果链表的第二个节点,即2与3比较得到2,此时合并后的链表节点为1->2,这

全排列(递归与非递归实现)

全排列问题在公司笔试的时候很常见,这里介绍其递归与非递归实现. 递归算法 1.算法简述 简单地说:就是第一个数分别以后面的数进行交换 E.g:E = (a , b , c),则 prem(E)= a.perm(b,c)+ b.perm(a,c)+ c.perm(a,b) 然后a.perm(b,c)= ab.perm(c)+ ac.perm(b)= abc + acb.依次递归进行. void swap(string &pszStr,int k,int m) { if(k==m) return ;

JumpNode递归和非递归访问

JumpNode的定义结构为如下所示: struct JumpNode { int data; //存储数据 int order; // 记录访问次序,初始化均为0 JumpNode *jump, *next; // next为线性下一节点,jump为跳跃到下一节点 JumpNode(int d): data(d), order(-1), jump(NULL), next(NULL) {} }; 现在需要以递归和非递归的方式来访问到一个JumpNode *list.在访问的时候给各个节点的ord

简单迷宫算法(递归与非递归C++实现)

假定迷宫如下:1代表墙,0代表道路,起点在(1,1),终点(11,9)(PS:下标从0开始计算). 现在寻求一条路径能从起点到达终点(非最短). 有两种解法:递归与非递归. 递归算法思路: 要用递归,就要寻找一个子问题,该子问题是递归的.很明显,这道题的子问题就是从8个方向(上下左右还有四个斜角)中寻找一个可行方向并向前走一步,该子问题(seekPath函数)的实现代码如下: 1 struct offset{ 2 int x; 3 int y; 4 }; 5 offset move[8]={{-

二叉树三种遍历递归及非递归实现(Java)

import java.util.Stack; //二叉树三种遍历递归及非递归实现(Java) public class Traverse { /******************定义二叉树**************************/ private final int MAX_SIZE = 10; //链式存储 public static class BinaryTreeNode { int mValue; BinaryTreeNode mLeft; BinaryTreeNode

数据结构——二叉树遍历之“递归与非递归遍历”

简述 二叉树的遍历分为先序遍历.中序遍历和后序遍历.如下图所示: 递归遍历 private void bianli1(List<Integer> list, TreeNode root) { // 先序遍历 if (root == null) { return; } list.add(root.val); bianli1(list, root.left); bianli1(list, root.right); } private void bianli2(List<Integer>

JAVA递归、非递归遍历二叉树(转)

原文链接: JAVA递归.非递归遍历二叉树 import java.util.Stack; import java.util.HashMap; public class BinTree { private char date; private BinTree lchild; private BinTree rchild; public BinTree(char c) { date = c; } // 先序遍历递归 public static void preOrder(BinTree t) {

Java数据结构系列之——树(4):二叉树的中序遍历的递归与非递归实现

package tree.binarytree; import java.util.Stack; /** * 二叉树的中序遍历:递归与非递归实现 * * @author wl * */ public class BiTreeInOrder { // 中序遍历的递归实现 public static void biTreeInOrderByRecursion(BiTreeNode root) { if (root == null) { return; } biTreeInOrderByRecursi

二叉树遍历递归与非递归实现

说明:本文仅供学习交流,转载请标明出处,欢迎转载! 二叉树遍历是二叉树中非常基础的部分,也是学习二叉树必须熟练掌握的部分,下面我们先给出二叉树三种遍历方式的定义,并通过举例来说明二叉树遍历的过程. 二叉树的遍历分为:前序遍历(也叫先序遍历).中序遍历.后序遍历.所谓前.中.后都是根据当前子树根结点相对左右孩子的位置而言,也就是说: 前序遍历:根结点在前,即:根 ----->左------->右: 中序遍历:根结点在中间,即:左------>根------>右: 后序遍历:根结点在最