【C语言】递归复杂度与链表OJ之双指针

🔥个人主页：大白的编程日记

🔥专栏：数据结构

---

前言

哈喽，各位小伙伴大家好！今天我们继续深入探讨递归的复杂度和链表OJ常见的双指针法。话不多说，咱们进入正题！向大厂冲锋！

一.递归复杂度

1.1递归时间复杂度

前面我们讲的复杂度没有涉及到递归，那递归的复杂度又该如何计算呢？

// 计算阶乘递归Fac的时间复杂度？
long long Fac(size_t N)
{
 if(0 == N)
    return 1;
 return Fac(N-1)*N;
}

之前我们都是在一个函数中算时间算复杂度，但是递归会自己调用自己，所以递归的时间复杂度计算就需要把每次函数调用次数累加起来。

那我们现在修改一下代码，现在的时间复杂度又是多少呢？

// 计算阶乘递归Fac的时间复杂度？
long long Fac(size_t N)
{
	if (0 == N)
		return 1;
	for (int i = 0; i < N; i++)
	{
		;
	}
	return Fac(N - 1) * N;
}

函数的调用次数不变，每次函数调用的复杂度改变。将每次函数调用的消耗相加
，时间复杂度函数为等差数列。大O渐进表示法算出O（N^2）。

结论：递归时间复杂度==所有递归递归调用次数累加。

现在我们再来计算一下斐波那契数列的时间复杂度。

// 计算斐波那契递归Fib的时间复杂度？
long long Fib(size_t N)
{
 if(N < 3)
 return 1;
 
 return Fib(N-1) + Fib(N-2);
}

这里我们需要画出递归展开图，然后发现调用次数是等比数列。
再用错位相减法计算调用次数即可。实际调用次数没那么多。
但是也是O(2^N)的量级。

1.2递归空间复杂度

那递归的复杂度又该如何计算呢？

• 阶乘
  递归会调用函数，每次调用函数都会开辟栈帧。
  所以递归的空间复杂度是函数调用的次数。

// 计算阶乘递归Fac的空间复杂度？
long long Fac(size_t N)
{
 if(N == 0)
 return 1;
 
 return Fac(N-1)*N;
}

• 斐波那契数列

// 计算斐波那契递归Fib的空间复杂度？
long long Fib(size_t N)
{
 if(N < 3)
 return 1;
 
 return Fib(N-1) + Fib(N-2);
}

斐波那契数列的递归是双倍递归，那他的空间复杂度该如何计算呢？

因为函数栈帧会重复利用，所以斐波那契数列的空间复杂度就是O(N)。

二.链表OJ之双指针

2.1倒数第K个节点

• 题目
  倒数第k个节点
  

• 思路分析

我们先让快慢指针拉开k步，当快指针到NULL节点，慢指针就是倒数第K个节点。

• 代码

typedef struct ListNode ListNode;
int kthToLast(struct ListNode* head, int k)
{
    ListNode* slow,*fast;
    slow=fast=head;
    while(k--)
    {
        fast=fast->next;
    }
    while(fast)
    {
        fast=fast->next;
        slow=slow->next;
    }
    return slow->val;
}

2.2链表的中间节点

• 题目
  链表的中间节点
  
• 思路分析
  我们可以定义两个指针，一个每次走一步，一个每次走两步。
  

这就是我们的快慢指针。两个指针走的路程是2倍关系，当快指针走完时，慢指针也走了快指针的一半路程。

• 代码

 typedef struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head)
 {
    //创建快慢指针
    struct ListNode* slow;
    struct ListNode* fast;
    slow=fast=head;
    while(fast&&fast->next)
    {
        fast=fast->next->next;
        slow=slow->next;
    }
    //此时slow指向中间节点
    return slow;
 }

2.3反转链表

• 题目
  反转链表
  
• 思路
• 我们创建三个节点指针n1,n2,n3。n1刚开始指向NULL，n2指向头节点，n3保存n2的下一个几点。每次都让n2指向n1，然后n1移动到n2，n2移动到n3.n3向后移动。当n2走到尾节点就完成反转。
  
• 代码

 typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head) {
    if(head==NULL)
      return NULL;
    ListNode* n1=NULL;
    ListNode* n2=head;
    ListNode* n3=head->next;
    while(n2)
    {
        n2->next=n1;
        n1=n2;
        n2=n3;
        if(n3)
          n3=n3->next;
    }
    return n1;
}

2.4回文链表

• 题目
  回文链表
  

• 思路

• 我们先找到中间节点，反转以中间节点为头节点的子链表。然后分别从头节点和中间节点开始遍历，一一对比，当中间节点走到NULL时，说明是回文链表。
  

• 代码

typedef struct ListNode ListNode;
 struct ListNode* reverseList(struct ListNode* head)
{
    //创建三个指针
  ListNode *n1,*n2,*n3;
  n1=NULL;
  n2=head;
  if(n2)
   n3=n2->next;
  while(n2)
  {
    n2->next=n1;
    n1=n2;
    n2=n3;
    if(n3)
      n3=n3->next;
  }
  return n1;
}
struct ListNode* middleNode(struct ListNode* head)
 {
    //创建快慢指针
    struct ListNode* slow;
    struct ListNode* fast;
    slow=fast=head;
    while(fast&&fast->next)
    {
        fast=fast->next->next;
        slow=slow->next;
    }
    //此时slow指向中间节点
    return slow;
 }
bool isPalindrome(struct ListNode* head) 
{
    ListNode* mid=middleNode(head);//找到中间节点
    ListNode* reverse=reverseList(mid);//反转后面节点
    ListNode*pcur=head;
    while(reverse)
    {
        if(pcur->val!=reverse->val)//匹配
        {
            return false;
            break;
        }
        reverse=reverse->next;//移动
        pcur=pcur->next;
    }
    return true;
}

2.5相交链表

• 题目
  相交链表
  

• 思路

• 判断相交
  分别遍历两个链表到尾节点，判断尾节点地址是否相等。相等就相交

• 找交点
  让长链表走两链表长度的差距步，此时两节点距离交点差距相等。两节点同时往后遍历，相遇的位置就是交点。

• 代码

typedef struct ListNode ListNode;
struct ListNode* getIntersectionNode(struct ListNode* headA,struct ListNode* headB) {
    int lena = 0, lenb = 0;
    ListNode* pa = headA;
    ListNode* pb = headB;
    while (pa->next)
    {
        lena++;
        pa = pa->next;//遍历统计
    }
    while (pb->next)
    {
        lenb++;
        pb = pb->next;//遍历统计
    }
    if (pb != pa) 
    {
        return NULL;
    }
    ListNode* pshort = headA;
    ListNode* plong = headB;
    if (lena > lenb) //假设法
    {
        plong = headA;
        pshort = headB;
    }
    int tmp = abs(lena - lenb);
    while (tmp--) 
    {
        plong = plong->next;//走差距步
    }
    while (plong!=pshort)
    {
        pshort = pshort->next;
        plong = plong->next;
    }
    return plong;
}

双指针法

大家发现这些题目都会用到两个指针解决问题，这就是我们说的双指针法，具体如何运用双指针，得看具体题目灵活运用。

后言

这就是递归的复杂度和链表常见OJ。今天就分享到这里，感谢大家耐心垂阅。咱们下期见！拜拜~