逻辑或运算如果前表达式为真，后表达式不计算，第一次循环时i为0，执行i++，第二次循环时i为1，是个真值，不再执行i++，也就死循环了

在C语言中，一个函数如果不写返回值类型，那么就默认为int类型

至少是其他数字两倍的最大数
题目来源
给你一个整数数组 nums ，其中总是存在 唯一的 一个最大整数 。请你找出数组中的最大元素并检查它是否 至少是数组中每个其他数字的两倍 。如果是，则返回 最大元素的下标 ，否则返回 -1

int dominantIndex(int* nums, int numsSize){
    //找到最大值元素
    int max = *(nums);
    int key = 0;
    int k = 0;
    for(k=0;k<numsSize;k++){
        if(*(nums+k)>=max){
            max = *(nums+k);
            key = k;
        }
    }
    
    //0 1 3 6
    //if 3*2<=6

    int i = 0;
    int j = 0;
    //冒泡排序
    for(i=0;i<(numsSize-1);i++){
        for(j=0;j<(numsSize-i-1);j++){
            if(*(nums+j)>*(nums+j+1)){
                int temp = *(nums+j);
                *(nums+j) = *(nums+j+1);
                *(nums+j+1) = temp; 
            }
        }
    }
    //排序之后
    //n-1 和 n-2
    if((*(nums+numsSize-2)*2)<=*(nums+numsSize-1)){
        return key; 
    }else{
        return -1;
    }
}

int dominantIndex(int* nums, int numsSize) {
    if (numsSize == 1) return 0;//特殊情况只有一个元素则特殊处理

    int max, sec, idx;
    //先对最大和次大进行选择赋值，注意max和sec不能随意赋初值，因为有可能你赋予的初值就是最大值
    //因此要使用数组中的数据进行初值赋予。
    //1 2 3 4
    if (nums[0] > nums[1]) {
        max = nums[0];
        idx = 0;
        sec = nums[1];
    }
    else {
        max = nums[1];
        idx = 1;
        sec = nums[0];
    }

    for (int i = 2; i < numsSize; i++) {
        if (nums[i] > max) { //当前元素大于max，则意味着要替换
            sec = max; //先将原先最大的保存到sec中，则他就是次大的
            max = nums[i]; //再将最大的放到max中
            idx = i; //保存max值的下标
        }
        else if (nums[i] > sec) {
            //避免刚好nums[0]就是最大的情况，因为不切换最大而导致次大无法判断情况
            sec = nums[i];
        }
    }
    if (max >= sec * 2) {
        return idx;
    }
    return -1;
}


int main() {
    //int nums[] = { 1,2,3,4 };
    //int nums[] = { 3,6,1,0 };
    //int nums[] = { 6,5,4,3 };
    int nums[] = { 6,2,4,1 };


    int numsSize = sizeof(nums) / sizeof(nums[0]);
    dominantIndex(nums,numsSize);
    return 0;
}

给定两个数组，编写一个函数来计算它们的交集。
题目来源

int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
    // int arr[1000]; 错误

    // static int arr[1000];
    // int* arr = (int*)malloc(sizeof(int)*1000);
    int* arr = (int*)calloc(1000,sizeof(int));

    *returnSize = 0;
    
    int i, j, k;
    
    for (i = 0; i < nums1Size; i++) {
        // nums1 = [1,2,2,1], nums2 = [2,2]
        // 2
        for (j = 0; j < nums2Size; j++) {

            if (nums2[j] == nums1[i]) break;//判断nums1[i] 是否在nums2数组中

        } 
            
        if(j == nums2Size) {// nums1中i位置的数据在nums2数组中不存在，则非交集数据
            continue;
        } 
        
        //只有在另一个数组中存在的数据才能走下来，判断是否已经被添加到返回数组中
        
        for (j = 0; j < *returnSize; j++) {
            
            if (nums1[i] == arr[j]) break;//判断nums1[i] 是否在 arr 这个返回数组中
        
        } 
            
        if(j == *returnSize) {//不在返回数组中，则添加到返回数组中
            arr[*returnSize] = nums1[i];
            *returnSize += 1;
        }
    } 

    return arr;
}