LeetCode算法学习笔记 - Day1

最新推荐文章于 2024-05-31 17:17:25 发布

Warren Scofield

最新推荐文章于 2024-05-31 17:17:25 发布

阅读量798

点赞数

文章标签： leetcode 算法数据结构 java

本文链接：https://blog.csdn.net/PY_Warren/article/details/121872616

版权

Java删除排序数组中的重复项

给你一个有序数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

LeetCode高赞评论是这样的

    public int removeDuplicates(int[] A) {
        int count = 0;//重复的数字个数
        for (int right = 1; right < A.length; right++) {
            if (A[right] == A[right - 1]) {
                //如果有重复的，count要加1
                count++;
            } else {
                //如果没有重复，后面的就往前挪
                A[right - count] = A[right];
            }
        }
        //数组的长度减去重复的个数
        return A.length - count;
    }

作者：数据结构和算法
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2gy9m/?discussion=4Zkrel
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

我尝试着不使用int[]数组而使用ArrayList数组去进行去重

	public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(0);integers.add(0);
        integers.add(1);integers.add(1);
        integers.add(2);integers.add(2);
        integers.add(3);integers.add(3);
        integers.add(4);integers.add(5);
        integers.add(6);integers.add(7);
        integers.add(8);integers.add(8);
        for (int i = 1; i < integers.size(); i++) {
            if (integers.get(i).equals(integers.get(i-1))){
                integers.remove(i);
            }
        }
        System.out.println(integers.length);
    }

因为ArrayList内的数字不是从小到大挨着的，而去重方法需要把数字依次排序，所以如果ArrayList内的数字不是依次排序的话需要去排序一下
我最后出来的结果和高赞回到的结果有差异但达到了题目要求(去重+返回去重后的长度)

Java计算股票最大收益

给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

	public static int maxProfit(int[] prices){
        ArrayList<Integer> integers = new ArrayList<>();
        for (int i = 0; i < prices.length; i++) {
            integers.add(prices[i]);
        }
        int total = 0;
        for (int i = 0; i < integers.size(); i++) {
            if (i != integers.size() - 1){
                if (integers.get(i) < integers.get(i+1)){
                    total += integers.get(i+1) - integers.get(i);
                }
            }
        }
        return total;
    }
    
这题相对简单，解题思路是判断当前数字和下一个数字谁大，然后把总和加起来就是总体收益
不过代码比较累赘还可优化

Java旋转数组

给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数

	public void rotate(int[] nums, int k) {
        while (k > nums.length){
            k = k- nums.length;
        }
        int[] ints = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            if (i+1 <= k){
                ints[i] = nums[nums.length + i - k];
            }else {
                ints[i] = nums[i - k];
            }
        }
        for (int i = 0; i < ints.length; i++) {
            nums[i] = ints[i];
        }
    }

Java判断数组内是否存在重复元素

给定一个整数数组，判断是否存在重复元素。
如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

	public boolean containsDuplicate(int[] nums) {
        Arrays.sort(nums);
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] == nums[i-1]){
                return true;
            }
        }
        return false;
    }

Java返回只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

	public static int singleNumber(int[] nums) {
        Arrays.sort(nums);
        for (int i = 1; i < nums.length; i++) {
            if (i == nums.length-1){
                if (nums[i -1] != nums[i]){
                    return nums[i];
                }
            }else {
                if (nums[i+1] != nums[i] && nums[i-1] != nums[i]){
                    return nums[i];
                }
            }
        }
        return 0;
    }

这是自己写的方法（很累赘）
最优解是使用异或运算.如下：

	public int singleNumber(int[] nums) {
	    int reduce = 0;
	    for (int num : nums) {
	        reduce =  reduce ^ num;
	    }
	    return reduce;
	}

两个数组的交集 II

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出
现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

	public int[] intersect(int[] nums1, int[] nums2) {
	    ArrayList<Integer> integers = new ArrayList<>();
	    for (int i = 0; i < nums1.length; i++) {
	        for (int j = 0; j < nums2.length; j++) {
	            if (nums1[i] == nums2[j]){
	                nums2[j] = -1;
	                integers.add(nums1[i]);
	                break;
	            }
	        }
	    }
	    int[] nums = new int[integers.size()];
	    for (int i = 0; i < integers.size(); i++) {
	        nums[i] = integers.get(i);
	    }
	    return nums;
	}

使用两个循环获取两个数组中相同的数字并把它添加到外部的ArrayList中方便使用
(获取相同数字后需要把第二个数字的相同数字设置成-1避免后面的循环重复获取该数字|然后就要break避免比较后面的数字)
之后就把ArrayList内的数据遍历到int[]即可

Java加一

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位，数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
题目很迷啊很多人都看不懂.大概就是给定一个数组然后需要把数组遍历出来形成一个数字.再把这个数字+1然后再变为一个数组即可
下面看看我的写法：

	public static int[] plusOne(int[] digits) {
        ArrayList<String> stringArrayList = new ArrayList<>();
        String num = "";
        for (int i = 0; i < digits.length; i++) {
            num += digits[i];
        }
        BigInteger int_num = BigInteger.valueOf(Long.parseLong(num)+1);
        for (int i = 0; i < String.valueOf(int_num).length(); i++) {
            stringArrayList.add(String.valueOf(int_num).substring(i,i+1));
        }
        int[] ints = new int[stringArrayList.size()];
        for (int i = 0; i < stringArrayList.size(); i++) {
            ints[i] = Integer.parseInt(stringArrayList.get(i));
        }
        return ints;
    }

最后的返回结果是没问题的不过在LeetCode上不能运行（因为LeetCode编辑器没有BigInteger这个包）

下面看一个评论区高赞的写法

    public int[] plusOne(int[] digits) {
        int length = digits.length;
        for (int i = length - 1; i >= 0; i--) {
            if (digits[i] != 9) {
                //如果数组当前元素不等于9，直接加1
                //然后直接返回
                digits[i]++;
                return digits;
            } else {
                //如果数组当前元素等于9，那么加1之后
                //肯定会变为0，我们先让他变为0
                digits[i] = 0;
            }
        }
        //除非数组中的元素都是9，否则不会走到这一步，
        //如果数组的元素都是9，我们只需要把数组的长度
        //增加1，并且把数组的第一个元素置为1即可
        int temp[] = new int[length + 1];
        temp[0] = 1;
        return temp;
    }

作者：数据结构和算法
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2cv1c/?discussion=v8T8jK
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

Java移动0

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

	public void moveZeroes(int[] nums) {
	    int start = 0;
	    int all = 0;
	    for (int i = 0; i < nums.length; i++) {
	        if (nums[i] == 0){
	            all += 1;
	        }
	    }
	    while (start <= all){
	        start++;
	        for (int i = 0; i < nums.length; i++) {
	            if (nums[i] == 0 && i< nums.length-1){
	                int left = nums[i];
	                int right = nums[i+1];
	                nums[i] = right;
	                nums[i+1] = left;
	            }
	        }
	    }
	}

代码过于臃肿且耗时长.但还是能正确执行

还是看看人家的高赞回答吧

    public void moveZeroes(int[] nums) {
        if (nums == null || nums.length == 0)
            return;
        int index = 0;
        //一次遍历，把非零的都往前挪
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != 0)
                nums[index++] = nums[i];
        }
        //后面的都是0,
        while (index < nums.length) {
            nums[index++] = 0;
        }
    }

作者：数据结构和算法
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2ba4i/?discussion=AJ2rEF
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

Java两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

	public int[] twoSum(int[] nums, int target) {
        int[] ints = new int[2];
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums.length; j++) {
                if (nums[i] + nums[j] == target && i != j){
                    ints[0] = i;
                    ints[1] = j;
                    return ints;
                }
            }
        }
        return ints;
    }

代码运行依旧臃肿耗时长.还是来看看别人的高赞回答

    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> m = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (m.get(target - nums[i]) != null) {
                return new int[]{m.get(target - nums[i]), i};
            }
            m.put(nums[i], i);
        }
        return new int[]{0, 0};
    }

作者：数据结构和算法
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2jrse/?discussion=bsiO6a
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

有效的数独

这题实在不会做.题目也不放了该题网址

旋转图像

这题依旧不会做网址~

Warren Scofield

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode算法学习笔记 - Day1

Java删除排序数组中的重复项给你一个有序数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。LeetCode高赞评论是这样的 public int removeDuplicates(int[] A) { int count = 0;//重复的数字个数 for (int right = 1; right < A
复制链接

扫一扫