递归算法中的链表操作

开发 架构 算法
今天我们要讲讲如何添加自己的操作,是在递归调用之前,还是在递归调用之后。

 今天,打算将问题深入一下,即添加相应的操作在递归的过程中。

(免责声明:下面的解法纯属娱乐 ,另外,示例代码未经编译和调试,许多想法未经实践验证。)

查找链表当中倒数第N个节点。

解法一

逐层递归,遍历到最后一个节点,并从返回的节点一次向后递归,遍历N次,找到倒数第N个节点。

  1. private LNode targetNode = null
  2. private LNode FindLastNthNode(LNode head, int index) 
  3.     if (head.Next == null
  4.     { 
  5.         return head; 
  6.     } 
  7.  
  8.     FindLastNthNode(head.Next, index); 
  9.  
  10.     LNode tmpNode = head; 
  11.  
  12.     while ((head.Next != null) && (index > 0)) 
  13.     { 
  14.         head = head.Next; 
  15.         index--; 
  16.     } 
  17.  
  18.     if (head.Next == null && index == 0) 
  19.     { 
  20.         targetNode = tmpNode; 
  21.         return targetNode; 
  22.     } 
  23.  
  24.     return targetNode; 
  25.  

分析

1. 额外的全局性的辅助变量。

2. 时间复杂度为O(index * n),n为链表的长度。

3. 性能开销较大。

解法二(解法一的变形)

每当遍历到当前节点,即再循环向后遍历n个,如果节点遍历到最后,并且index自减等于0,说明当前节点即为要找的倒数第n个。也就是说解法一是从后向前找,而解法二是从前向后找。

  1. private LNode targetNode2 = null
  2.  
  3. private LNode FindLastNthNode2(LNode head, int index) 
  4.     if (head.Next == null
  5.         return head; 
  6.  
  7.     LNode tmpNode = head; 
  8.  
  9.     while (head != null && index >= 0) 
  10.     { 
  11.         head = head.Next; 
  12.         index--; 
  13.     } 
  14.  
  15.     if (head == null && index == 0) 
  16.     { 
  17.         targetNode2 = tmpNode; 
  18.         return targetNode2; 
  19.     } 
  20.  
  21.     return targetNode2; 

分析:与解法一一样。

解法三

  1. private int counter = 0; 
  2. private LNode targetNode2; 
  3.  
  4. private LNode FindLastNthNode2(LNode head, int index) 
  5.     if (head.Next == null
  6.     { 
  7.         counter = index; 
  8.         return head; 
  9.     } 
  10.  
  11.     FindLastNthNode2(head.Next, index); 
  12.  
  13.     counter--; 
  14.  
  15.     if (counter == 0) 
  16.     { 
  17.         targetNode2 = head; 
  18.         return targetNode2; 
  19.     } 
  20.  
  21.     return targetNode2; 
定义一个全局变量,用来计数,当递归从最后一个节点返回时,计数器减减,当等于0时,这个节点即是要找的倒数第N个节点分析
1. 两个辅助变量。
2. 时间复杂度为O(n)。
3. 多余的index,累赘的counter。
责任编辑:彭凡 来源: 博客园
相关推荐

2021-01-28 07:33:34

JavaScript链表数据

2020-07-10 08:15:19

递归算法函数

2012-02-22 14:12:08

算法

2009-11-17 16:53:24

PHP递归算法

2009-11-30 09:35:15

PHP递归算法

2010-04-26 14:43:17

Oracle递归条件查

2021-09-15 07:40:50

二叉树数据结构算法

2019-09-18 10:12:37

递归数据结构

2009-11-18 16:47:50

PHP递归算法

2021-04-25 09:42:40

SQL递归SQL Server

2023-08-29 09:46:12

SQLCTE递归

2019-06-26 09:10:07

操作系统调度算法

2009-09-02 18:39:34

C#递归算法

2020-10-14 08:32:08

算法递归面试

2022-01-27 22:50:01

链表双指针结构

2021-08-03 08:13:47

数据

2009-09-28 10:09:09

Linux内核Linux循环链表

2020-03-31 08:37:31

递归单链表反转

2009-07-20 17:41:59

Java JDBC

2022-03-15 08:36:46

递归查询SQL
点赞
收藏

51CTO技术栈公众号