DAY5-力扣刷题

1.两两交换链表中的节点

24. 两两交换链表中的节点 - 力扣(LeetCode)

给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。

方法一:递归(不好想)

可以通过递归的方式实现两两交换链表中的节点。 

递归的终止条件是链表中没有节点,或者链表中只有一个节点,此时无法进行交换。

如果链表中至少有两个节点,则在两两交换链表中的节点之后,原始链表的头节点变成新的链表的第二个节点,原始链表的第二个节点变成新的链表的头节点。

链表中的其余节点的两两交换可以递归地实现。在对链表中的其余节点递归地两两交换之后,更新节点之间的指针关系,即可完成整个链表的两两交换。

class Solution {
    public ListNode swapPairs(ListNode head) {
        //递归完成的标志
        if(head==null||head.next==null){
            return head;
        }

        //假如有两个节点a,b
        ListNode newHead=head;
        head.next=swapPairs(newHead.next);
        newHead.next=head;
        return newHead;
    }
}

方法二:迭代 

也可以通过迭代的方式实现两两交换链表中的节点。

创建哑结点 dummyHead,令 dummyHead.next = head。令 temp 表示当前到达的节点,初始时 temp = dummyHead。每次需要交换 temp 后面的两个节点。

如果 temp 的后面没有节点或者只有一个节点,则没有更多的节点需要交换,因此结束交换。否则,获得 temp 后面的两个节点 node1 和 node2,通过更新节点的指针关系实现两两交换节点。

class Solution {
    public ListNode swapPairs(ListNode head) {
        //创建哑结点 dummyHead
        //先把哑结点添加到链表中
        ListNode dummyHead = new ListNode(0);
        dummyHead.next=head;
        ListNode temp=dummyHead;
        while(temp.next!=null&&temp.next.next!=null){
            ListNode node1=temp.next;
            ListNode node2=temp.next.next;
            temp.next=node2;
            node1.next=node2.next;
            node2.next=node1;
            temp=node1;
        }
        return dummyHead.next;
    }
}

 2.删除有序数组的重复项

26. 删除有序数组中的重复项 - 力扣(LeetCode)

给你一个 非严格递增排列 的数组 nums ,请你 原地 删除重复出现的元素,使每个元素 只出现一次 ,返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ,你需要做以下事情确保你的题解可以被通过:

  • 更改数组 nums ,使 nums 的前 k 个元素包含唯一元素,并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
  • 返回 k 。
class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums == null || nums.length == 0){
            return 0;
        }
        int i=0;
        int j=1;
        while(j<nums.length){
            if(nums[i] == nums[j]){
                j++;
            }else{
                i++;
                nums[i]=nums[j];
                j++;
            }
        }
        return i+1;
    }
}

3.移除元素

27. 移除元素 - 力扣(LeetCode)

给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k,要通过此题,您需要执行以下操作:

  • 更改 nums 数组,使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
  • 返回 k
class Solution {
    public int removeElement(int[] nums, int val) {
        int left=0;
        int right=nums.length;
        int count=0;
        while(left<right){
            if(nums[left]==val){
                nums[left]=nums[right-1];
                right--;
            }else{
                left++;
                count++;
            }
        }
        return count;
    }
}

 4.找出字符串第一个匹配的下标(重点)

28. 找出字符串中第一个匹配项的下标 - 力扣(LeetCode)

class Solution {
    public static int strStr(String haystack, String needle) {
        int count=needle.length();
        for(int i=0;i<haystack.length()-count+1;i++){
            System.out.println(haystack.substring(i,i+count));
            if(haystack.substring(i,i+count).equals(needle)){
                return i;
            }
        }
        return -1;
    }
}

但我们可以看出此时所费的时间很长

考虑另一种经典的算法

方法一:Knuth-Morris-Pratt 算法(经典的字符串匹配)

快速的从主串中找到相同串

KMP算法-超细超全讲解(上)原理篇_哔哩哔哩_bilibili(详细)

class Solution {
    public int strStr(String haystack, String needle) {
        int n = haystack.length(), m = needle.length();
        if (m == 0) {
            return 0;
        }
        int[] pi = new int[m];
        for (int i = 1, j = 0; i < m; i++) {
            while (j > 0 && needle.charAt(i) != needle.charAt(j)) {
                j = pi[j - 1];
            }
            if (needle.charAt(i) == needle.charAt(j)) {
                j++;
            }
            pi[i] = j;
        }
        for (int i = 0, j = 0; i < n; i++) {
            while (j > 0 && haystack.charAt(i) != needle.charAt(j)) {
                j = pi[j - 1];
            }
            if (haystack.charAt(i) == needle.charAt(j)) {
                j++;
            }
            if (j == m) {
                return i - m + 1;
            }
        }
        return -1;
    }
}

5.两数相除(重点)

29. 两数相除 - 力扣(LeetCode)

方法一:二分法

不用除法求解中位数的方法

class Solution {
    public int divide(int dividend, int divisor) {
        //考虑被除数作为最小值的情况
        if(dividend==Integer.MIN_VALUE){
            //divisor为除数
            if(divisor==1){
                return Integer.MIN_VALUE;
            }
            if(divisor==-1){
                return Integer.MAX_VALUE;
            }
        }
        //考虑除数为最小值(此时绝对值最大)的情况
        if(divisor==Integer.MIN_VALUE){
            return dividend==divisor?1:0;
        }
        //考虑被除数为0的情况
        //被除数➗除数
        if(dividend==0){
            return 0;
        }

        //上面是特殊情况
        //后续我们只需要考虑一般情况
        //一般情况,使用二分查找
        //将所有的正数取相反数,这样就只用考虑一种情况
        boolean rev=false;
        if(dividend>0){
            dividend=-dividend;
            rev=!rev;
        }
        if(divisor>0){
            divisor=-divisor;
            rev=!rev;
        }
        int left=1,right=Integer.MAX_VALUE,ans=0;
        while(left<=right){
            //注意溢出
            //不能使用除法
            int mid=left+(right-left)>>1;
            boolean check=quickAdd(divisor,mid,dividend);
            if(check){
                ans=mid;
                //注意溢出
                if(mid==Integer.MAX_VALUE){
                    break;
                }
                left=mid+1;
            }else{
                right=mid-1;
            }
        }
        return rev?-ans:ans;
        //rev本身是false
        //如果没改变,就证明原先就是俩负数,所得的结果是大于0
        //改变任意一个,结果都是负数,即true的时候,结果为-ans
    }
    //上述特殊情况
    //X和Y都是负数
    //根据除法以及余数的定义
    //1.我们首先直到暴力求解
    //X/Y可以进行分解
    //X-Y>Y,COUNT++
    //直到X-Y<Y时才证明除完了
    //我们将上述思想改成乘法的等价形式
    //Z*Y>=X>(Z+1)*Y
    //因此我们可以使用二分法得到Z,找出最大的Z使得上述不等式成立
    //快速乘
    public boolean quickAdd(int y,int z,int x){
        //x和y是负数,z是正数
        //被除数X➗除数Y
        //Z*X>=X是否成立
        int result=0,add=y;//y是除数
        while(z!=0){
            if((z&1)!=0){
                
                //需要保证result+add>=x
                //result<x-add意味着我们后续要把left,mid,right的范围画在原先的后部分
                //0<10-5
                //这就意味着前部分是不行的
                if(result<x-add){
                    return false;
                }
                result=result+add;
            }
            if(z!=1){
                //需要保证add+add>=x
                if(add<x-add){
                    return false;
                }
                add+=add;
            }
            //不能使用除法
            //二分法,求z的中间值
            z=z>>1;
        }
        return true;
        //true的时候,我们所对应的范围是原来范围的前部分
    }
    
}

方法二:类二分法

class Solution {
    public int divide(int dividend, int divisor) {
        // 考虑被除数为最小值的情况
        if (dividend == Integer.MIN_VALUE) {
            if (divisor == 1) {
                return Integer.MIN_VALUE;
            }
            if (divisor == -1) {
                return Integer.MAX_VALUE;
            }
        }
        // 考虑除数为最小值的情况
        if (divisor == Integer.MIN_VALUE) {
            return dividend == Integer.MIN_VALUE ? 1 : 0;
        }
        // 考虑被除数为 0 的情况
        if (dividend == 0) {
            return 0;
        }
        
        // 一般情况,使用类二分查找
        // 将所有的正数取相反数,这样就只需要考虑一种情况
        boolean rev = false;
        if (dividend > 0) {
            dividend = -dividend;
            rev = !rev;
        }
        if (divisor > 0) {
            divisor = -divisor;
            rev = !rev;
        }

        List<Integer> candidates = new ArrayList<Integer>();
        candidates.add(divisor);
        int index = 0;
        // 注意溢出
        while (candidates.get(index) >= dividend - candidates.get(index)) {
            candidates.add(candidates.get(index) + candidates.get(index));
            ++index;
        }
        int ans = 0;
        for (int i = candidates.size() - 1; i >= 0; --i) {
            if (candidates.get(i) >= dividend) {
                ans += 1 << i;
                dividend -= candidates.get(i);
            }
        }

        return rev ? -ans : ans;
    }
}

  • 29
    点赞
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值