LeetCode双指针经典题（一）15道

最新推荐文章于 2024-04-07 11:19:09 发布
最新推荐文章于 2024-04-07 11:19:09 发布
阅读量1.5k 收藏 8
点赞数 1
分类专栏： LeetCode 文章标签： 算法 双指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43478694/article/details/124465496
版权

文章目录

905. 按奇偶排序数组

https://leetcode-cn.com/problems/sort-array-by-parity/
在这里插入图片描述

使用两个指针，第一个指针从前往后寻找奇数，第二个指针从后往前寻找偶数，找到了就交换，然后分别继续往前往后寻找，直到两个指针相遇

class Solution {
    public int[] sortArrayByParity(int[] nums) {
        int n=nums.length;
        int i=0,j=n-1;
        while(i<j)
        {
            while(i<n&&nums[i]%2==0)//找到前面的奇数
                i++;
            while(j>=0&&nums[j]%2==1)//找到后面的偶数
                j--;
            if(i>=j)//寻找完毕
                break;
            int tmp=nums[i];//交换
            nums[i]=nums[j];
            nums[j]=tmp;
            i++;
            j--;
        }
        return nums;
    }
}
//O(n)
//O(1)

5. 最长回文子串

https://leetcode-cn.com/problems/longest-palindromic-substring/
在这里插入图片描述

思路：中心拓展法 枚举中心点，然后向两侧拓展 如果两侧指针指向的字符不相等 则停止拓展 中心点可能是1个,比如aba这种以b作为中心点，也可能是2个，比如abba这种以bb为中心点，因此一共有n个单个字符中心点，n-1个双字符中心点（一共2n-1种情况）不需要3字符和4字符中心点，因为它们分别可以从单字符和双字符拓展得到

class Solution {
    public String longestPalindrome(String s) {
        int maxLen=0,n=s.length();
        int start=0;
        for(int i=0;i<2*n-1;i++)
        {
            //i为偶数时  left=right  单中心点
            //i为奇数时  right=left+1  双中心点
            int left=i/2,right=left+i%2;
            while(left>=0&&right<n&&s.charAt(left)==s.charAt(right))
            {
            
                int len=right-left+1;
                if(len>maxLen)//更新最大长度
                {
                    maxLen=len;
                    start=left;//更新起点
                }
                left--;
                right++;    
            }
        } 
        return s.substring(start,start+maxLen);//起点+最大长度确定最长回文子串
    }
}
//O(n)
//O(1)

11. 盛最多水的容器

https://leetcode-cn.com/problems/container-with-most-water/
在这里插入图片描述

思路：假设左边的线的高度为h1,右边的线的高度为h2, 那么由这两条线所形成的容器可以容纳的水的体积为:min(h1,h2)*(j-i) 即水的体积由短板决定 那么如果继续移动长板，假设h1>h2, h1增加的话，水的体积不变; h1减小的话，水的体积可能减小也可能不变； 移动h2的话，h2增加水的体积增加；h2减小的话，水的体积减小； 所以要想水的体积增大，只有一种可能，就是移动h2(短板)
所以每次移动短板获得新的水的体积，不断更新最大值即可（贪唯一的增加可能性）

class Solution {
    public int maxArea(int[] height) {
        int left=0,right=height.length-1;
        int ans=0;
        while(left<right)
        {
            if(height[left]>height[right])
            {
                ans=Math.max(ans,(right-left)*height[right]);
                right--;
            }
            else
            {
                ans=Math.max(ans,(right-left)*height[left]);
                left++;
            }
        }
        return ans;
    }
}
//O(n)
//O(1)

15. 三数之和

https://leetcode-cn.com/problems/3sum/
在这里插入图片描述

思路：先对数组按升序排序，排序的好处： 记第一个元素为nums[first], 当nums[first]>0时，则说明后面的元素都大于0，不可能形成a+b+c=0的情况，此时结束循环；相等的元素一定连续在一起，这样利于去重。 具体思路：先固定第一个元素的下标first, first的范围为[0,n-2], 然后需要寻找的目标就是-nums[first], 照nums[second]+nums[third]=target时，可以采用双指针法，left从前往后遍历，right从后往前遍历, 二者之和分为以下3种情况：

  1. num[left]+nums[right]=target 找到 添加一个三元组到答案中 left++ right-- 同时进行去重操作
  2. num[left]+nums[right]>target 此时right应该左移 使得整体变小
  3. num[left]+nums[right]<target 此时left应该右移 使得整体变大
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ans=new ArrayList<>();
        if(nums.length<3)
            return ans;
        int n=nums.length;
        Arrays.sort(nums);
        for(int first=0;first<n-2;first++)
        {
            if(nums[first]>0)//后面的元素都大于0了
                break;
            if(first>=1&&nums[first]==nums[first-1])//-1 -1 -1 ....只需要以第一个-1开头就行了
                continue;
            int target=-nums[first];
            int left=first+1,right=n-1;
            while(left<right)
            {
               
                if(nums[left]+nums[right]==target)
                {
                   
                    List<Integer> tmp=new ArrayList<>();
                    tmp.add(nums[first]);
                    tmp.add(nums[left]);
                    tmp.add(nums[right]);
                    ans.add(tmp);
                    left++;
                    right--;
                    while(left<right&&nums[left]==nums[left-1])//-2 0 0 2 2 排除这种重复的情况
                        left++;
                    while(left<right&&nums[right]==nums[right+1])//-2 0 0 2 2 排除这种重复的情况
                        right--;
                    //-2 0 0 2 2只需要一个-2 0 2 当nums[first]=-2  nums[left]=nums[1]=0  nums[right]=nums[4]=2
                    //此时满足条件  但是需要排除后面和nums[left]以及nums[right]相等的连续元素

                }
                else if(nums[left]+nums[right]<target)
                    left++;
                else if(nums[left]+nums[right]>target)
                    right--;
            }
        }
        return ans;
    }
}
//O(n^2)
//O(logn)  排序的空间复杂度

31. 下一个排列

https://leetcode-cn.com/problems/next-permutation/
在这里插入图片描述

思路： 想要获取下一个排列，要进行以下3步（以2 3 1 为例）

  1. 从后往前寻找到a[i] 使得a[i]<a[i+1] 对应例子中a[i]=2 这样使得a[i+1]…a[n-1]都是非递增的
  2. 在区间[i+1,n-1]内从后往前寻找第一个a[j],使得a[j]>a[i] 对应例子中a[j]=3
  3. 交换a[i]和a[j] 由于a[i+1,n-1]本身就是非递增的了 交换之后该区间还是递减的
  4. 翻转a[i+1,n-1]区间内的元素 这样就使得该区间内的元素由递减变成递增的， 相对序较小

ps: 特殊情况，当例子为3 2 1时，会发现第1步中找到的i=-1, 因此直接进行第4步，翻转[0,2]区间，即翻转所有元素，这与直接的观察结果也符合

class Solution {
    public void nextPermutation(int[] nums) {
        int n=nums.length;
        int i=n-2;
        while(i>=0&&nums[i]>=nums[i+1])//不能改成nums[i]>nums[i+1]
            i--;
        if(i>=0)
        {
            int j=0;
            for(j=n-1;j>=i+1;j--)
            {
                if(nums[j]>nums[i])
                    break;
            }
            swap(nums,i,j);
        }
        reverse(nums,i+1,n-1);
    }
    public void swap(int[] nums,int i,int j)
    {
        int tmp=nums[i];
        nums[i]=nums[j];
        nums[j]=tmp;
    }
    public void reverse(int[] nums,int i,int j)
    {
        while(i<j)
        {
            swap(nums,i,j);
            i++;
            j--;
        }
    }
}
//O(n)
//O(1)

160. 相交链表

https://leetcode-cn.com/problems/intersection-of-two-linked-lists/
在这里插入图片描述
思路：先使用两个指针pA pB分别指向headA headB 当pA!=pB时 如果A链表没有遍历完，pA往后走一步，如果A遍历完了，就让pA指向headB, 从B链表的头部开始移动； 对于headB同理
在这里插入图片描述

392. 判断子序列

https://leetcode-cn.com/problems/is-subsequence/
在这里插入图片描述
思路：这里要求的是子序列，不是连续子序列，设置两个指针i,j分别扫描s和t, 具体做法为，当s[i]==t[j]时，i++, 而j一直往后走，如果最后i==s.length() 则匹配成功

class Solution {
    public boolean isSubsequence(String s, String t) {
        int i=0,j=0;
        int m=s.length(),n=t.length();
        while(i<m&&j<n)
        {
            if(s.charAt(i)==t.charAt(j))
                i++;
            j++;
        }
        return i==m;
    }
}
//O(m+n)
//O(1)

进阶问题： 预处理出对于 t的每一个位置，从该位置开始往后每一个字符第一次出现的位置

构造一个dp数组dp[i][j]: 表示从t中的位置i开始字符第一次出现的位置
d p [ i ] [ j ] = { i , if  t [ i ] = = j d p [ i + 1 ] [ j ] , if  t [ i ] ! = j   dp[i][j] = \begin{cases} i, & \text{if $t[i]==j$} \\ dp[i+1][j], & \text{if $t[i]!=j$ } \\ \end{cases} dp[i][j]={i,dp[i+1][j],​if t[i]==jif t[i]!=j ​

如果在t中，i位置上面的字符就是j, 即t[i]==j 则dp[i][j]=j
如果不是， j 出现在位置 i+1 开始往后，即dp[i+1][j]

class Solution {
    public boolean isSubsequence(String s, String t) {
       
        int m=s.length(),n=t.length();
        int [][] dp=new int[n+1][26];//只有26个小写字母
        for(int i=0;i<26;i++)
            dp[n][i]=n;//t中的位置是[0,n-1] n位置额外腾出来表示不存在 
        //dp[i][j]=dp[i+1][j] 这样当t[n-1]!=j 时 dp[n-1][j]=dp[n][j]=n 表示n-1位置往后不存在字符j
        for(int i=n-1;i>=0;i--)//从后到前处理dp数组 因为当前位置的情况依赖于后面的
        {
            for(int c=0;c<26;c++)
            {
                if(t.charAt(i)==c+'a')
                    dp[i][c]=i;
                else
                    dp[i][c]=dp[i+1][c];
            }
        }
        int index=0;
        //s串是否是t串的子序列
        //m=s.length()  n=t.length()
        for(int i=0;i<m;i++)
        {
           
            int c=s.charAt(i)-'a';
            if(dp[index][c]==n)
                return false;//s中的字符c在t中不会出现 则可以判断不是子序列
            index=dp[index][c]+1;//c在t中出现的位置是dp[index][c]  所以s中的下一个字符和dp[index][c]比较
        }
        return true;

    }
}
//O(n*26+m)
//O(26*n)

26. 删除有序数组中的重复项

https://leetcode-cn.com/problems/remove-element/
在这里插入图片描述
在这里插入图片描述
思路：题目要求原地修改数值，最后返回的是数组的长度，可以使用两个指针，一个指针先固定在某个元素x，另外一个指针从元素x的下一个元素开始往后遍历，直到遇到一个元素y,y!=x, 然后将y放在x的下一个位置即可，重复这个过程，直到right指针遍历完数组

class Solution {
    public int removeDuplicates(int[] nums) {
        int left=0,right=1,n=nums.length;
        if(n==0)
            return 0;
        while(right<n){
           
            if(nums[right]!=nums[left])
            {
                nums[left+1]=nums[right];
                left++;   
            }
            right++;
        }
        return left+1;
    }
}
//O(n)
//O(1)

27. 移除元素

在这里插入图片描述

在这里插入图片描述
思路：所以双指针，一个left指针指向当前构造出的新数组的最后一个元素，一个right指针往后寻找和val不等的元素，找到后就将该元素放置在left` 的位置上面

class Solution {
    public int removeElement(int[] nums, int val) {
        int left=0,right=0,n=nums.length;
        while(right<n){
            //right往后寻找和val不等的元素
            if(nums[right]!=val){
                nums[left]=nums[right];
                left++;
            }
            right++;
        }
        return left;//返回新数组的长度
        
    }
}
//o(n)
//O(1)

83. 删除排序链表中的重复元素

https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/
在这里插入图片描述
思路：先使用一个指针left指向当前头节点，然后另外一个指针right往后寻找和left节点的值不一样的节点，找到后将right指向的节点连接在left节点后面，然后使left指向right, 继续上述过程； 最后left指向尾结点，需要断开left和后面重复节点的连接

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head==null)
            return null;
        ListNode left=head,right=head;
        while(right!=null){
            if(right.val!=left.val){//right指向的节点和left指向的节点值不同
                left.next=right;//right节点连接到left上
                left=right;//left更新为right
            }
            right=right.next;
        }
        left.next=null;//断开后面重复的连接
        return head;

    }
}
//O(n)
//O(1)

283. 移动零

https://leetcode-cn.com/problems/move-zeroes/
在这里插入图片描述
思路：使用right和left两个指针，left指针指向已处理的左边的最后一个非0元素，right则往后寻找非0元素，当right找到了非0元素，分为2种情况：

  1. left=right 说明此时right遇到的都是非0元素 不用处理
  2. left!=right 则nums[left]=nums[right] nums[right]=0
class Solution {
    public void moveZeroes(int[] nums) {
        int n=nums.length;
        int left=0,right=0;
        while(right<n){
            if(nums[right]!=0)
            {
                if(right!=left){
                    nums[left]=nums[right];//把非0元素放到left位置上
                    nums[right]=0;//right位置上面放0
                }
                left++;//left=right&&nums[right]！=0 不用交换
            }
            right++;
        }
    }
}
//O(n)
//O(1)

986. 区间列表的交集

https://leetcode-cn.com/problems/interval-list-intersections/
在这里插入图片描述
在这里插入图片描述
思路：对于两个区间，先获得两个区间左边界中的较大值，右边界中的较小值，如果这个较大值<=较小值，说明有交集，将该交集加入答案中，另外比较完当前区间后，需要移动右边界较小的区间，因为该区间不会和自己的区间列表内的元素有交集，也不会和另外一个区间列表的下一个区间有交集

class Solution {
    public int[][] intervalIntersection(int[][] firstList, int[][] secondList) {
        int n1=firstList.length,n2=secondList.length;
        ArrayList<int[]> ans=new ArrayList<>();
        if(n1==0||n2==0)
             return ans.toArray(new int[ans.size()][]);
        int i=0,j=0;
        while(i<n1&&j<n2){
            int start=Math.max(firstList[i][0],secondList[j][0]);
            int end=Math.min(firstList[i][1],secondList[j][1]);
            if(start<=end){
                ans.add(new int[]{start,end});
            }
            if(firstList[i][1]<secondList[j][1])//移动结束较早的区间
                i++;
            else
                j++;
        }
        return ans.toArray(new int[ans.size()][]);
    }
}
//O(m+n)
//O(m+n)

870. 优势洗牌

https://leetcode-cn.com/problems/advantage-shuffle/
在这里插入图片描述
思路：类似于田忌赛马，将A中元素升序，B中元素降序，当A中的最大元素可以打败B中的最大元素时，则二者匹配；否则，用A中的最小元素来和B中的最大元素匹对

class Solution {
    public int[] advantageCount(int[] nums1, int[] nums2) {
        PriorityQueue<int[]> pq=new PriorityQueue<>((a,b)->b[1]-a[1]);//降序 堆顶元素最大
        for(int i=0;i<nums2.length;i++){
            pq.offer(new int[]{i,nums2[i]});
        }
        Arrays.sort(nums1);//升序
        int[] ans=new int[nums1.length];
        int left=0,right=nums1.length-1;//left指向最小元素 right指向最大元素
        while(!pq.isEmpty()){
            int[] tmp=pq.poll();
            int index=tmp[0],maxVal=tmp[1];
            if(nums1[right]>maxVal){//A中最大>B中最大
                ans[index]=nums1[right];
                right--;
            }else{
                ans[index]=nums1[left];//A中目前最小-B中目前最大
                left++;
            }
        }
        return ans;
    }
}
//O(nlogn)
//O(n)

18. 四数之和

https://leetcode-cn.com/problems/4sum/
在这里插入图片描述
思路：类似于15. 三数之和，先对数组进行排序，方便去重，一段连续相同的数字只取第一个，然后先固定住第一个数字和第二个数字，对于第3个数字和第4个数字可以使用双指针的方法求解，在求解第3个数字和第4个数字的时候也需要去重

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> ans=new ArrayList<>();
        int n=nums.length;
        for(int a=0;a<n-3;a++){
            while(a>0&&a<n-3&&nums[a-1]==nums[a])//去重
                a++;
            for(int b=a+1;b<n-2;b++){
                while(b>a+1&&b<n-2&&nums[b-1]==nums[b])//去重
                    b++;
                int left=b+1,right=n-1;
                int val=target-nums[a]-nums[b];
                while(left<right){
                    if(nums[left]+nums[right]==val){//找到1个答案
                        List<Integer> tmp=new ArrayList<>();
                        tmp.add(nums[a]);
                        tmp.add(nums[b]);
                        tmp.add(nums[left]);
                        tmp.add(nums[right]);
                        ans.add(tmp);
                        left++;
                        right--;
                        while(left<right&&nums[left]==nums[left-1])//去重
                            left++;
                        while(left<right&&nums[right]==nums[right+1])//去重
                            right--;
                    }
                    else if(nums[left]+nums[right]<val)//和偏小 left++
                        left++;
                    else if(nums[left]+nums[right]>val)//和偏大 right--
                        right--;
                }
            }
               
        }
        return ans;


    }
}
//O(n^3)
//O(nlogn)

821. 字符的最短距离

https://leetcode-cn.com/problems/shortest-distance-to-a-character/
在这里插入图片描述

思路：两遍扫描，第一遍求出每个字符距离左边最近的c的距离，第二次扫描遍历每个字符距离右边最近的c的距离，取二者中的较小值即可

class Solution {
    public int[] shortestToChar(String s, char c) {
        int n=s.length();
        int[] ans=new int[n];
        Arrays.fill(ans,n+2);
        int j=-1;
        for(int i=0;i<n;i++){
            if(s.charAt(i)==c)
                j=i;
            if(j!=-1)
                ans[i]=Math.min(ans[i],i-j);
        }
        j=-1;
        for(int i=n-1;i>=0;i--){
            if(s.charAt(i)==c)
                j=i;
            if(j!=-1)
                ans[i]=Math.min(ans[i],j-i);
        }
        return ans;
    }
}
//O(n)
//O(1)
CodePanda@GPF
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Leetcode各种题型题目+思路+代码（共176道题及答案）
muli522的博客
05-16 4万+
文章目录 第一章：Leetcode 每日很多题 1、Leetcode-1047 删除字符串中的所有相邻重复项 2、剑指 Offer 53 - I. 在排序数组中查找数字 I 3、Leetcode704:二分查找 4、 Leetcode 227：基本计算器II 5、leetcode 224：基本计算器(带括号的计算) 6、Leetcode 15：三数之和：排序+双指针 7、剑指 offer 38.字符串的排列 8、Leetcode409：最长回文串 9、Leetcode 331：验证二叉树的前序序列化 10、
Leetcode题库(21-40)
qq_50402133的博客
04-19 651
Leetcode题库(21-40)
C++力扣Leetcode算法2--双指针
最新发布
m0_62037584的博客
04-07 814
双指针遍历方向相同且不相交，称为滑动窗口，通常用于区间搜索双指针遍历方向相反，用来搜索，待搜数组通常是排好序的指针函数，返回类型是指针的函数函数指针，指向函数的指针快慢指针通常用于链表环，一个指针走一步，一个指针走两步，快指针走到尽头就是没环路，走到第一次相遇，快指针从头走，走一步，第二次相遇，就是环点。
Leetcode 算法题合集
19年的墨先生的博客
07-29 2399
Leetcode 算法
Leetcode 热门题目100道每日一题
weixin_47964837的博客
10-29 2212
leetcode
LeetCode：数组刷题（17道经典题目）
一起加油~
03-22 2874
列出了一些关于数组的经典题目，并提供了对应的题解。主要是用C++实现的。对于使用其他语言的童鞋，可以很好的迁移过去。
java-leetcode面试题解双指针之第15题三数之和.zip
03-25
java java_leetcode面试题解双指针之第15题三数之和
java-leetcode面试题解双指针之第925题长按键入.zip
03-25
java java_leetcode面试题解双指针之第925题长按键入
java-leetcode面试题解双指针之第42题接雨水.zip
03-25
java java_leetcode面试题解双指针之第42题接雨水
java-leetcode面试题解双指针之第344题反转字符串.zip
03-25
java java_leetcode面试题解双指针之第344题反转字符串
java-leetcode面试题解双指针之第125题验证回文串.zip
03-25
java java_leetcode面试题解双指针之第125题验证回文串
leetcode题库
Fddadd的博客
09-08 920
原题链接 2、dict集合（哈希表）解法 Java解法 1、暴力解法 2、HashMap集合（哈希表）解法
LeetCode算法题整理(200题左右)
qq_38253797的博客
10-18 1万+
Leetcode
200道大数据面试常考Leetcode算法题01-05（python带代码解析）
guihua55的博客
07-19 2404
import java.sql.*; import java.sql.SQLException; public class HivetoMySQL { private static String driverName = "org.apache.hive.jdbc.HiveDriver"; private static String driverName_mysql = "com.mysql.jdbc.Driver"; public static void main(Strin..
leetcode - 103道入门基础题
seaalan的博客
11-22 1663
一、leetcode - 字符串 二、leetcode - 二进制、数学类 三、leetcode - 数组 四、leetcode - 二分查找 五、leetcode - 快慢指针 六、leetcode - 滑动窗口 七、leetcode - 矩阵 八、leetcode - 栈和队列 九、leetcode - 链表 十、leetcode - 二叉树 十一、leetcode - 并查集 十二、leetcode - 回溯 十三、leetcode - 动态规划 十四、leetcode - 贪心 一、leetcode
LeetCode数据库题库合集
hard_days的博客
09-14 1466
组合两个表表: Person| 列名 | 类型 |personId 是该表的主键列。该表包含一些人的 ID 和他们的姓和名的信息。表: Address| 列名 | 类型 |addressId 是该表的主键列。该表的每一行都包含一个 ID = PersonId 的人的城市和州的信息。编写一个SQL查询来报告 Person 表中每个人的姓、名、城市和州。
LeetCode数据库题目汇总一（附答案）
悦分享
02-14 1016
表: `Queue````person_id 是这个表的主键。该表展示了所有等待电梯的人的信息。表中 person_id 和 turn 列将包含从 1 到 n 的所有数字，其中 n 是表中的行数。```电梯最大载重量为 **1000**。写一条 SQL 查询语句查找最后一个能进入电梯且不超过重量限制的 `person_name`。题目确保队列中第一位的人可以进入电梯。查询结果如下所示 :```Queue 表。
Leetcode题目讲解汇总（持续更新）
热门推荐
qq_32865355的博客
09-07 1万+
[Leetcode1] Two Sum(两数之和) 题目： Given an array of integers, return indices of the two numbers such that they add up to a specific target. You may assume that each input would have exactly one solutio...
LeetCode题目精选
qq_25127933的博客
10-14 603
一、Leetcode题精选 1. 两数之和 要求：空间复杂度O(n)，时间复杂度O(nlogn) 牛客网返回数字位置从1开始 import java.util.*; public class Solution { /** * * @param numbers int整型一维数组 * @param target int整型 * @return int整型一维数组 */ public int[] twoSum (int[]...
leetcode 第一题怎么做
09-17
### 回答1： LeetCode 的第一题是 Two Sum。题目描述是：给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。 解法： 1. 暴力枚举法：对于每一个数，遍历整个数组，找到另一个数使得它们的和为 target。时间复杂度为 O(n^2)。 2. Hash 表法：遍历数组，对于每一个数，用 target 减去该数，判断差值是否在数组中出现过，如果出现过就返回该数的下标和差值的下标。时间复杂度为 O(n)。 在 LeetCode 中，你可以使用任意一种方法来解决该题。 ### 回答2： leetcode第一题是要求找出数组中两个数的和等于给定目标数的索引。可以使用哈希表来解决这个问题。 首先，我们可以创建一个空的哈希表。然后，遍历整个数组，对于每一个元素，计算目标数减去当前元素的差值。接着，我们检查差值是否在哈希表中，如果存在，说明当前元素与差值的和等于目标数。我们可以直接返回当前元素和差值在哈希表中的索引。 如果差值不在哈希表中，我们将当前元素及其索引插入哈希表中，以便之后可以通过差值来找到当前元素的索引。遍历完成后，如果没有找到满足条件的索引，返回一个空数组或者其他指定的结果。 使用哈希表的解决方案可以将查找的时间复杂度降低到O(1)。整个算法的时间复杂度为O(n)，其中n为数组的长度。算法的空间复杂度为O(n)，因为需要额外的哈希表来存储元素及其索引。 总结起来，leetcode第一题可以通过使用哈希表来解决，其中遍历数组并将元素及其索引存储在哈希表中，然后查找差值是否在哈希表中，找到满足条件的索引并返回。这个解决方案的时间复杂度为O(n)，空间复杂度为O(n)。 ### 回答3： LeetCode是一个在线的编程题库，第一题是非常简单的算法题。这个题目要求我们在一个整数数组中找到两个数，使得它们的和等于目标数。解决这个问题有几种方法。 一种简单的方法是使用双重循环来遍历数组中的每一对数，然后判断它们的和是否等于目标数。这样的时间复杂度是O(n^2)，不是很高效。 另一种更优化的方法是使用哈希表。我们可以遍历一遍数组，将每个数与目标数的差值作为键，对应的索引作为值存放在哈希表中。然后再次遍历数组，每次都判断当前数在哈希表中是否存在，如果存在则说明找到了满足条件的两个数。这种方法的时间复杂度是O(n)，空间复杂度也是O(n)。 还有一种更巧妙的方法是使用双指针。我们可以设置两个指针，一个指向数组的起始位置，一个指向数组的末尾位置，然后通过移动指针来逐渐缩小搜索范围。如果指针所指的两个数的和等于目标数，则找到了答案；如果和小于目标数，则将左指针右移一位；如果和大于目标数，则将右指针左移一位。这种方法的时间复杂度也是O(n)，但空间复杂度是O(1)，比哈希表方法更节省空间。 总之，这个题目虽然很简单，但是解决的方法有多种。根据题目要求和具体情况，我们可以选择适合的方法来解决这个问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CodePanda@GPF

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值