第一题：至少是两倍其他数字的最大数

第一题：

思路一：

1.需要我们返回最大数值的下标，所以先循环遍历我们的这个数组记录一下最大的数值和下标位置。
2.使用qsort排序（总是存在唯一的最大整数）
3所以排序之后的数组的倒数第二个元素就是除了最后一个元素在数组中最大的。
4.只需要判断这个数的两倍是否小于等于最大的数值。
5.注意题目的特殊情况是数组中只存在一个元素的时候，这个时候默认他就是最大的直接返回下标0.

int cmp(void* p1,void*p2)
{
    return ((*(int*)p1))-((*(int*)p2));
}

int dominantIndex(int* nums, int numsSize){

    if(numsSize==1)
    return 0;

    int MAX=0;
    int tmp=0;
    for(int i=0;i<numsSize;i++)
    {
        if(nums[i]>MAX)
        {
            MAX=nums[i];
            tmp=i;
        }
    }

    qsort(nums,numsSize,sizeof(nums[0]),cmp);
    if(2*nums[numsSize-2]<=MAX)
    {
        return tmp;
    }

    return -1;
}

总结：这个方法的时间复杂度O（log^n+1)n

思路二：

1.可以使用双指针的方法在一次循环遍历中就找到最大的数和次大的数值。
2.定义MAX和MAX_2用来保存。
3.存在最大的数值已经不能更改了，数组后面还存在次大的数值。需要MAX_2去循环遍历。

int dominantIndex(int* nums, int numsSize){

    if(numsSize==1)
    return 0;

    int MAX=0;
    int MAX_2=0;
    int tmp=0;
    for(int i=0;i<numsSize;i++)
    {
        if(nums[i]>MAX)
        {
            MAX_2=MAX;
            MAX=nums[i];
            tmp=i;
        }
        else
        {
            //一个数组需要走完的
            if(nums[i]>MAX_2)
            MAX_2=nums[i];
        }
    }

    if(MAX_2*2<=MAX)
    {
        return tmp;
    }
    return -1;
}

第二题：两个数组的交集

第二题：

思路一：

1.动态开辟一个数组去保存我们的相同的值，定义一个变量k控制这个数组的变化。
2.使用双for循环一对多的比较是否相等，相当就保存到数组里面。但是有这样的一个情况。
3.比较的过程中一个元素已经在之前放进这个数组里面了这个数值是不可以添加进来的。只有第一次进入不需要判断是否和之前的相等。

int pp(int* ret,int n,int k)
{
    int flag=-1;
    int i=0;
    while(k--)
    {
        if(*(ret+i)==n)
        {
            flag=0;
            break;
        }
        else
        {
            flag=1;
        }
        i++;
    }
    return flag;
}

int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
    int k = 0;
    int n1 = nums1Size;
    int n2 = nums2Size;
    int p1 = 0;
    int p2 = 0;
    int* ret = (int*)malloc((sizeof(int)) * (n1 + n2));

    for(int i=0;i<n1;i++)
    {
        for(int j=0;j<n2;j++)
        {
            if(nums1[i]==nums2[j])
            {
                if(k==0)
                {
                    *ret=nums2[j];
                    k++;
                    break;
                }
                else
                {
                    if(pp(ret,nums2[j],k))
                    {
                        *(ret+k)=nums2[j];
                        k++;
                        break;
                    }
                }
            }
        }
    }
    (*returnSize) = k;
    return ret;
}

总结：时间复杂度是O（n^2）