力扣面试题（七）

峰巢

已于 2024-08-02 15:47:31 修改

阅读量1k

点赞数 24

分类专栏：力扣笔试题文章标签： leetcode 算法

于 2024-08-01 17:00:00 首次发布

本文链接：https://blog.csdn.net/huoyunfeng13579/article/details/140851968

版权

力扣笔试题专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1、找到最高海拔

有一个自行车手打算进行一场公路骑行，这条路线总共由 n + 1 个不同海拔的点组成。自行车手从海拔为 0 的点 0 开始骑行。

给你一个长度为 n 的整数数组 gain ，其中 gain[i] 是点 i 和点 i + 1 的 净海拔高度差（0 <= i < n）。请你返回 最高点的海拔 。

示例 1：
输入：gain = [-5,1,5,0,-7]
输出：1
解释：海拔高度依次为 [0,-5,-4,1,1,-6] 。最高海拔为 1 。

思路：

根据题解是a[0] = 0; 所以接下来就知道a[1]、a[2] .....

int largestAltitude(int* gain, int gainSize) {
    int max = 0;
    int sum = 0;

    for(int i = 0; i < gainSize; i++){
        sum += gain[i];
        if(max < sum){
            max = sum;
        }
    }

    return max;
}

2、寻找数组的中心下标

给你一个整数数组 nums ，请计算数组的 中心下标 。

数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。

如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。

如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 -1 。

示例 1：
输入：nums = [1, 7, 3, 6, 5, 6]
输出：3
解释：
中心下标是 3 。
左侧数之和 sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11 ，
右侧数之和 sum = nums[4] + nums[5] = 5 + 6 = 11 ，二者相等。
示例 2：
输入：nums = [1, 2, 3]
输出：-1
解释：
数组中不存在满足此条件的中心下标。
示例 3：
输入：nums = [2, 1, -1]
输出：0
解释：
中心下标是 0 。
左侧数之和 sum = 0 ，（下标 0 左侧不存在元素），
右侧数之和 sum = nums[1] + nums[2] = 1 + -1 = 0 。

思路：

先将所有的值进行加和，然后从最左边找，如果不相等，则左边数组求和，直到相等

int pivotIndex(int* nums, int numsSize) {
    int totalSum = 0;
    int leftSum = 0;

    // Calculate the total sum of the array
    for (int i = 0; i < numsSize; ++i) {
        totalSum += nums[i];
    }

    // Iterate through the array to find the pivot index
    for (int i = 0; i < numsSize; ++i) {
        // If leftSum equals the total sum minus leftSum minus the current element,
        // then we have found the pivot index
        if (leftSum == (totalSum - leftSum - nums[i])) {
            return i;
        }
        // Add the current element to the leftSum for the next iteration
        leftSum += nums[i]; }

    // If no pivot index is found, return -1
    return -1;
}

3、找出两数组的不同

给你两个下标从 0 开始的整数数组 nums1 和 nums2 ，请你返回一个长度为 2 的列表 answer ，其中：

answer[0] 是 nums1 中所有不存在于 nums2 中的不同整数组成的列表。
answer[1] 是 nums2 中所有不存在于 nums1 中的不同整数组成的列表。

注意：列表中的整数可以按任意顺序返回。

示例 1：
输入：nums1 = [1,2,3], nums2 = [2,4,6]
输出：[[1,3],[4,6]]
解释：
对于 nums1 ，nums1[1] = 2 出现在 nums2 中下标 0 处，然而 nums1[0] = 1 和 nums1[2] = 3 没有出现在 nums2 中。因此，answer[0] = [1,3]。
对于 nums2 ，nums2[0] = 2 出现在 nums1 中下标 1 处，然而 nums2[1] = 4 和 nums2[2] = 6 没有出现在 nums2 中。因此，answer[1] = [4,6]。
示例 2：
输入：nums1 = [1,2,3,3], nums2 = [1,1,2,2]
输出：[[3],[]]
解释：
对于 nums1 ，nums1[2] 和 nums1[3] 没有出现在 nums2 中。由于 nums1[2] == nums1[3] ，二者的值只需要在 answer[0] 中出现一次，故 answer[0] = [3]。
nums2 中的每个整数都在 nums1 中出现，因此，answer[1] = [] 。

思路：

因为涉及到数组的数小于0的情况，所以用数组hash的时候需要考虑绝对值；再就是存在赋值和正值绝对值相同，所以当1和2相等的时候，需要确认1和2中的数是否存在，一个为正，一个为负，但是绝对值相同的情况；由于相同的数值只能在数组中出现一次，所以找出所有的不同需要将队列排序，去掉不同的。

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

int removeSame(int *nums, int *numSize){
    int i = 0;
    int j = 1;

    if(*numSize == 0){
        return 0;
    }
    for(i = 1; i < *numSize; i++){
        if(nums[i] != nums[i-1]){
            nums[j++] = nums[i];
        }
    }

    *numSize = j;
    return 0;
}
int isDiff(int num, int *nums_a, int *nums_b)
{    
    if(num < 0){
        if((nums_a[abs(num)] &0x1) && (nums_b[abs(num)]&0x1)) {
            return 0;
        }
    }
    else{
        if((nums_a[num] &0x2) && (nums_b[num]&0x2)) {
            return 0;
        }
    }

    return 1;
}

int** findDifference(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize, int** returnColumnSizes) {
    int maxVal = 0;
   
    for (int i = 0; i < nums1Size; i++) {
        if (abs(nums1[i]) > maxVal) maxVal = abs(nums1[i]);
    }
    for (int i = 0; i < nums2Size; i++) {      
        if (abs(nums2[i]) > maxVal) maxVal = abs(nums2[i]);
    }
    
    maxVal++; // To include the maxVal itself

    int * nums_a = malloc(maxVal * sizeof(int));
    int * nums_b = malloc(maxVal * sizeof(int));
    memset(nums_a, 0, maxVal * sizeof(int));
    memset(nums_b, 0, maxVal * sizeof(int));

    for (int i = 0; i < nums1Size; i++) {
        if (nums1[i] < 0 && !(nums_a[abs(nums1[i])] &0x1)){
            nums_a[abs(nums1[i])] |= 0x1;
        }
        else if(nums1[i]>= 0 && !(nums_a[nums1[i]] & 0x2)){
            nums_a[nums1[i]] |= 0x2;
        }                    
    }

    for (int i = 0; i < nums2Size; i++) {
        if (nums2[i] < 0 && !(nums_b[abs(nums2[i])] &0x1)){
            nums_b[abs(nums2[i])] |= 0x1;
        }
        else if(nums2[i] >= 0 && !(nums_b[nums2[i]] & 0x2)){
            nums_b[nums2[i]] |= 0x2;
        }                    
    }
    
    int *hashSet1 = malloc(maxVal * sizeof(int));
    int *hashSet2 = malloc(maxVal * sizeof(int));
    memset(hashSet1, 0, maxVal * sizeof(int));
    memset(hashSet2, 0, maxVal * sizeof(int));
  
  
    // Mark elements of nums1 in hashSet1
    for (int i = 0; i < nums1Size; i++) {    
        hashSet1[abs(nums1[i])] = 1;
    }

    // Mark elements of nums2 in hashSet2
    for (int i = 0; i < nums2Size; i++) {
        hashSet2[abs(nums2[i])] = 1;
    }

    int uniqueCount1 = 0;
    int uniqueCount2 = 0;
    int *uniqueNums1 = malloc(maxVal * sizeof(int));
    int *uniqueNums2 = malloc(maxVal * sizeof(int));

    // Find unique elements in nums1
    for (int i = 0; i < nums1Size; i++) {    
        if (hashSet2[abs(nums1[i])] == 0  || (1 == hashSet2[abs(nums1[i])])&&isDiff(nums1[i], nums_a, nums_b)) {
            uniqueNums1[uniqueCount1++] = nums1[i];
        }
    }

    // Find unique elements in nums2
    for (int i = 0; i < nums2Size; i++) {
        if (hashSet1[abs(nums2[i])] == 0  || (1 == hashSet1[abs(nums2[i])]&&isDiff(nums2[i], nums_a, nums_b))) {
            if(uniqueCount2 < maxVal-1)
            uniqueNums2[uniqueCount2++] = nums2[i];
        }
    }
    
    qsort(uniqueNums1, uniqueCount1, sizeof(int), compareInts);
    qsort(uniqueNums2, uniqueCount2, sizeof(int), compareInts);

    
    removeSame(uniqueNums1, &uniqueCount1);
    removeSame(uniqueNums2, &uniqueCount2);

    int** answer = malloc(2 * sizeof(int*));
    answer[0] = malloc(uniqueCount1 * sizeof(int));
    answer[1] = malloc(uniqueCount2 * sizeof(int));

    for (int i = 0; i < uniqueCount1; i++) {
        answer[0][i] = uniqueNums1[i];
    }
    for (int i = 0; i < uniqueCount2; i++) {
        answer[1][i] = uniqueNums2[i];
    }

    *returnSize = 2;
    *returnColumnSizes = malloc(2 * sizeof(int));
    (*returnColumnSizes)[0] = uniqueCount1;
    (*returnColumnSizes)[1] = uniqueCount2;

    free(hashSet1);
    free(hashSet2);
    free(uniqueNums1);
    free(uniqueNums2);
    free(nums_a);
    free(nums_b);
    return answer;
}