【算法笔记4.6小节 - two pointers】双指针

最新推荐文章于 2024-10-27 21:20:17 发布
原创 最新推荐文章于 2024-10-27 21:20:17 发布 · 336 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法笔记

本文探讨了在递增正整数序列中找到两数之和等于特定值的算法，以及实现序列合并、归并排序、快速排序和随机选择算法的详细过程。通过具体示例，展示了不同排序算法的运行效果。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  1. 给定一个递增的正整数序列a和一个正整数m,求序列中的两个不同位置的数a和b，使他们的和恰好为m,输出所有满足条件的方案。

    #include <stdio.h>
/*
给定一个递增的正整数序列a和一个正整数m,求序列中的两个不同位置
的数a和b，使他们的和恰好为m,输出所有满足条件的方案。
*/
int main()
{
   int a[6] = {1,2,3,4,5,6};
   int i=0, j=5,m=8;
   while(i<j)
   {
       if(a[i]+a[j]==m)
       {
           printf("%d %d\n",a[i],a[j]);
           i++;
           j--;
       }
       else if(a[i]+a[j]<m) i++;
       else  j--;
   }
   return 0;
}
/*运行结果
2 6
3 5

*/

     

  2. 序列合并问题。假设有两个递增序列a和b,要求把他们合并成一个递增序列c.

    #include<stdio.h>
int merge(int a[], int b[], int c[], int n,int m)
{
    int i=0,j=0,index = 0;
    while(i<n&&j<m)
    {
        if(a[i]<=b[j])
            c[index++] = a[i++];
        else
            c[index++] = b[j++];
    }
    while(i<n) c[index++] = a[i++];
    while(j<m) c[index++] = b[j++];
    return index;//返回序列c的长度
}
int main()
{
    int a[5]={1,3,5,7,9}, b[4]={2,4,6,8};
    int c[12];
    int len = merge(a,b,c,5,4);
    for(int i=0; i<len; i++)
    {
        printf("%d",c[i]);
        if(i<len-1)
            printf(" ");
        else
            printf("\n");
    }
    return 0;
}
//运行结果 1,2,3,4,5,6,7,8,9

     

  3. 2-路归并排序( nlogn)

例如序列{66， 12， 33， 57,  64， 27， 18}

第一趟新序列    { 12， 66， 33， 57,  27， 64， 18 }

第二趟新序列    { 12， 33， 57， 66,  18， 27， 64 }

第三趟新序列    {12， 18， 27， 33,  57， 64， 66 }

#include<stdio.h>
/*
归并排序递归实现
*/
void merge(int a[], int left1, int right1, int left2, int right2)
{
    int i=left1, j = left2;    //  i指向a[L1],j指向a[L2]
    int temp[100], index = 0;   //  temp临时存放合并后的数组
    while(i<=right1&&j<=right2)
    {
        if(a[i]<=a[j]) temp[index++] = a[i++];
        else           temp[index++] = a[j++];
    }
    while(i<=right1) temp[index++] = a[i++];
    while(j<=right2) temp[index++] = a[j++];
    for(i=0; i<index; i++)
        a[left1+i] = temp[i];    //将合并后的序列赋值回数组a
}

void mergeSort(int a[], int left, int right)
{
    if(left<right)  // 只要left小于right
    {
        int mid = (left + right)/2;
        mergeSort(a, left, mid);    //递归左子区间
        mergeSort(a, mid+1, right); //递归右子区间
        merge(a, left, mid,mid+1, right);   //将左右区间合并
    }
}
int main()
{
    int a[7] = {66,12,33,57,64,27,18};
    mergeSort(a, 0,6);
    for(int i=0; i<7; i++)
    {
        printf("%d",a[i]);
        if(i<6) printf(" ");
        else printf("\n");
    }
}
//运行结果 12 18 27 33 57 64 66

#include<stdio.h>
#include<algorithm>
using namespace std;
/*
归并排序非递归实现
*/
void merge(int a[], int left1, int right1, int left2, int right2)   //两个序列合并
{
    int i=left1, j = left2;    //  i指向a[L1],j指向a[L2]
    int temp[100], index = 0;   //  temp临时存放合并后的数组
    while(i<=right1&&j<=right2)
    {
        if(a[i]<=a[j]) temp[index++] = a[i++];
        else           temp[index++] = a[j++];
    }
    while(i<=right1) temp[index++] = a[i++];
    while(j<=right2) temp[index++] = a[j++];
    for(i=0; i<index; i++)
        a[left1+i] = temp[i];    //将合并后的序列赋值回数组a
}

void mergeSort(int a[], int n)
{
    //step为组内元素个数
    //step/2 为左子区间元素个数,注意等号可以不取
    for(int step=2; step/2<=n; step*=2){
        //每step个元素一组，组内前step/2和后step/2元素进行合并
        for(int i=0; i<n; i+=step)
        {
            int mid = i + step/2 - 1;//左子区间元素个数为step/2
            if(mid+1<=n)    //右子区间存在元素则合并
            //左子区间为[i, mid], 右子区间为[mid+1，min(i+step-1, n)]
                merge(a,i, mid, mid+1, min(i+step-1, n));
        }
         for(int i=0; i<7; i++)
        {
            printf("%d",a[i]);
            if(i<6) printf(" ");
            else printf("\n");
        }
    }
}


int main()
{
    int a[7] = {66,12,33,57,64,27,18};
    mergeSort(a, 6);

}
//运行结果 12 18 27 33 57 64 66

4. 快速排序( nlogn)

#include<stdio.h>
#include<algorithm>
#include<stdlib.h>
#include<time.h>
#include<math.h>
using namespace std;
/*
快速排序
*/

//对区间[left, right]进行一次划分
int Partition(int a[], int left, int right)
{
    //生成[left,right]内的随机数
    int p = (round(1.0*rand()/RAND_MAX*(right-left)+left));
    swap(a[p], a[left]);//交换a[p]和a[left]

    int temp = a[left];         //以a[left]为枢轴
    while(left<right)           //只要left和right不相遇
    {
        while(left<right&&a[right]>temp) right--;
        a[left] = a[right];
        while(left<right&&a[left]<=temp) left++;
        a[right]=a[left];//将a[left]挪到a[right]
    }
    a[left] = temp; //把temp放到left与right相遇的地方
    return left;//返回相遇的下标
}

//快速排序，left与right初值为序列首尾下标
void quickSort(int a[], int left, int right)
{
    if(left < right)
    {
        int pos = Partition(a, left, right);
        quickSort(a, left, pos-1);
        quickSort(a, pos+1, right);
    }
}
int main()
{
    int a[7] = {66,12,33,57,64,27,18};
    quickSort(a, 0, 6);
    for(int i=0; i<7; i++)
        printf("%d ", a[i]);


}
//运行结果 12 18 27 33 57 64 66

5. 随机选择算法(O(n))

（408真题）给定一个由整数组成的集合，集合中的整数各不相同，现在要将它分为两个子集合，使得这两个子集合的并为原集合，交为空集，同时在两个子集合的元素个数n1和n2之差的绝对值|n1-n2|可能小的前提下，要求他们各自的元素之和s1与s1之差的绝对值|s1-s2|尽可能大。求这个|s1-s2|等于多少？


#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<stdlib.h>
#include<time.h>
/*
如何从一个无序的数组中求出第K大的数,(假设数组中的数各不相同)
随机选择算法 O(n)
*/
using namespace std;
int a[6];
//随机划分
int randPartition(int a[], int left, int right)
{
    //生成[left,right]内的随机数
    int p = (round(1.0*rand()/RAND_MAX*(right-left)+left));
    swap(a[p], a[left]);//交换a[p]和a[left]

    int temp = a[left];         //以a[left]为枢轴
    while(left<right)           //只要left和right不相遇
    {
        while(left<right&&a[right]>temp) right--;
        a[left] = a[right];
        while(left<right&&a[left]<=temp) left++;
        a[right]=a[left];//将a[left]挪到a[right]
    }
    a[left] = temp; //把temp放到left与right相遇的地方
    return left;//返回相遇的下标
}
int randSelect(int a[], int left, int right, int k)
{
    if(left==right) return a[left];//边界
    int p = randPartition(a, left, right);//随机划分
    int m = p-left+1;
    if(k==m) return a[p];
    if(k<m)     //第k大的数在主元左侧
        return randSelect(a,left, p-1,k);
    else
        return randSelect(a, p+1, right, k-m);
}
int main()
{
    srand((unsigned)time(NULL));
    int n;
    int sum=0, sum1=0;
    scanf("%d",&n);
    for(int i=0; i<n; i++)
    {
        scanf("%d",&a[i]);
        sum+=a[i];
    }

    randSelect(a,0,n-1, n/2);//寻找第n/2的数，并进行切分
    for(int i=0; i<n/2; i++)
        sum1+=a[i];
    printf("%d\n",(sum-sum1)-sum1);
    return 0;
}
/*
13
1 6 33 18 4 0 10 5 12 7 2 9 3
80

*/

 

 

 

 

算法篇-------------双指针法
2401_85878549的博客
03-31 1162
直接盲目凭空猜是肯定不靠谱的，我们不妨这样，可以进行。
python 教程 leetcode 代码模板-Linked-List-Two-Pointers.md
07-17
### Python 教程 LeetCode 代码模板 - Linked List & Two Pointers #### 一、双指针技术概览 在本教程中，我们将探讨一种在处理链表问题时非常有用的技巧——双指针技术。双指针技术的核心在于利用两个指针来遍历...
算法笔记——双指针法
袁钰琦的博客
02-19 342
最近几天想把寒假做的有关算法的笔记整理出来，其中有很多例题都是出自leetcode，还有一些是参考 《算法竞赛入门经典》，用得比较多的方法有动态规划法、双指针法、回溯法、二分法、递归法等。 今天先双指针法：双指针法的形式有好几种，如同侧出发，两侧逼近（需要先排序，其实遍历两次也可以，但是算法复杂度比较高），两侧远离。 形式一：同侧出发 乘积小于K的子数组 ： 给定一个正整数数组 nums。 找出该...
双指针法
Moon And pennys
09-15 381
双指针法 双指针法三类 左右双指针算法 快慢双指针算法 后序双指针算法 左右双指针算法 左右双指针算法基本思想 左右双指针算法在解决问题的过程中会生成两个指针，**一个指向头部，一个指向尾部，从两端向中间逼近，知道满足条件或者两个指针相遇为止。**二分查找就是一种左右双指针算法的应用场景，其他使用情况基本上可以总结为数组中元素组合问题。 经典例题：三和之和 该问题是采用左右双指针算法解决的经典问题之一，以三数之和为限制条件，适当调整左右指针。 def threeSum(array): ""
python 教程 leetcode 代码模板-.Linked-List-Two-Pointers-List.md
07-17
### Python教程：LeetCode中的链表与双指针技术详解 #### 一、引言 在数据结构与算法的学习过程中，链表作为一种重要的线性数据结构，在计算机科学领域有着广泛的应用。而“双指针”技巧，则是解决链表问题时经常...
前端大厂最新面试题-two-pointers.docx
06-06
前端大厂最新面试题-two-pointers.docx 本文档总结了前端大厂的最新面试题，涵盖了 two-pointers topic 的相关知识点。该文档共收录了 50 道题目，涵盖了中等和困难两种难度的面试题目。 Knowledge Point 1:双...
LeetCodemaxarea-Two-Pointers-1:两分球-1
07-07
【标题】"LeetCodemaxarea-Two-Pointers-1:两分球-1" 涉及的主要是编程算法中的"两分法"（Two-Pointers Technique）在解决实际问题中的应用，特别是在力扣（LeetCode）平台上的挑战。这个题目可能是关于在一个数组或...
leetcode-Two-Pointers-2:两分球-2
06-29
在LeetCode平台上，"两分球-2"是一组与编程和算法相关的题目，主要涉及了"两分法"（Two-Pointers）这一经典算法思想。两分法是一种高效解决数组或链表问题的策略，它通过维护两个指针，一个从数组的起始位置开始，另...
双指针方法
Hello World!
08-03 2009
如果左指针left 指向的元素等于val，此时将右指针right 指向的元素复制到左指针left 的位置，然后右指针 right 左移一位。如果赋值过来的元素恰好也等于val，可以继续把右指针right 指向的元素的值赋值过来（左指针left 指向的等于val 的元素的位置继续被覆盖），直到左指针指向的元素的值不等于val 为止。根据快慢法则，走的快的一定会追上走得慢的。对于字符串，我们定义两个指针（也可以说是索引下标），一个从字符串前面，一个从字符串后面，两个指针同时向中间移动，并交换元素。.......
双指针法（快慢指针
a22025340的博客
06-13 528
来自代码随想录 暴力解法 就是两层for循环，一个for循环遍历数组元素 ，第二个for循环更新数组。 双指针法 双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。定义快慢指针快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组 慢指针：指向更新 新数组下标的位置 很多同学这道题目做的很懵，就是不理解 快慢指针究竟都是什么含义，所以一定要明确含义，后面的思路就更容易理解了。 力扣相关题目 移除元素 删除有序数组中的重复项 比较含退格的字符串(逆序遍历） 有序数
数组之双指针法(快慢指针法)
weixin_46497503的博客
10-09 312
//数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖 public static void main(String[] args) { int[] a = {3, 2, 4, 7, 1, 10, 6, 9, 8, 5}; int len = delNode(a, 3, 10); for(int i = 0; i < len; i++){ System.out.print(a[i] + " ");
双指针法及例题
最新发布
2301_80186482的博客
10-27 813
双指针法的讲解及例题
[零基础算法入门①] 双指针法
罅隙的博客
12-08 1527
????????零基础算法入门系列——双指针法
【习题】双指针法（详解）
Shun_Hua的博客
02-02 882
双指针习题
掌握算法精髓：LeetCode Two Pointers系列第二弹
在处理类似于"Two-Pointers-2"这样的算法问题时，通常的做法是首先阅读题目要求，确定是否适合使用双指针技术。如果适合，接下来要确定指针的起始位置、移动条件以及最终的目标。在编码时，需要注意边界条件和特殊...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值