LeetCode数据结构--Week 1

LeetCode数据结构day1算法题学习

题217. 存在重复元素

1）思路：

       首先利用排序算法把输入数组排序，再将有序的数组遍历，比较相邻两个是否相等。

2）代码：

int compFunc(void* p,void* q){
    int* node_1 = (int*)p;
    int* node_2 = (int*)q;

    return (*node_1-*node_2);
}

bool containsDuplicate(int* nums, int numsSize){
    int flag,i;
    qsort(nums, numsSize, sizeof(int), compFunc);//快排算法对输入数组排序
    flag = nums[0];
    for (i = 1; i < numsSize; i++)
    {
        if (flag == nums[i])
        {
            return  true;
        }
        flag = nums[i];
    }

    return false;
}

还可以优化一下：

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

题53. 最大子数组和

1）思路：

       对于数组中每一个数，如果它的前一个数>0，则加到当前数上；否则，当前数不变。

2）代码：

int maxSubArray(int* nums, int numsSize){
    int pre = 0, maxAns = nums[0];//初始前驱设为0
    for (int i = 0; i < numsSize; i++) {
        pre = fmax(pre + nums[i], nums[i]);//取max（pre+nums[i],nums[i]），并赋值给pre
        maxAns = fmax(maxAns, pre);
    }
    return maxAns;
}
//上述代码摘自官方

LeetCode数据结构day2算法题学习

题1. 两数之和

1）思路：

       数组遍历，然后将两次遍历的值相加与target比较，相等则返回数组下标（数组中同一个元素在答案里不能重复出现）

2）代码：

int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    int i,j;
    for(i=0;i<numsSize;i++){
        for(j=i+1;j<numsSize;j++){
            if(nums[i]+nums[j]==target){
                int* ret = malloc(sizeof(int) * 2);
                ret[0] = i, ret[1] = j;
                *returnSize = 2;
                return ret;
            }
        }
    }
    *returnSize = 0;
    return NULL;
}

题88. 合并两个有序数组

1）思路：

       采用一种类似于插入排序的思想，新建一个数组用于合并两个数组，由于原先两个数组已有序，故比较最低位再插入即可。

2）代码：

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
    int p=0,q=0;
    int sorted[m+n];
    int cur=0;
    while(p<m||q<n){
        if(p==m){
            cur=nums2[q++];//nums1已遍历完
        }
        else if(q==n){
            cur=nums1[p++];//nums2已遍历完
        }
        else if(nums1[p]>nums2[q]){
            cur=nums2[q++];
        }
        else{
            cur=nums1[p++];
        }
        sorted[p+q-1]=cur;//插入进合并的数组        
    }
    for(int i = 0; i < m + n; i++){
        nums1[i]=sorted[i];//合并后数组存放在nums1上
        }
}

LeetCode数据结构day3算法题学习

题350. 两个数组的交集 II

1）思路：排序+双指针

       将两个数组先排序，然后分别用指针指向数组首部，每次比较两个指针指向的两个数组中的数字，如果两个数字不相等，则将指向较小数字的指针右移一位；如果两个数字相等，将该数字添加到答案，并将两个指针都右移一位。当至少有一个指针超出数组范围时，遍历结束。（常用解题思路）

2）代码：

int cmp(const void* _a, const void* _b) {
    int *a = _a, *b = (int*)_b;
    return *a == *b ? 0 : *a > *b ? 1 : -1;
}

int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size,
               int* returnSize) {
    qsort(nums1, nums1Size, sizeof(int), cmp);
    qsort(nums2, nums2Size, sizeof(int), cmp);
    *returnSize = 0;
    int* intersection = (int*)malloc(sizeof(int) * fmin(nums1Size, nums2Size));
    int index1 = 0, index2 = 0;
    while (index1 < nums1Size && index2 < nums2Size) {
        if (nums1[index1] < nums2[index2]) {
            index1++;
        } else if (nums1[index1] > nums2[index2]) {
            index2++;
        } else {
            intersection[(*returnSize)++] = nums1[index1];
            index1++;
            index2++;
        }
    }
    return intersection;
}

题121. 买卖股票的最佳时机

1）思路：

       DP思想：记录第i天之前的min，算出以今天之前min买入、今天卖出的profit；比较每天的获利，取max。

2）代码：

class Solution {
    public int maxProfit(int[] prices) {
        if(prices.length<=1){
            return 0;
        }
        int min = prices[0],max=0;
        for(int i=1;i<prices.length;i++){
            max = Math.max(max,prices[i]-min);
            min = Math.min(min,prices[i]);
        }
        return max;
    }
}//摘自LeetCode解答