剑指Offer双指针

1. 剑指 Offer 18. 删除链表的节点

剑指 Offer 18. 删除链表的节点

思路：设置两个指针，一个指针最终指向待删除的节点cur，另外一个指针指向待删除节点的前一个节点pre，当找到待删除节点后,直接令pre.next=cur.next即可，注意特殊情况，当删除的节点是头节点时，直接返回head.next

class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        ListNode pre=head,cur=head;
        if(head.val==val)
            return head.next;
        while(cur!=null&&cur.val!=val)
        {   
            pre=cur;
            cur=cur.next;
        }
        pre.next=cur.next;
        return head;
    }
}
//O(n)
//O(1)

---

2. 剑指 Offer 22. 链表中倒数第k个节点

剑指 Offer 22. 链表中倒数第k个节点

思路：使用快慢指针，倒数第k个节点的编号是n-k+1（编号从1开始）,先将两个指针初始化指向head（1号节点）,快指针fast先走k步到达（k+1）号节点，也就是倒数第n-k个节点，之后两个指针一向前运动，fast指针再向前运动n-k步变成null,此时slow指针达到(1+n-k)也即倒数第k个节点

class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode fast=head,slow=head;
        for(int i=1;i<=k;i++)
            fast=fast.next;//快指针先走k步
          
        while(fast!=null)//快慢指针一起走
            {
                slow=slow.next;
                fast=fast.next;
             
            }
        return slow;
    }
}
//O(n)
//O(1)

---

3. 剑指 Offer 25. 合并两个排序的链表

剑指 Offer 25. 合并两个排序的链表

思路：使用双指针，分别指向链表1的头节点和链表2的头节点，然后遍历两个链表，并比较节点大小，取较小的节点连在我们事先创建的dummy节点后面，被取到的节点指针往后移动，未被取到的节点指针保持不动

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy=new ListNode(-1);//创建一个哑节点方便后面节点串起来
        ListNode cur=dummy;
        while(l1!=null&&l2!=null)
        {
            
            if(l1.val<l2.val)//l1当前节点值较小 取该节点
            {
                cur.next=l1;
                l1=l1.next;
            }
            else
            {
                cur.next=l2;
                l2=l2.next;
            }
            cur=cur.next;//cur指针往后移动
           
        }
        if(l1!=null)//l1不为null,则l2为null,直接将剩余部分的l1节点连上
            cur.next=l1;
        if(l2!=null)//l2不为null,则l1为null,直接将剩余部分的l2节点连
            cur.next=l2;
        return dummy.next;
    }
}
//O(n)
//O(1)

---

4. 剑指 Offer 52. 两个链表的第一个公共节点

剑指 Offer 52. 两个链表的第一个公共节点

思路：使用双指针，A指向headA,B指向headB,如果A不为null,则A=A.next,否则A=headB;B指向headB,如果B不为null,则B=AB.next,否则B=headA; 知道A==B时跳出循环

合理性： 先设headA所在链表长度为m,headB所在链表长度为n

1. 存在交点: 设公共部分长度为c,headA的非公共部分长度为a,headB的非公共部分长度为b

如果m==n,则a==b,这种情况下A指针和B指针移动a-1次（b-1）即可相遇

如果m!=n,则a!=b,这种情况下A移动a+c+b次 B移动b+c+a次 a+c+b==b+c+a 即可相遇

2. 不存在交点：

如果m==n,A和B运动m(n)次变成null,跳出循环

如果m!=n,A运动m+n次 B运动n+m次 二者变成null 跳出循环

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode A=headA,B=headB;
        while(A!=B)
        {
            A=A!=null?A.next:headB;
            B=B!=null?B.next:headA;
        
        }
        return A;
    }
}
//O(m+n)
//O(1)

---

5. 剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

思路：设置两个指针i，j，初始分别指向数组中的第一个元素和最后一个元素，i用于从前往后寻找在前半部分的偶数，j用于从后往前寻找在后半部分的奇数，只要找到在前面的偶数和一个在后面的奇数就将这两个数交换，如果全是奇数，最终是最后一个元素和自身交换，如果全是偶数，最终是第一个元素和自身交换，这两种情况不影响最终结果

class Solution {
    public int[] exchange(int[] nums) {
        int i=0,j=nums.length-1;
        while(i<=j)
        {
            //全是偶数，最终是第一个元素和自身交换
            while(i<j&&nums[j]%2==0)//寻找奇数
                    j--;   
            //全是奇数，最终是最后一个元素和自身交换
            while(i<j&&nums[i]%2==1)//寻找偶数
                i++;
            swap(nums,i,j);
                i++;//指向后一个元素
                j--;//指向前一个元素
        }
        return nums;
    }
    public void swap(int []nums,int i,int j)
    {  
        
        int tmp=nums[i];
        nums[i]=nums[j];
        nums[j]=tmp;
    }
}
//O(n)
//O(1)

---

6. 剑指 Offer 57. 和为s的两个数字

剑指 Offer 57. 和为s的两个数字

思路：先定义两个指针i,j分别第一个元素，由于数组元素是升序的，如果nums[i]+nums[j]<target，则令i++;如果nums[i]+nums[j]>target，则令j–;

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int i=0,j=nums.length-1;
        while(i<j)
        {
            int num=nums[i]+nums[j];
            if(num==target)
                return new int[]{nums[i],nums[j]};
            else if(num>target)
                j--;
            else if(num<target)
                i++;
        }
        return new int[]{};
    }
}
//O(n)
//O(1)

---

7. 剑指 Offer 58 - I. 翻转单词顺序

剑指 Offer 58 - I. 翻转单词顺序

思路1：先将字符串分成多个单词，然后用StringBuilder从后往前连接单词

class Solution {
    public String reverseWords(String s) {
        String str=s.trim();//去掉首尾空格
        String words[]=str.split(" ");
        StringBuilder sb=new StringBuilder();
        int j=words.length-1;
        while(j>=0)
        {  
            //因为存在多个空格 以空格划分数组中则会出现空串
            if(words[j].equals(""))
                {
                    j--;
                    continue;//空串直接跳过
                   
                }
            sb.append(words[j]+" ");
            j--;
        }
        return sb.toString().trim();//最后一个单词后面会多一个空格
        
    }
}
//O(n)
//O(1)

思路2：使用两个指针分别指向单词的开始和结束位置，然后使用substring()来截取单词添加到StringBuilder中

class Solution {
    public String reverseWords(String s) {
        s = s.trim(); // 删除首尾空格
        int j=s.length()-1,i=j;
        StringBuilder sb=new StringBuilder();
        while(i>=0)
        {
            //i指向单词开始的位置  j指向单词结束位置
            while(i>=0&&s.charAt(i)!=' ')//找到单词的开始位置
                i--;
            //上面的循环结束后i+1指向单词的开始位置 i指向空格
            //[i+1，j+1) substring截取的是左闭右开区间
            sb.append(s.substring(i+1,j+1)+" ");
            while(i>=0&&s.charAt(i)==' ')//剔除多余空格
                i--;
             //上面的循环结束后i指向单词的结束位置 
            j=i;//j指向下一个单词的最后一个字符位置 即j指向结束位置
        }
        return sb.toString().trim();
    }
}