leetcode刷题报告5

最新推荐文章于 2023-02-16 13:06:33 发布

摸鱼の文酱

最新推荐文章于 2023-02-16 13:06:33 发布

阅读量1.7k

点赞数 6

分类专栏：算法刷题笔记文章标签： java

本文链接：https://blog.csdn.net/qq_53947552/article/details/123705533

版权

算法刷题笔记专栏收录该内容

57 篇文章 2 订阅

订阅专栏

本文详细介绍了使用C++和Java的库函数进行排序和搜索操作，包括快速排序、查找多数元素、检查数组是否存在重复元素、找到最大间距、按奇偶排序、找最小时间差和构建最大周长三角形等实际问题的解决方案。通过实例展示了如何高效地利用内置函数优化代码执行效率。

摘要由CSDN通过智能技术生成

📜个人简介

⭐️个人主页：摸鱼の文酱博客主页🙋‍♂️
🍑博客领域：java编程基础,mysql
🍅写作风格：干货,干货,还是tmd的干货
🌸精选专栏：【Java】【mysql】【算法刷题笔记】
🎯博主的码云gitee，平常博主写的程序代码都在里面。
🚀支持博主：点赞👍、收藏⭐、留言💬
🍭作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！

今日学习内容:排序APi

今天的学习内容是为了熟练使用c/java的库函数中的排序函数,以后会补齐对于其他排序算法的练习使用

今日刷题:

🎯912. 排序数组

题目描述:
给你一个整数数组 nums，请你将该数组升序排列。

🐾思路一:直接使用库函数

java:

public int[] sortArray(int[] nums) {
        Arrays.sort(nums);
        return nums;
    }

int cmp(const void*a, const void* b) {
    return *(int *)a - *(int *)b;             // (1)
}
int* sortArray(int* nums, int numsSize, int* returnSize){
    qsort(nums, numsSize, sizeof(int), cmp);  // (2)
    *returnSize = numsSize;                   // (3)
    return nums;                              // (4)
}

🎯169. 多数元素

问题描述:给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

🐾思路一:直接使用库函数

java

public int majorityElement(int[] nums) {
		int len = nums.length, half = len >> 1;
		while (true) {
			int index = (int) (Math.random() * len);
			int num = nums[index];
			int count = 0;
			for (int i = 0; i < len; i++) {
				count += nums[i] == num ? 1 : 0;
			}
			if (count > half) {
				return num;
			}
		}
	}

int cmp(const void *a, const void *b) {
    return (*(int *)a) - (*(int *)b);
}
int majorityElement(int* nums, int numsSize){
    qsort(nums, numsSize, sizeof(int), cmp);
    return nums[numsSize/2];                    // (1)
}

🎯217. 存在重复元素

问题描述:给你一个整数数组 nums 。如果任一值在数组中出现至少两次，返回 true ；如果数组中每个元素互不相同，返回 false 。

🐾思路一:直接使用库函数

java:set自带去重

public boolean containsDuplicate(int[] nums) {
        Set<Integer> res = new HashSet<Integer>();
        for(int i:nums)
            res.add(i);
        return res.size()<nums.length?true:false;
    }

int cmp(const void *a, const void *b) {
    return (*(int *)a) - (*(int *)b);
}

bool containsDuplicate(int* nums, int numsSize){
    int i;
    qsort(nums, numsSize, sizeof(int), cmp);
    for(i = 1; i < numsSize; ++i) {
        if(nums[i] == nums[i-1]) {    // (1)
            return true;
        }
    }
    return false;
}

🎯164. 最大间距

问题描述:给定一个无序的数组 nums，返回数组在排序之后，相邻元素之间最大的差值。如果数组元素个数小于 2，则返回 0 。

您必须编写一个在「线性时间」内运行并使用「线性额外空间」的算法。

🐾思路一:直接使用库函数

java:

  public int maximumGap(int[] nums) {
        Arrays.sort(nums);
        int max = 0;
        for (int i = 1; i < nums.length; i++) {
            max = Math.max(max, nums[i] - nums[i - 1]);
        }
        return max;
    }

int cmp(const void *a, const void *b) {
    return *(int *)a - *(int *)b;
}

int maximumGap(int* nums, int numsSize){
    int i, max = 0;
    qsort(nums, numsSize, sizeof(int), cmp);
    for(i = 1; i < numsSize; ++i) {
        if(nums[i] - nums[i-1] > max) {     // (1)
            max = nums[i] - nums[i-1];
        }
    }
    return max;
}

🎯905. 按奇偶排序数组

问题描述:给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。

你可以返回满足此条件的任何数组作为答案。

🐾思路一:直接使用库函数

java:

public int[] sortArrayByParity(int[] A) {
        Integer[] B = new Integer[A.length];
        for (int t = 0; t < A.length; ++t)
            B[t] = A[t];

        Arrays.sort(B, (a, b) -> Integer.compare(a%2, b%2));

        for (int t = 0; t < A.length; ++t)
            A[t] = B[t];
        return A;
    }

int Qua(int x) {
    return x & 1;
}

int cmp(const void *a, const void *b) {
    return Qua(*(int *)a) - Qua(*(int *)b);
}

int* sortArrayByParity(int* nums, int numsSize, int* returnSize){
    int i;
    int *ret = (int *)malloc( sizeof(int) * numsSize );  // (1)
    for(i = 0; i < numsSize; ++i) {
        ret[i] = nums[i];                                // (2)
    }
    qsort(ret, numsSize, sizeof(int), cmp);              // (3)
    *returnSize = numsSize;                              // (4)
    return ret;
}

🎯539. 最小时间差

问题描述:给定一个 24 小时制（小时:分钟 “HH:MM”）的时间列表，找出列表中任意两个时间的最小时间差并以分钟数表示。

🐾思路一:直接使用库函数

java

public int findMinDifference(List<String> timePoints) {
        Collections.sort(timePoints);
        int ans = Integer.MAX_VALUE;
        int t0Minutes = getMinutes(timePoints.get(0));
        int preMinutes = t0Minutes;
        for (int i = 1; i < timePoints.size(); ++i) {
            int minutes = getMinutes(timePoints.get(i));
            ans = Math.min(ans, minutes - preMinutes); // 相邻时间的时间差
            preMinutes = minutes;
        }
        ans = Math.min(ans, t0Minutes + 1440 - preMinutes); // 首尾时间的时间差
        return ans;
    }

    public int getMinutes(String t) {
        return ((t.charAt(0) - '0') * 10 + (t.charAt(1) - '0')) * 60 + (t.charAt(3) - '0') * 10 + (t.charAt(4) - '0');
    }

int cmp(const void *a, const void *b) {
    return *(int *)a - *(int *)b;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int findMinDifference(char ** timePoints, int timePointsSize){
    int *ret = (int *) malloc( sizeof(int) * timePointsSize );
    int i, ans = 1440;
    int a, b;
    for(i = 0; i < timePointsSize; ++i) {
        sscanf(timePoints[i], "%d:%d", &a, &b);             // (1)
        ret[i] = a * 60 + b;                                // (2)
    }
    qsort(ret, timePointsSize, sizeof(int), cmp);           // (3)
    for(i = 1; i < timePointsSize; ++i) {
        ans = min(ans, ret[i] - ret[i-1]);                  // (4)
    }
    ans = min(ans, ret[0] - ret[timePointsSize-1] + 1440);  // (5)
    return ans;
}

🎯976. 三角形的最大周长

问题描述:给定由一些正数（代表长度）组成的数组 nums ，返回由其中三个长度组成的、面积不为零的三角形的最大周长。如果不能形成任何面积不为零的三角形，返回 0。

🐾思路一:直接使用库函数

java:

public int largestPerimeter(int[] A) {
        Arrays.sort(A);
        for (int i = A.length - 1; i >= 2; --i) {
            if (A[i - 2] + A[i - 1] > A[i]) {
                return A[i - 2] + A[i - 1] + A[i];
            }
        }
        return 0;
    }

int cmp(const void *a, const void *b) {
    return *(int *)a - *(int *)b;
}

int largestPerimeter(int* nums, int numsSize){
    int i;
    qsort(nums, numsSize, sizeof(int), cmp);
    for(i = numsSize-1; i >= 2; --i) {
        if(nums[i-2] + nums[i-1] > nums[i]) {       // (1)
            return nums[i-2] + nums[i-1] + nums[i];
        }
    }
    return 0;
}

🎯976. 三角形的最大周长

问题描述: 给定由一些正数（代表长度）组成的数组 nums ，返回由其中三个长度组成的、面积不为零的三角形的最大周长。如果不能形成任何面积不为零的三角形，返回 0。

🐾思路一:直接使用库函数

java:

public int largestPerimeter(int[] A) {
        Arrays.sort(A);
        for (int i = A.length - 1; i >= 2; --i) {
            if (A[i - 2] + A[i - 1] > A[i]) {
                return A[i - 2] + A[i - 1] + A[i];
            }
        }
        return 0;
    }

int cmp(const void *a, const void *b) {
    return *(int *)a - *(int *)b;
}

int largestPerimeter(int* nums, int numsSize){
    int i;
    qsort(nums, numsSize, sizeof(int), cmp);
    for(i = numsSize-1; i >= 2; --i) {
        if(nums[i-2] + nums[i-1] > nums[i]) {       // (1)
            return nums[i-2] + nums[i-1] + nums[i];
        }
    }
    return 0;
}

🎯881. 救生艇

问题描述:给定数组 people 。people[i]表示第 i 个人的体重，船的数量不限，每艘船可以承载的最大重量为 limit。

每艘船最多可同时载两人，但条件是这些人的重量之和最多为 limit。

返回承载所有人所需的最小船数。

🐾思路一:直接使用库函数

java:

class Solution {
    public int numRescueBoats(int[] people, int limit) {
        int res = 0;
        int right = people.length - 1;
        int left = 0;
        Arrays.sort(people);
        while (left <= right) {
            if (left == right) {
                res++;      // 只剩下最后一个,直接一个走,结束
                break;
            }
            if (people[left] + people[right] > limit) {
                res++;
                right--;        // 先载最重的, 而且最小的也无法一起载,那么就最重的单独走
            }
            else {
                res++;
                right--;        // 最重的与最轻的一起走
                left++;
            }
        }
        return res;
    }
}

int cmp(const void *a, const void *b) {
    return *(int *)a - *(int *)b;
}

int numRescueBoats(int* people, int peopleSize, int limit){
    int i;
    int l = 0, r = peopleSize-1;
    int ans = 0;
    qsort(people, peopleSize, sizeof(int), cmp);     // (1)
    while(l <= r) {
        if(l == r) {
            ++ans; break;                            // (2)
        } else if(people[l] + people[r] > limit) {   // (3)
            ++ans, r--;
        } else                                       // (4)
            ++ans, ++l, --r;
    }
    return ans;
}