双指针的基本应用

已于 2023-05-11 15:25:30 修改
阅读量739 收藏 3
点赞数
分类专栏： 力扣 文章标签： 链表 数据结构
于 2023-05-06 10:21:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wdxabc1/article/details/130520796
版权

一、环形链表 I

在这里插入图片描述
在这里插入图片描述

方法1:哈希表

在这里插入图片描述

struct hashTable {
    struct ListNode* key;
    UT_hash_handle hh;
};

struct hashTable* hashtable;

struct hashTable* find(struct ListNode* ikey) {
    struct hashTable* tmp;
    HASH_FIND_PTR(hashtable, &ikey, tmp);
    return tmp;
}

void insert(struct ListNode* ikey) {
    struct hashTable* tmp = malloc(sizeof(struct hashTable));
    tmp->key = ikey;
    HASH_ADD_PTR(hashtable, key, tmp);
}

bool hasCycle(struct ListNode* head) {
    hashtable = NULL;
    while (head != NULL) {
        if (find(head) != NULL) {
            return true;
        }
        insert(head);
        head = head->next;
    }
    return false;
}

代码解释
(1) HASH_FIND_PTR(hashtable, &ikey, tmp);
  在这段代码中，hashtable 是哈希表的头指针，&ikey 是要查找的键，它是一个指向链表节点指针的指针的地址，tmp 是查找结果的输出参数，它是一个指向哈希表项的指针。因此，HASH_FIND_PTR(hashtable, &ikey, tmp) 的作用是在哈希表中查找指定键的哈希表项，并将结果存储在 tmp 中。如果找到了，则返回该哈希表项；否则返回 NULL。

(2)HASH_ADD_PTR(hashtable, key, tmp);
  在这段代码中，hashtable 是哈希表的头指针，key 是哈希表项中表示键的字段，它是一个指向链表节点指针的指针，tmp 是要添加的键值对，它是一个指向哈希表项的指针。因此，HASH_ADD_PTR(hashtable, key, tmp) 的作用是将一个键值对添加到哈希表中，其中键是 tmp->key，即链表节点的指针，值是 tmp，即哈希表项的指针，同时更新哈希表的头指针 hashtable。

C++

class Solution {
public:
    bool hasCycle(ListNode *head) {
        //定义了一个 unordered_set<ListNode*> seen，
        //表示存储已经遍历过的链表节点的集合。
        unordered_set<ListNode*> seen;
        while (head != nullptr) {
            if (seen.count(head)) {
                return true;
            }
            seen.insert(head);
            head = head->next;
        }
        return false;
    }
};

方法2：快慢指针

在这里插入图片描述
在这里插入图片描述
C

bool hasCycle(struct ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return false;
    }
    struct ListNode* slow = head;
    struct ListNode* fast = head->next;
    while (slow != fast) {
        //检测快指针 fast 是否到达了链表的末尾。如果 fast 指针到达了末尾，
        //即 fast 指向空节点或者 fast 的下一个节点为空节点，则说明链表没有环，
        //返回 false。
        if (fast == NULL || fast->next == NULL) {
            return false;
        }
        slow = slow->next;
        fast = fast->next->next;
    }
    return true;
}

C++

class Solution {
public:
    bool hasCycle(ListNode* head) {
        if (head == nullptr || head->next == nullptr) {
            return false;
        }
        ListNode* slow = head;
        ListNode* fast = head->next;
        while (slow != fast) {
            if (fast == nullptr || fast->next == nullptr) {
                return false;
            }
            slow = slow->next;
            fast = fast->next->next;
        }
        return true;
    }
};

二、环形链表 II

在这里插入图片描述
在这里插入图片描述

方法1:哈希表

在这里插入图片描述

C

struct hashTable {
    struct ListNode* key;
    UT_hash_handle hh;
};

struct hashTable* hashtable;

struct hashTable* find(struct ListNode* ikey) {
    struct hashTable* tmp;
    HASH_FIND_PTR(hashtable, &ikey, tmp);
    return tmp;
}

void insert(struct ListNode* ikey) {
    struct hashTable* tmp = malloc(sizeof(struct hashTable));
    tmp->key = ikey;
    HASH_ADD_PTR(hashtable, key, tmp);
}

struct ListNode* detectCycle(struct ListNode* head) {
    hashtable = NULL;
    while (head != NULL) {
        if (find(head) != NULL) {
            return head;
        }
        insert(head);
        head = head->next;
    }
    return false;
}

C++

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        unordered_set<ListNode *> visited;
        while (head != nullptr) {
            if (visited.count(head)) {
                return head;
            }
            visited.insert(head);
            head = head->next;
        }
        return nullptr;
    }
};

方法2：快慢指针

在这里插入图片描述
C

struct ListNode* detectCycle(struct ListNode* head) {
    struct ListNode *slow = head, *fast = head;
    while (fast != NULL) {
        slow = slow->next;
        if (fast->next == NULL) {
            return NULL;
        }
        fast = fast->next->next;
        if (fast == slow) {
            struct ListNode* ptr = head;
            while (ptr != slow) {
                ptr = ptr->next;
                slow = slow->next;
            }
            return ptr;
        }
    }
    return NULL;
}

C++

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *slow = head, *fast = head;
        while (fast != nullptr) {
            slow = slow->next;
            if (fast->next == nullptr) {
                return nullptr;
            }
            fast = fast->next->next;
            if (fast == slow) {
                ListNode *ptr = head;
                while (ptr != slow) {
                    ptr = ptr->next;
                    slow = slow->next;
                }
                return ptr;
            }
        }
        return nullptr;
    }
};

三、相交链表

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

方法1:哈希集合

在这里插入图片描述
C

struct HashTable {
    struct ListNode *key;
    UT_hash_handle hh;
};

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct HashTable *hashTable = NULL;
    struct ListNode *temp = headA;
    while (temp != NULL) {
        struct HashTable *tmp;
        HASH_FIND(hh, hashTable, &temp, sizeof(struct HashTable *), tmp);
        if (tmp == NULL) {
            tmp = malloc(sizeof(struct HashTable));
            tmp->key = temp;
            HASH_ADD(hh, hashTable, key, sizeof(struct HashTable *), tmp);
        }
        temp = temp->next;
    }
    temp = headB;
    while (temp != NULL) {
        struct HashTable *tmp;
        HASH_FIND(hh, hashTable, &temp, sizeof(struct HashTable *), tmp);
        if (tmp != NULL) {
            return temp;
        }
        temp = temp->next;
    }
    return NULL;
}

代码解释:
(1)HASH_FIND(hh, hashTable, &temp, sizeof(struct HashTable *), tmp);
HASH_FIND(hh, hashTable, &temp, sizeof(struct HashTable *), tmp); 的作用是在哈希表 hashTable 中查找是否存在指针 temp 所指向的 ListNode 节点，如果找到了就将指向 HashTable 结构体的指针赋值给 tmp，否则将 tmp 赋值为 NULL。

(2)HASH_ADD(hh, hashTable, key, sizeof(struct HashTable *), tmp);
HASH_ADD(hh, hashTable, key, sizeof(struct HashTable *), tmp); 的作用是将指针 tmp 所指向的 HashTable 结构体添加到哈希表 hashTable 中。具体来说，它将 tmp 关联到 key 成员（即指向 ListNode 的指针），并将 tmp 添加到哈希表中。

C++

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        unordered_set<ListNode *> visited;
        ListNode *temp = headA;
        while (temp != nullptr) {
            visited.insert(temp);
            temp = temp->next;
        }
        temp = headB;
        while (temp != nullptr) {
            if (visited.count(temp)) {
                return temp;
            }
            temp = temp->next;
        }
        return nullptr;
    }
};

方法2:双指针

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

C

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    if (headA == NULL || headB == NULL) {
        return NULL;
    }
    struct ListNode *pA = headA, *pB = headB;
    while (pA != pB) {
        pA = pA == NULL ? headB : pA->next;
        pB = pB == NULL ? headA : pB->next;
    }
    return pA;
}

C++

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (headA == nullptr || headB == nullptr) {
            return nullptr;
        }
        ListNode *pA = headA, *pB = headB;
        while (pA != pB) {
            pA = pA == nullptr ? headB : pA->next;
            pB = pB == nullptr ? headA : pB->next;
        }
        return pA;
    }
};

四、删除链表的倒数第N个节点

在这里插入图片描述

方法1：计算链表长度

在这里插入图片描述
C

int getLength(struct ListNode* head) {
    int length = 0;
    while (head) {
        ++length;
        head = head->next;
    }
    return length;
}

struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    struct ListNode* dummy = malloc(sizeof(struct ListNode));
    dummy->val = 0, dummy->next = head;
    int length = getLength(head);
    struct ListNode* cur = dummy;
    for (int i = 1; i < length - n + 1; ++i) {
        cur = cur->next;
    }
    cur->next = cur->next->next;
    struct ListNode* ans = dummy->next;
    free(dummy);
    return ans;
}

C++

class Solution {
public:
    int getLength(ListNode* head) {
        int length = 0;
        while (head) {
            ++length;
            head = head->next;
        }
        return length;
    }

    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0, head);
        int length = getLength(head);
        ListNode* cur = dummy;
        for (int i = 1; i < length - n + 1; ++i) {
            cur = cur->next;
        }
        cur->next = cur->next->next;
        ListNode* ans = dummy->next;
        delete dummy;
        return ans;
    }
};

代码解释:
(1)ListNode* dummy = new ListNode(0, head);
  在C++中，使用new关键字可以动态地在堆上分配内存，返回指向该内存的指针。ListNode(0, head)是调用ListNode类的构造函数，创建一个新的ListNode对象，并将0和head作为参数传递给构造函数。因为该构造函数接收两个参数，所以使用了括号括起来的两个参数。

  这段代码的作用是创建一个虚拟头节点，将其值初始化为0，next指针指向head，这样可以方便处理删除头节点的情况。因为该虚拟头节点是动态分配的，所以在函数结束时需要调用delete关键字释放动态分配的内存。

方法2：栈

在这里插入图片描述
C

struct Stack {
    struct ListNode* val;
    struct Stack* next;
};

struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    struct ListNode* dummy = malloc(sizeof(struct ListNode));
    dummy->val = 0, dummy->next = head;
    struct Stack* stk = NULL;
    struct ListNode* cur = dummy;
    while (cur) {
        struct Stack* tmp = malloc(sizeof(struct Stack));
        tmp->val = cur, tmp->next = stk;
        stk = tmp;
        cur = cur->next;
    }
    for (int i = 0; i < n; ++i) {
        struct Stack* tmp = stk->next;
        free(stk);
        stk = tmp;
    }
    struct ListNode* prev = stk->val;
    prev->next = prev->next->next;
    struct ListNode* ans = dummy->next;
    free(dummy);
    return ans;
}

代码解释:
(1)tmp->val = cur, tmp->next = stk;stk = tmp;
  第一行代码将 tmp 的 val 字段设置为 cur 的当前值，即将当前节点压入栈中。第二行代码将 tmp 的 next 字段设置为栈的当前顶部节点 stk 的地址，表示将新节点的下一个节点设置为当前栈顶节点。最后，将 stk 的值更新为 tmp 的地址，即将新节点 tmp 设置为栈的新顶部节点。这样，新节点就被成功压入了栈中。

C++

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0, head);
        stack<ListNode*> stk;
        ListNode* cur = dummy;
        while (cur) {
            stk.push(cur);
            cur = cur->next;
        }
        for (int i = 0; i < n; ++i) {
            stk.pop();
        }
        ListNode* prev = stk.top();
        prev->next = prev->next->next;
        ListNode* ans = dummy->next;
        delete dummy;
        return ans;
    }
};

代码解释
(1)stk.push(cur);
  这行代码的作用是将当前节点 cur 压入栈中。具体来说，代码使用一个 stack 容器来存储链表中的每个节点，每当遍历到一个节点时，就将其压入栈中，以便后续在栈中访问该节点。由于栈是一种后进先出（LIFO）的数据结构，因此在遍历完整个链表后，栈中存储的节点顺序就是链表中节点的逆序。

(2)stk.pop();
  这行代码的作用是从栈中弹出一个节点，即将栈顶的节点删除。具体来说，代码使用一个 for 循环从栈中弹出前 n 个节点，即跳过倒数第 k 个节点。由于栈是一种后进先出（LIFO）的数据结构，因此每次 stk.pop() 操作都会弹出栈顶的节点，直到循环结束时，栈中存储的节点就是链表中从头节点开始到倒数第 k+1 个节点的所有节点。

(3)stk.top();
  这行代码的作用是获取栈顶节点的指针，即获取栈中最近压入的节点。具体来说，代码使用一个 stack 容器来存储链表中的每个节点，每当遍历到一个节点时，就将其压入栈中，以便后续在栈中访问该节点。

  由于栈是一种后进先出（LIFO）的数据结构，因此栈顶节点就是最近压入栈中的节点，可以使用 stk.top() 来获取栈顶节点的指针。在本实现中，栈中存储的是指向链表节点的指针，因此 stk.top() 返回的是一个指向栈顶节点的指针。

方法3：双指针

在这里插入图片描述
在这里插入图片描述
C

struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    struct ListNode* dummy = malloc(sizeof(struct ListNode));
    dummy->val = 0, dummy->next = head;
    struct ListNode* first = head;
    struct ListNode* second = dummy;
    for (int i = 0; i < n; ++i) {
        first = first->next;
    }
    while (first) {
        first = first->next;
        second = second->next;
    }
    second->next = second->next->next;
    struct ListNode* ans = dummy->next;
    free(dummy);
    return ans;
}

C++

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0, head);
        ListNode* first = head;
        ListNode* second = dummy;
        for (int i = 0; i < n; ++i) {
            first = first->next;
        }
        while (first) {
            first = first->next;
            second = second->next;
        }
        second->next = second->next->next;
        ListNode* ans = dummy->next;
        delete dummy;
        return ans;
    }
};
孤芳剑影
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++双指针示例
11-11
双指针的基本思想是设置两个指针，一个从数组或数据结构的头部开始，另一个从尾部开始，然后逐渐靠近，直到找到特定条件或完成特定任务。这种方式通常用于排序、查找、合并等操作，极大地提高了算法效率。 首先，...
C语言指针（二重指针）
shark_93的博客
05-08 6579
1.二重指针 1.1、二重指针与普通一重指针的区别 (1)本质上来说，二重指针和一重指针的本质都是指针变量，指针变量的本质就是变量。 (2)一重指针变量和二重指针变量本身都占4字节内存空间， 1.2、二重指针的本质 (1)二重指针本质上也是指针变量，和普通指针的差别就是它指向的变量类型必须是个一重指针。二重指针其实也是一种数据类型，编译器在编译时会根据二重指针的数据类型来做静态类型检查，一旦发现运算时数据类型不匹配编译器就会报错。 (2)C语言中如果没有二重指针行不行？其实是可以的。一重指针完全可以做二重指
双重指针的用法
qq_51197244的博客
11-06 5192
双重指针的定义是指向指针数据的指针变量，简单来说指向指针的指针。 作用1：改变一维指针的指向。 作用2：借助双重指针一系列操作直接改变存储的值。
为什么链表要用双重指针？？
最新发布
weixin_63809529的博客
04-23 477
在C语言中，二重指针是指指向指针的指针。它的语法形式是type **ptr，其中type是指针指向的数据类型。二重指针通常用于函数参数传递，特别是在需要修改指针指向的内存地址时非常有用。
C语言哈希表学习
2440学习---LCD详解（1） LCD原理
07-22 1615
C语言标准库uthash.h 源码 uthash.h源文件地址 源码分析 缺 convenience forms HASH_FIND_INT(head,findint,out) 功能:从哈希表head中查找int类型数据findint， 参数分析： head：处理句柄，可以理解为需要进行 参考： [1]、https://blog.csdn.net/whatday/article/details/95926766 ...
双重指针的使用
weixin_41637329的博客
05-10 995
这几天看yolov3程序，里面有双重指针的调用，不是很了解，所以转载了双重指针的用法这篇文章。 首先看一道习题： char GetMemory(char *memorystr,u8 num) { memorystr = (char*)malloc(num); } int main(void) { char *str = NULL; GetMemory(str,6)...
C语言 - 二重指针，二维数组
weixin_49303682的博客
07-15 5466
1.二重指针 (1)二重指针与普通一重指针的区别 ->本质上来说，二重指针和一重指针的本质都是指针变量，指针变量的本质就是变量。 ->一重指针变量和二重指针变量本身都占4字节内存空间。 ...
c语言双重指针结构体,指针的本质
weixin_39564807的博客
05-25 1333
指针就是一个整数计算机中的内存都是编址的，每个地址都有一个符号，就像家庭地址或者IP地址一样。指针，是一个无符号整数(unsignedint，因不致歧义，下简称“整数”)，它是一个以当前系统寻址范围为取值范围的整数。声明指针和声明一个无符号整数实质上并无区别。32位系统的寻址能力(地址空间)是4GB(0~232-1)，二进制表示长度为32比特，也就是4B。不难验证，在32位系统里，int类型也正好...
适合小白的python算法-双指针问题
12-21
总结来说，双指针在数组操作中有着广泛的应用，如数组合并和二分查找。理解这些基础概念有助于解决更复杂的问题，并提升编程能力。同时，链表作为重要的数据结构，理解和掌握其工作原理对学习高级算法至关重要。
深入理解双指针的两种用法
09-05
本文将详细讲解双指针的两种主要用法，以及它们在实际问题中的应用。 首先，双指针的基本概念是：在一个指针变量中存储另一个指针的地址。这样，我们可以通过一级指针来间接操作二级指针所指向的内存，从而实现更...
双指针实现交换
07-06
在C++等编程语言中，我们可以采用多种方法来实现这个功能，其中一种就是使用双指针。本文将深入探讨如何使用双指针来实现交换，并通过一个具体的C++示例来解释其工作原理。 首先，我们要明白指针在内存中的工作方式...
双向链表插入删除基本应用介绍
09-05
下面我们将详细讨论双向链表的基本概念、插入和删除操作。 首先，我们定义双向链表的节点结构。如下所示： ```cpp struct DNode { int data; // 存储数据的成员 struct DNode *next; // 指向下一个节点的指针 ...
HASH_FIND_PTR(_hashForTimers, &target, element);
u010536615的专栏
04-07 2589
调用unscheduel（）和isScheduel()时程序崩到HASH_FIND_PTR(_hashForTimers, &target, element); 原因：调用unscheduel（）和isScheduel()的类已经不存在，仔细检查下是否置为NULL,或者释放过，或者已经removeFromParent();
双指针法总结
qq_46514141的博客
05-17 1597
双指针法在对数组做出某种改变中经常用到，优点是时间复杂度为O(n)，且一般空间复杂度也比较低。 所谓双指针法，就是利用两个指针（不一定真是指针，能存储相应元素的位置就行）分别标识两个位置，然后通过指针所指元素的性质对数组进行修改，同时指针进行移动完成目标的方法。 一般双指针有两种使用方法，一是分为快慢指针，慢指针指向下一个要填充的位置，快指针指向下一个要判断的位置，若快指针指向的元素符合相应的条件，则把元素填充（或交换）到慢指针所指位置，然后两个指针进行移动。这样还可以保持数组的相对顺序（如果不用保持相对顺
指针和双重指针
初学者的学习播客
11-09 469
指针和双重指针
算法——双指针技巧总结
weixin_61015911的博客
04-19 2896
双指针技巧可细分分为两类，一类是**快慢指针**，一类是**左右指针**。 前者解决主要解决链表中的问题，比如典型的判定链表中是否包含环、反转链表、找链表的中间节点、删除链表的倒数第 N 个结点；也用来解决数组中的问题，如移动/移除元素、删除有序数组中的重复项。 后者主要解决数组（或者字符串）中的问题，比如二分查找，滑动窗口。
小白学C语言数据结构之链表（二：例题贴）
qq_53190537的博客
03-19 212
例题 其实这章才能用明白hashmap...
C语言哈希表uthash的使用方法详解
qq_45022743的博客
03-17 2863
uthash简介   由于C语言本身不存在哈希，但是当需要使用哈希表的时候自己构建哈希会异常复杂。因此，我们可以调用开源的第三方头文件，这只是一个头文件：uthash.h。我们需要做的就是将头文件复制到您的项目中，然后：#include "uthash.h"。由于uthash仅是头文件，因此没有可链接的库代码。   使用uthash添加，查找和删除通常是常数时间的操作，此哈希的目标是简约高效。它大约有1000行C。它会自动内联，因为它是作为宏实现的。   uthash还包括三个额外的头文件，主要提供链表，.
循环链表和双向链表.ppt
09-20
资源内容： 带头结点的链表、循环链表和双向链表的特征，基本运算。 对于循环链表要突出掌握判断链表空满的条件； 双向链表要强调插入和删除算法的实现。 最后通过多项式加法的示例，介绍线性表的应用。 预期目标： 我希望大家都学习点算法，提升下内功，别整天就知道CRUD，ok。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值