数据结构leetcode——day1

217. 存在重复元素

题目即寻找有无重复元素，有就返回true 没有返回false

思路一：直接排序 然后查找相邻元素是否相同

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

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

其中qsort方法如下 （当然也可以自己利用其他排序来复习下各大排序算法）

方法二：哈希表

c++

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int> ans;
        for (int i: nums) {
        	//如果表中已经查找到 即返回true说明有重复
            if (ans.find(i) != ans.end()) 
            {
                return true;
            }
            //否则插入表中
            ans.insert(i);
        }
        return false;
    }
};

当然 如果不嫌麻烦 想复习下c语言 也可以调用uthash.h来实现哈希表，其中HASH_ADD_INT、HASH_FIND_INT、HASH_DEL都是标准函数
HASH_FIND_INT中第一个参数set是哈希表，第二个参数是set_id的地址（一定要传递地址）。最后tmp是输出变量。当可以在哈希表中找到相应键值时，tmp返回给定键的结构，当找不到时tmp返回NULL。
HASH_ADD_INT函数中，第一个参数set是哈希表，第二个参数id是键字段的名称。最后一个参数tmp是指向要添加的结构的指针。

struct hashTable {
    int key;
    UT_hash_handle hh; //makes this structure hashable
};

bool containsDuplicate(int* nums, int numsSize) {
	/*声明哈希为NULL指针*/
    struct hashTable* set = NULL;
    for (int i = 0; i < numsSize; i++) {
        struct hashTable* tmp;
        HASH_FIND_INT(set, nums + i, tmp);
        if (tmp == NULL) {
            tmp = malloc(sizeof(struct hashTable));
            tmp->key = nums[i];
            HASH_ADD_INT(set, key, tmp);
        } else {
            return true;
        }
    }
    return false;
}

53. 最大子序和

思路一：贪心+动态规划思想，比较容易想到的就是求最大连续子序和，就是每次选取对结果有增益的sum 如果sum>0 就继续往前遍历 否则舍去直接从当前遍历数字开始

int maxSubArray(int* nums, int numsSize){
    int ans=nums[0];
    int sum=0;
    for(int i=0; i<numsSize;++i)
    {
        if(sum>0) sum+=nums[i];
        else
            sum=nums[i];
        ans=fmax(ans,sum);
    }
    return ans;

}

也可以用更标准的动态规划思路来写

int maxSubArray(int* nums, int numsSize){
    int dp[numsSize] ;
	dp[0] = nums[0];
	int max = nums[0];
	for (int i = 1; i < numsSize; i++) {
		dp[i] = fmax(dp[i- 1] + nums[i], nums[i]);	
		if (max < dp[i]) {
			max = dp[i];
		}
	}
	return max;
}

方法三：分治法（还需学习!）
以下代码转载在leetcode 确实没想到还能分治法！
即分而治之，最大子序和以数组中心点为中心要么全在左边，要么全在右边，要么跨中心
跨中心又分为左边和右边的子序和问题，即左右分别用贪心算法求得

class Solution
{
public:
    int maxSubArray(vector<int> &nums)
    {
        //类似寻找最大最小值的题目，初始值一定要定义成理论上的最小最大值
        int result = INT_MIN;
        int numsSize = int(nums.size());
        result = maxSubArrayHelper(nums, 0, numsSize - 1);
        return result;
    }

    int maxSubArrayHelper(vector<int> &nums, int left, int right)
    {
        if (left == right)
        {
            return nums[left];
        }
        int mid = (left + right) / 2;
        int leftSum = maxSubArrayHelper(nums, left, mid);
        //注意这里应是mid + 1，否则left + 1 = right时，会无限循环
        int rightSum = maxSubArrayHelper(nums, mid + 1, right);
        int midSum = findMaxCrossingSubarray(nums, left, mid, right);
        int result = max(leftSum, rightSum);
        result = max(result, midSum);
        return result;
    }

    int findMaxCrossingSubarray(vector<int> &nums, int left, int mid, int right)
    {
        int leftSum = INT_MIN;
        int sum = 0;
        for (int i = mid; i >= left; i--)
        {
            sum += nums[i];
            leftSum = max(leftSum, sum);
        }

        int rightSum = INT_MIN;
        sum = 0;
        //注意这里i = mid + 1，避免重复用到nums[i]
        for (int i = mid + 1; i <= right; i++)
        {
            sum += nums[i];
            rightSum = max(rightSum, sum);
        }
        return (leftSum + rightSum);
    }
};