代码随想录刷题笔记5——双指针

最新推荐文章于 2024-03-11 11:06:55 发布
最新推荐文章于 2024-03-11 11:06:55 发布
阅读量94 收藏
点赞数
分类专栏： leetcode刷题 文章标签： 笔记 leetcode 算法 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhj12138/article/details/132688870
版权

移除元素

例题27（简单）移除元素

注意要点：

  1. 在数组专题中已经有涉及，直接快慢指针，如果碰到要删除的元素，就直接快指针右移跳过；否则就把快指针的值赋值给慢指针，然后一起右移。

下面贴出代码：

CPP版本

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slow = 0;
        for (int fast = 0; fast < nums.size(); fast++)
        {
            if (nums[fast] == val) {continue;}
            else {nums[slow++] = nums[fast];}
        }
        return slow;
    }
};

C版本

int removeElement(int* nums, int numsSize, int val){
    int slow = 0;
    for (int fast = 0; fast < numsSize; fast++)
    {
        if (nums[fast] == val) {continue;}
        else {nums[slow++] = nums[fast];}
    }
    return slow;
}

反转字符串

例题344（简单）反转字符串

注意要点：

  1. 相向双指针，交换当前两指针的值后，均向内移动一位。

下面贴出代码：

CPP版本

class Solution {
public:
    void reverseString(vector<char>& s) {
        for (int i = 0; i < s.size() / 2; i++)
        {
            int tmp = s[i];
            s[i] = s[s.size() - 1 - i];
            s[s.size() - 1 - i] = tmp;
        }
    }
};

C版本

void reverseString(char* s, int sSize){
    for (int i = 0; i < sSize / 2; i++)
    {
        int tmp = s[i];
        s[i] = s[sSize - 1 - i];
        s[sSize - 1 - i] = tmp;
    }
}

替换空格

例题 剑指Offer05（简单）替换空格

注意要点：

  1. 需要注意替换的方向：从前向后就是O(n^2)（还需要在填充后进行移位操作）；而预先扩充数组空间后从后向前就仅有O(n)。

下面贴出代码：

CPP版本

class Solution {
public:
    string replaceSpace(string s) {
        //统计空格数量
        int count = 0;
        for (int i = 0; i < s.size(); i++)
        {
            if (s[i] == ' ') {count++;}
        }
        //扩充为所需的数组大小
        int oldSize = s.size();
        s.resize(s.size() + 2 * count);
        int newSize = s.size();
        for (int i = newSize - 1, j = oldSize - 1; i >= 0, j >= 0; i--, j--)
        {
            if (s[j] == ' ')
            {
                s[i--] = '0';
                s[i--] = '2';
                s[i] = '%';
            }
            else {s[i] = s[j];}
        }
        return s;
    }
};

C版本

char* replaceSpace(char* s){
    int size = 0;
    for (int i = 0; i < strlen(s); i++)
    {
        if (s[i] != ' ') {size++;}
        else {size += 3;}
    }
    char* ans = (char* )malloc(sizeof(char) * (size + 1));
    int ptr_s = strlen(s) - 1, ptr_ans = size;
    ans[ptr_ans] = '\0';
    ptr_ans--;
    while (ptr_s >= 0)
    {
        if (s[ptr_s] != ' ')
        {
            ans[ptr_ans] = s[ptr_s];
            ptr_s--;
            ptr_ans--;
        }
        else
        {
            ans[ptr_ans] = '0';
            ans[ptr_ans-1] = '2';
            ans[ptr_ans-2] = '%';
            ptr_ans -= 3;
            ptr_s--;
        }
    }
    return ans;
}

翻转字符串中的单词

例题151（中等）反转字符串中的单词

注意要点：

  1. 最重要的思路：首先先删掉多余的空格，反转整个字符串，然后寻找到每一个单词，再把单词翻转；
  2. 删除多余的空格，使用快慢指针就可以，类似之前的移除元素；

下面贴出代码：

CPP版本

class Solution {
public:
    void myreverse(string& s, int start, int end)
    {
        int mid = start + (end - start) / 2;
        for (int i = start; i < mid; i++)
        {
            swap(s[i], s[end - 1 - (i - start)]);
        }
    }

    void removeExtraSpaces(string& s)
    {
        int slow = 0;
        for (int i = 0; i < s.size(); i++)
        {
            if (s[i] != ' ')
            {
                if (slow) {s[slow++]  = ' ';}
                while (i < s.size() && s[i] != ' ') {s[slow++] = s[i++];}
            }
        }
        s.resize(slow);
    }

    string reverseWords(string s) {
        removeExtraSpaces(s);
        myreverse(s, 0, s.size());
        int start = 0;
        for (int i = 0; i <= s.size(); i++)
        {
            if (i == s.size() || s[i] == ' ')
            {
                myreverse(s, start, i);
                start = i + 1;
            }
        }
        return s;
    }
};

C版本

char * reverseWords(char * s){
    int slow = 0;
    for (int i = 0; i < strlen(s); i++)
    {
        if (s[i] != ' ')
        {
            if (slow) {s[slow++]  = ' ';}
            while (i < strlen(s) && s[i] != ' ') {s[slow++] = s[i++];}
        }
    }
    s[slow] = '\0';

    int left = 0, right = strlen(s) - 1;  // 当前头部仍可能有空格时的字符串长度
    while (left < right)
    {
        char tmp = s[right];
        s[right] = s[left];
        s[left] = tmp;
        left++;
        right--;
    }
    int len_tmp = strlen(s);

    int len = strlen(s);
    // 接下来翻转单词
    int word_left = 0;
    for (int i = 0; i < len + 1; i++)
    {
        if (s[i] == ' ' || s[i] == '\0')
        {
            int word_right = i - 1;
            while (word_left < word_right)
            {
                char tmp = s[word_right];
                s[word_right] = s[word_left];
                s[word_left] = tmp;
                word_left++;
                word_right--;
            }
            word_left = i + 1;
        }
    }
    return s;
}

翻转链表

例题206（简单）翻转链表

注意要点：

  1. 翻转的思路是找到当前节点的前一个节点，并修改当前节点的next指针，然后向后移动一位；所以需要保存pre以及cur->next辅助计算。

下面贴出代码：

CPP版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur = head;
        ListNode* pre = nullptr;
        while (cur)
        {
            ListNode* tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
};

C版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* dummy = (struct ListNode* )malloc(sizeof(struct ListNode));
    dummy->next = head;
    struct ListNode* cur = dummy->next;
    struct ListNode* pre = NULL;
    while (cur)
    {
        struct ListNode* tmp = cur->next;
        cur->next = pre;
        pre = cur;
        cur = tmp;
    }
    return pre;
}

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

例题19（中等）删除链表的倒数第N个节点

注意要点：

  1. 避免删除的是头结点，所以设置虚拟头节点辅助计算；
  2. 通过快慢指针，快指针移动（n+1）次，再与慢指针一起移动直至链表尾部，慢指针所在位置即为倒数（n+1）所在；
  3. 移动n+1次，就可以直接通过next来删除倒数第n个，避免还要记录pre节点。

下面贴出代码：

CPP版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* slow = dummy;
        ListNode* fast = dummy;
        while (n--) {fast = fast->next;}
        fast = fast->next;
        while (fast)
        {
            slow = slow->next;
            fast = fast->next;
        }
        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        delete(tmp);
        tmp = nullptr;
        return dummy->next;
    }
};

C版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
    struct ListNode* dummyhead = malloc(sizeof(struct ListNode));
    dummyhead->next = head;
    struct ListNode* slow = dummyhead;
    struct ListNode* fast = dummyhead;
    while (n--) {fast = fast->next;}
    fast = fast->next;
    while (fast)
    {
        slow = slow->next;
        fast = fast->next;
    }
    slow->next = slow->next->next;
    return dummyhead->next;
}

链表相交

例题160（简单）链表相交

注意要点：

  1. 通过遍历长度，并使得两链表的当前指针对齐，进而可以同时移动指针判断是否相交；
  2. 对齐方法：计算链表长度差，并在长链表指针移动长度差个次数，来对齐两个指针；
  3. 相交是地址相等，不能简单判断值相等。

下面贴出代码：

CPP版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int totalA = 0, totalB = 0;
        ListNode* curA = headA;
        ListNode* curB = headB;
        //统计两个链表的长度
        while (curA) {curA = curA->next; totalA++;}
        while (curB) {curB = curB->next; totalB++;}

        //移动到距离结尾相同距离处
        curA = headA, curB = headB;
        int sub = totalA - totalB;
        if (sub > 0)
        {
            while (sub--) {curA = curA->next;}
        }
        else {while (sub++) {curB = curB->next;}}

        //判断地址是否相同，而不是val是否相同
        while (curA)
        {
            if (curA == curB) {return curA;}
            else
            {
                curA = curA->next;
                curB = curB->next;
            }
        }
        return NULL;
    }
};

C版本

/**
 1. Definition for singly-linked list.
 2. struct ListNode {
 3.     int val;
 4.     struct ListNode *next;
 5. };
 */
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode* p1 = malloc(sizeof(struct ListNode));
    struct ListNode* p2 = malloc(sizeof(struct ListNode));
    p1->next = headA;
    p2->next = headB;
    int l1 = 0, l2 = 0;
    while (p1->next)
    {
        p1 = p1->next;
        l1++;
    }
    while (p2->next)
    {
        p2 = p2->next;
        l2++;
    }
    p1 = headA;
    p2 = headB;
    int delta = l1 - l2;
    // printf("delta = %d\n", delta);
    // printf("p1 = %d\n", p1);
    if (delta >= 0)
    {
        while(delta--) {p1 = p1->next;}
    }
    else
    {
        while(delta++) {p2 = p2->next;}
    }
    // printf("p1 = %d\n", p1);
    while (p1)
    {
        if (p1 == p2)
        {
            return p1;
        }
        p1 = p1->next;
        p2 = p2->next;
    }
    return NULL;
}

环形链表

例题142（中等）环形链表II

注意要点：

  1. 是否成环的判断：快慢指针，快指针走两步，慢指针走一步，如果能相遇，则证明成环；记录下当前节点；
  2. 寻找成环点：快指针从当前节点出发，慢指针从头结点出发，移动相同步数，相遇点即为成环点。

这道题涉及到的数学推导可以自行退导一下，不乐意推导就直接记结论就可以做题了。

下面贴出代码：

CPP版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* slow = head;
        ListNode* fast = head;
        while (fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast)  //有环
            {
                //从相遇节点，slow回到head，再次移动同样步数，再次相遇就是成环点
                slow = head;
                while (slow != fast)
                {
                    slow = slow->next;
                    fast = fast->next;
                }
                return slow;
            }
        }
        return NULL;
    }
};

C版本

/**
 1. Definition for singly-linked list.
 2. struct ListNode {
 3.     int val;
 4.     struct ListNode *next;
 5. };
 */
struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode* slow = head;
    struct ListNode* fast = head;
    while (fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast)
        {
            while (slow != head)
            {
                slow = slow->next;
                head = head->next;
            }
            return head;
        }
    }
    return NULL;
}

三数之和

例题15（中等）三数之和

注意要点：

  1. 首先把数组变成单调数组，这样才可以简化后续的算法复杂度；
  2. for循环内部，通过单调的特性，进行双指针的简化复杂度算法；如果>target，那么right指针就左移来减小和；如果<target，那么left指针就右移来增大和。

下面贴出代码：

CPP版本

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> ret;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size() - 2; i++)
        {
            //排序后的最小值已经是正的，不可能达到和为0
            if (nums[i] > 0) {return ret;}
            //剪枝操作，不可以从第一个开始，这样会使得答案有遗漏
            if (i && nums[i] == nums[i - 1]) {continue;}
            int left = i + 1, right = nums.size() - 1;
            while (left < right)
            {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum > 0) {right--;}
                else if (sum < 0) {left++;}
                else
                {
                    ret.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    while (left < right && nums[left] == nums[left + 1]) {left++;}
                    while (left < right && nums[right] == nums[right - 1]) {right--;}
                    left++;
                    right--;
                }
            }
        }
        return ret;
    }
};

C版本

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */

int cmp(const void* a, const void* b)
{
    return *(int* )a - *(int* )b;
}


int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
    int** ans = (int** )malloc(sizeof(int* ) * 3000 * 6);
    *returnSize = 0;
    if (numsSize < 3) {return ans;}
    qsort(nums, numsSize, sizeof(int), cmp);

    for (int i = 0; i < numsSize - 2; i++)
    {
        if (nums[i] > 0) {break;}
        else
        {
            if (i && nums[i] == nums[i - 1]) {continue;}
            int left = i + 1, right = numsSize - 1;
            while (right > left)
            {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum > 0) {right--;}
                else if (sum < 0) {left++;}
                else
                {
                    int* arr = (int* )malloc(sizeof(int) * 3);
                    arr[0] = nums[i];
                    arr[1] = nums[left];
                    arr[2] = nums[right];
                    ans[(*returnSize)++] = arr;
                    while (right > left && nums[right] == nums[right - 1]) {right--;}
                    while (right > left && nums[left] == nums[left + 1]) {left++;}
                    right--;
                    left++;
                }
            }
        }
    }
    *returnColumnSizes = (int* )malloc(sizeof(int) * (*returnSize));
    for (int k = 0; k < (*returnSize); k++) {(*returnColumnSizes)[k] = 3;}
    return ans;
}

四数之和

例题18（中等）四数之和

注意要点：

  1. 方法与三数之和很类似，只不过for需要循环两次，注意剪枝和去重都可以写两次。

下面贴出代码：

CPP版本

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> ret;
        if (nums.size() < 4) {return ret;}
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size() - 3; i++)
        {
            if (nums[i] > target && nums[i] >= 0) {break;}
            if (i && nums[i] == nums[i - 1]) {continue;}
            for (int j = i + 1; j <nums.size() - 2; j++)
            {
                if (nums[i] + nums[j] > target && nums[i] + nums[j] >= 0) {break;}
                if (j > i + 1 && nums[j] == nums[j - 1]) {continue;}
                int left = j + 1, right = nums.size() - 1;
                while (left < right)
                {
                    if ((long)nums[i] + nums[j] + nums[left] + nums[right] > target) {right--;}
                    else if ((long)nums[i] + nums[j] + nums[left] + nums[right] < target) {left++;}
                    else
                    {
                        ret.push_back(vector<int>{nums[i], nums[j], nums[left], nums[right]});
                        while (left < right && nums[left] == nums[left + 1]) {left++;}
                        while (left < right && nums[right] == nums[right-1]) {right--;}
                        left++;
                        right--;
                    }
                }
            }
        }
        return ret;
    }
};

C版本

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int cmp(const void* a, const void* b)
{
    return *(int* )a - *(int* )b;
}

int** fourSum(int* nums, int numsSize, int target, int* returnSize, int** returnColumnSizes){
    int** res= (int** )malloc(sizeof(int* ) * 1001);
    *returnSize = 0;
    if (numsSize < 4) {return res;}
    qsort(nums, numsSize, sizeof(int), cmp);
    int len = numsSize;
    for (int i = 0; i < len - 3; i++)
    {
        if (nums[i] > target && nums[i] >= 0) {break;}
        if (i && nums[i] == nums[i - 1]) {continue;}
        for (int j = i + 1; j < len - 2; j++)
        {
            if (nums[i] + nums[j] > target && nums[i] + nums[j] >= 0) {break;}
            if (j > i + 1 && nums[j] == nums[j - 1]) {continue;}
            int left = j + 1, right = len - 1;
            while (left < right)
            {
                if ((long)nums[i] + nums[j] + nums[left] + nums[right] < target) {left++;}
                else if ((long)nums[i] + nums[j] + nums[left] + nums[right] > target) {right--;}
                else
                {
                    int* arr = (int* )malloc(sizeof(int) * 4);
                    arr[0] = nums[i];
                    arr[1] = nums[j];
                    arr[2] = nums[left];
                    arr[3] = nums[right];
                    res[(*returnSize)++] = arr;
                    while (left < right && nums[left] == nums[left + 1]) {left++;}
                    while (left < right && nums[right] == nums[right-1]) {right--;} 
                    left++;
                    right--;
                }
            }
        }
    }
    *returnColumnSizes = (int* )malloc(sizeof(int* ) * (*returnSize));
    for (int i = 0; i < (*returnSize); i++) {(*returnColumnSizes)[i] = 4;}
    return res;
}

总结

  1. 双指针法非常常用，只要涉及删改或者交换，都可以考虑是否需要用双指针法，包括有快慢指针，以及相向指针；
  2. 双指针法用来降低时间复杂度，大多需要配合数组的预排序；
  3. 反向操作就需要先记录pre，以及当前的cur形成双指针。
努力自学的小夏
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
代码随想录+刷题笔记记录
03-22
本文主要介绍代码随想录的刷题笔记记录，方便读者更好地利用该网站进行学习。 ## 刷题笔记记录的作用 刷题笔记记录是代码随想录提供的一个功能，用于记录用户在刷题过程中的解题思路和方法。它可以帮助用户更好地...
代码随想录-双指针
wa9zlp58的博客
03-04 443
27. 移除元素https://leetcode-cn.com/problems/remove-element/ 给你一个数组 nums和一个值 val，你需要 原地 移除所有数值等于val的元素，并返回移除后数组的新长度。 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。 1、暴力法 每次检测到nums[i]==val 就从后往前移动一遍元素 //暴力解法 遍历 pub...
代码随想录——双指针法学习记录
jackelove1的博客
10-13 81
双指针法学习记录
代码随想录学习记录——双指针篇
FavoriteStar的博客
09-06 453
代码随想录学习记录——双指针篇，包含很多道力扣题目的解答！！！
双指针之快慢指针（leetcode刷题总结）
leoyongyuan的博客
09-15 640
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、什么是快慢指针二、例题体现三、数组模拟链表总结 前言 在leetcode刷题经常会碰到快慢指针问题，本文将快慢指针的题目总结模板 一、什么是快慢指针 快慢指针其实就是定义两个指针 fast 和 slow 然后让fast每次都比slow走快一步。快慢指针常见在链表题目，快慢指针的出现让我们能更好的定位链表中的结点位置，也可以在一些特定数组中模拟成链表，简化题目难度。 二、例题体现 在leetcode中有这么一个题目，求环形链
快慢指针 刷题及解答
jhckii的博客
07-11 170
在初始化设置指向链表头结点时，设置两个指针，快慢指针，前进时快指针fast在前，慢指针slow在后，巧妙解决链表中的一些问题。每次快指针多走一步，假设环长为x，当快指针多走x步时会与慢指针相遇快指针是每次走两步，慢指针每次走一步 而不是快指针一开始指向head的下一个 慢指针指向head 两个一起走https://leetcode.cn/problems/linked-list-cycle/ https://leetcode.cn/problems/happy-number/ 已知链表中含有环，返回这个环的
代码随想录刷题打卡day02
最新发布
04-18
代码随想录刷题打卡day02
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
《代码随想录》是一本深受程序员喜爱的编程学习资料，尤其在算法领域，它提供了丰富的实例和深入的解析，帮助读者理解并掌握动态规划、回溯、递归、二叉树以及贪心等核心算法。这些算法是解决复杂计算问题的基础工具...
算法学习---双指针算法
weixin_39038328的博客
03-11 783
算法学习--双指针算法
Leetcode 11. 盛最多水的容器 从暴力优化到双指针，明明白白
u014339447的博客
12-10 214
从暴力优化到双指针，明明白白 这道题的最优解法是左右双指针法。双指针法的难点在于难于想到，难以证明。接下来将一步一步地从暴力解法优化到双指针法。证明也就很简单了。 暴力解法 找出每一种情况，求出盛水值，最大的就是答案。 i指向左挡板，从第一块到遍历倒数第二块。 j指向右挡板，从倒数第一块遍历到i后面那一块。 res保存最大盛水值。 返回res。 代码： //cpp #include <iostream> #include <vector> using namespace std;
[杂记]算法: 快慢指针
wjpwjpwjp0831的博客
11-08 391
打算以后记录一些比较有代表性的算法. 仅从初学者角度对算法进行简单解读, 以力扣题为例.
数据结构之“快慢指针” ---leetcode经典例题讲解和思路
m0_50986342的博客
02-10 1288
今天又掌握到了一个新的操作——“快慢指针” 先介绍一下快慢指针吧 其实顾名思义，就是定义N个指针，其中有快有慢。还是给出例子比较好理解——在有序链表中找出中间节点，返回节点（序列号） 肯定有人和我看到它的第一想法一样：“简单嘛，先遍历一遍，计算出链表的总长度N，然后再遍历一遍找到N/2 确实，这是最好想的方法，但是如果要求只能遍历一遍呢？ 这个时候我就学到了这个操作——快慢指针（如果让我想，我感觉我想大半天估计都想不到这个方法。。。） 首先思路很简单，你想，小明和小红进行100M的赛跑，小明是一个腿比较长
Leetcode每日一题：面试题02.02.kth-node-from-end-of-list-lcci（返回倒数第k个节点）
CodeLuweir 的博客
09-28 3154
思路：典型得快慢指针问题，快指针与慢指针中间隔着k-2个节点，那么同时++快慢指针，当快指针指向链表结尾节点时，慢指针指向倒数第k个节点； struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; int kthToLast(ListNode *head, int k) { ListNode *left = head, *right = head; int count = 1; .
算法---快慢指针最全例题详解
Aa102365478的博客
07-27 451
快慢指针最全例题详解
leetcode总结-快慢指针题型总结
abcnull 的博客
04-03 523
文章目录题型关键字解题步骤 使用快慢指针，可以在 O(n) 的时间复杂度 O(1) 的空间复杂度完成答题 题型 对于线性表类型的题目，如果要求中间某个特定位置的结点值，我们就可以用到快慢指针 关键字 要求线性表中某个结点的结点值 解题步骤 若题型符合快慢指针的题型 1.设置快指针有多快 快指针比慢指针快多少？这要看题目的条件，比方说如果题目要求链表最中间的结点值，我们可以设置快指针每次移动速度...
快慢指针的理解与例题
weixin_44765605的博客
12-09 370
一、前言 最近这段时间我在看链表，同时刷leetcode与链表相关的一些题目，遇到了判断环形链表的题目，我无从下手，然后上网查找一下关于链表的一些其他操作，找到了快慢指针这一关于链表的操作，可以用于判断一个链表是否是环形链表。 二、快慢指针在链表中的一些证明 以下内容我参考了一篇博客：https://blog.csdn.net/jnxxhzz/article/details/82773112 1、快慢指针相遇的证明 ① 没有环的情况 当链表没有环的时候，快指针会到链表尾部，遇到null，慢指针则指向链
C语言--关于快慢指针的例题
loreal8的博客
04-02 404
关于快慢指针的例题 1：给定一个带有头结点 head 的非空单链表，返回链表的中间结点。 如果有两个中间结点，则返回第二个中间结点。 示例1： 输入：[1,2,3,4,5] 输出：此列表中的结点 3 (序列化形式：[3,4,5]) 返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。注意， 我们返回一个 ListNode 类型的对象 ans，这样：ans.val = 3, a...
牛客上代码随想录怎么看题刷题
04-12
牛客网上的代码随想录是一个非常好的刷题平台，它提供了大量的编程题目和解题思路。在牛客网上刷题，可以按照以下步骤进行： 1. 注册并登录牛客网账号。 2. 在主页上找到“代码随想录”板块，点击进入。 3. 在代码...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值