代码随想录训练营-6day：哈希表2

一、454 四数相加

这道题处理时候，自己编写的hash map函数遇到初始化的问题，没有插入数据，也能找到，导致随机值，后面就想的是，初始化value为0，遍历时候，把nums1 + nums2的值出现次数保存下来；

接下来是遍历一次，把0 - nums3 - num4的值的次数找到，就是四数相加为0的情况，累加这个次数，就是结果。

typedef struct hashTable {
    int key;
    int val;
    UT_hash_handle hh;
} Hash;

Hash* hashtable = NULL;

Hash* find(int key)
{
    Hash* tmp = NULL;
    HASH_FIND_INT(hashtable, &key, tmp);
    return tmp;
}

void insert(int key, int value)
{
    Hash* tmp = find(key);
    if(NULL == tmp)
    {
       Hash* hashNode = (Hash*)malloc(sizof(Hash));
       hashNode->key = key;
       hashNode->val = value;
       HASH_ADD_INT(hashtable, key, hashNode);//c语言自带的宏定义
    }
    else
    {
       tmp->val = value;
    }
}

int fourSumCount(int* nums1, int nums1Size, int* nums2, int nums2Size, int* nums3, int nums3Size, int* nums4, int nums4Size){
  
   int len = nums1Size;
   int count = 0;
   /**
    初始化 在解决过程中，发现如果不初始化，那么没有插入数据，
    会导致搜索0 -（nums3 + nums4）时候出错，具体是num1 + num2的值并未插入，
    即没有次数，预期应该不能找到，但实际打印确有值。
   **/
   for(int i = 0; i < len; i++)
   {
      for(int j = 0; j < len; j++)
      {   
         /**注意两边的key值都需要填0，所以键值对都初始化**/
         insert(nums1[i] + nums2[j], 0);//times
         insert(0 - nums3[i] - nums4[j], 0);
      }
   }


   for(int i = 0; i < len; i++)
   {
      for(int j = 0; j < len; j++)
      {    
        int times = 1;
        int key = nums1[i] + nums2[j];
        //printf("1-key[%d %d] = %d\n",i, j, key);
        if(NULL == find(key))
        {
            insert(key, times);//times
           // printf("1tms = %d value = %d\n", key, times);
        }
        else
        {   
            struct hashTable* tmp = find(key);
            times = tmp->val + 1;
            insert(key, times);
            //printf("tms = %d value = %d\n", key, times);
        }
      }
   }

  for(int i = 0; i < len; i++)
   {
      for(int j = 0; j < len; j++)
      {    
           
            int times = 0;
            int key = 0 - nums3[i] - nums4[j]; 
            //printf("return key[%d %d] = %d\n",i, j, key);
            if(NULL != find(key))
            {   
                struct hashTable* tmp = find(key);
                times = tmp->val;
                //printf("return key = %d value = %d\n", key, times);
                count+= times;
            }
      }

   }

   return count;
}

二、383 赎金信

这道题需要理解：magazine内部的字符去组成ansomNote的字符串，因此如果ansomNote字符串多于magazine，那么magazine一定没有那么多的字符来组成。一开始记录magazine内部字符出现的次数，利用hash set（c语言可用数组，26个字母），在ansomNote字符串中遍历，把遇到的字符次数剪掉，如果hash set内部元素有小于0的，说明magazine内部没有此字符，那么就组成不了ansomNote。

/**主要是理解题目的意思，magazine里面的一部分字符，是ransomNote的一部分**/ 
bool canConstruct(char* ransomNote, char* magazine) {
  
  int charNum[26] = {0};//记录26个字母出现的次数
  /**如果ransomNote的字符多，那么magazine一定凑不出那么多字符去组成ransomNote**/
  if(strlen(ransomNote) > strlen(magazine))
  {
    return false;
  }

  for(int i = 0; i < strlen(magazine); i++)
  {
      charNum[magazine[i] - 'a']++;
  }

  for(int i = 0; i < strlen(ransomNote); i++)
  {
      charNum[ransomNote[i] - 'a']--;
      /**如果magazine里面没有ransomNote所需要的字符，那么ransomNote减掉的字符次数肯定小于0**/
      if(charNum[ransomNote[i] - 'a'] < 0)
      {
          return false;
      }
  }
  return true;
}

三、15 三数之和

主要是学习代码随想录的双指针法思路（代码随想录 (programmercarl.com)），首先需要对数组排序，重要的思路就是剪掉重复的数字，但需要保留有效的集合，例如[-1 -1 2]，需要理解多余数的核心，就是这句话：“不能有重复的三元组，但三元组内的元素是可以重复的”；

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
 /**1 重复情况需要排除 2 先排序**/
 void sortArr(int* nums, int numsSize)
 {
    for(int i = 0; i < numsSize; i++)
    {
        for(int j = i + 1; j < numsSize; j++)
        {
            if(nums[i] > nums[j])
            {
                int  tmp = nums[i];
                nums[i] = nums[j];
                nums[j] = tmp;
            }
            
        }
    }
 }


int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    sortArr(nums, numsSize);
    /**双指针法**/
    int** arr = (int**)malloc(sizeof(int*) * numsSize * numsSize);
    *returnColumnSizes = (int*)malloc(sizeof(int) * numsSize * numsSize);
    *returnSize = 0;

    for(int i = 0; i < numsSize - 2; i++)//i的取值
    {
        if(nums[i] > 0)
        {
           break;
        }
       
        if(i > 0 &&(nums[i] == nums[i-1]))
        {
            continue;
        }

        int left = i + 1;
        int right = numsSize - 1;
        while(left < right)
        {
            int sum = nums[i] + nums[left] + nums[right];
            //printf("sum = %d\n", sum);
            if(sum > 0)
            {
               right--;
            }
            else if(sum < 0)
            {
               left++;
            }
            else
            {
                arr[*returnSize] = (int*)malloc(sizeof(int)* 3);
                (*returnColumnSizes)[*returnSize] = 3;
                arr[*returnSize][0] = nums[i];
                arr[*returnSize][1] = nums[left];
                arr[*returnSize][2] = nums[right];
                (*returnSize)++;
                while((left < right) &&(nums[right] == nums[right -1]))
                {
                    right--;
                }

                while((left < right) &&(nums[left] == nums[left + 1]))
                {
                    left++;
                }
                right--;
                left++;
            }

        }

    }

    return arr;
}

四、18 四数之和

在三数字之和的基础上，主要是对去重的理解。

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
  /**1 重复情况需要排除 2 先排序**/
 void sortArr(int* nums, int numsSize)
 {
    for(int i = 0; i < numsSize; i++)
    {
        for(int j = i + 1; j < numsSize; j++)
        {
            if(nums[i] > nums[j])
            {
                int  tmp = nums[i];
                nums[i] = nums[j];
                nums[j] = tmp;
            }
            
        }
    }
 }

int** fourSum(int* nums, int numsSize, int target, int* returnSize, int** returnColumnSizes) {
     sortArr(nums, numsSize);
    /**双指针法**/
    int** arr = (int**)malloc(sizeof(int*) * numsSize * numsSize);
    *returnColumnSizes = (int*)malloc(sizeof(int) * numsSize * numsSize);
    *returnSize = 0;
    for(int k = 0; k < numsSize - 3; k++)
    {
        if(nums[k] > target && nums[k] >= 0)
        {
            break;
        }
    
        if(k > 0 &&(nums[k] == nums[k-1]))
        {
            continue;
        }
        for(int i = k + 1; i < numsSize - 2; i++)//i的取值
        {
            if(nums[k] + nums[i] > target && (nums[k] + nums[i] >= 0))
            {
                break;
            }
        
            if(i > k + 1 &&(nums[i] == nums[i-1]))
            {
                continue;
            }

            int left = i + 1;
            int right = numsSize - 1;
            while(left < right)
            {
                //考虑数字溢出情况
                long sum = (long)nums[i] + nums[k] + nums[left] + nums[right];
                //printf("sum = %d\n", sum);
                if(sum > target)
                {
                   right--;
                }
                else if(sum < target)
                {
                   left++;
                }
                else
                {
                    arr[*returnSize] = (int*)malloc(sizeof(int)* 4);
                    (*returnColumnSizes)[*returnSize] = 4;
                    arr[*returnSize][0] = nums[k];
                    arr[*returnSize][1] = nums[i];
                    arr[*returnSize][2] = nums[left];
                    arr[*returnSize][3] = nums[right];
                    (*returnSize)++;
                    while((left < right) && (nums[right] == nums[right -1]))
                    {
                        right--;
                    }

                    while((left < right) && (nums[left] == nums[left + 1]))
                    {
                        left++;
                    }
                    right--;
                    left++;
                }

            }

        }
    }
    return arr;
}