数组

1、乘积最大子数组

2、多数元素

剔除元素法（Boyer-Moore投票算法）：

原理：在原序列中去除两个不同的元素后，原序列中的多数元素在新序列中还是多数元素。

int majorityElement(int* nums, int numsSize){
    int cur_number = 0, count = 0;
    int i;
    for(i=0; i<numsSize; ++i)
    {
        if(0 == count) {
            cur_number = nums[i];
        }
        if(cur_number == nums[i]) {
            ++count;
        } else {
            --count;
        }
    }
    return cur_number;
}

3、旋转数组

使用方法：3次反转法

void reverse(int *nums, int left, int right)
{
    int tmp;
    while(left < right)
    {
        tmp = nums[left];
        nums[left] = nums[right];
        nums[right] = tmp;
        ++left;
        --right;
    }
}

void rotate(int* nums, int numsSize, int k){
    k %= numsSize; (出过错，勿忘)
    reverse(nums, 0, numsSize-1);
    reverse(nums, 0, k-1);
    reverse(nums, k, numsSize-1);
}

4、存在重复元素

利用了哈希表，哈希表的范围是最大值和最小值的差值。

bool containsDuplicate(int* nums, int numsSize){
    if(0 == numsSize)
        return false;
    int min,max,len,i;
    min=nums[0], max=nums[0];
    for(i=1; i<numsSize; ++i)
    {
        if(nums[i] < min){
            min = nums[i];
        }          
        if(nums[i] > max){
            max = nums[i];
        }
    }
    len = max-min+1;
    int *hashSet = malloc(len*sizeof(int));
    for(i=0; i<len; ++i)
        hashSet[i] = 0;
    for(i=0; i<numsSize; ++i)
    {
        if(1 == hashSet[nums[i]-min]){
            return true;
        }
        hashSet[nums[i]-min] = 1;
    }
    return false;
}

5、移动零

类似于快排和快慢指针

void moveZeroes(int* nums, int numsSize){
    int i, lastNotZero=0;
    for(i=0; i<numsSize; ++i)
    {
        if(nums[i] != 0){
            nums[lastNotZero++] = nums[i];
        }
    }
    while(lastNotZero < numsSize)
        nums[lastNotZero++] = 0;
}

6、打乱数组

#include <time.h>

typedef struct {
    int* array;
    int* original;
    int size;
} Solution;

void swap(int *a, int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

int randInit(int min, int max)
{
    int ret = rand()%(max-min+1)+min;
    return ret;
}

Solution* solutionCreate(int* nums, int numsSize) {
    int i;
    Solution* new = (Solution*)malloc(sizeof(Solution));
    new->size = numsSize;
    new->array = (int*)malloc(numsSize*sizeof(int));
    new->original = (int*)malloc(numsSize*sizeof(int));
    for(i=0; i<numsSize; ++i)
    {
        new->array[i] = nums[i];
        new->original[i] = nums[i];
    }
    return new;
}

/** Resets the array to its original configuration and return it. */
int* solutionReset(Solution* obj, int* retSize) {
    int i;
    *retSize = obj->size;
    for(i=0; i<obj->size; ++i)
    {
        obj->array[i] = obj->original[i];
    }
    return obj->array;
}

/** Returns a random shuffling of the array. */
int* solutionShuffle(Solution* obj, int* retSize) {
    *retSize = obj->size;
    int swapIndex, i;
    for(i=0; i<*retSize; ++i)
    {
        swapIndex = randInit(i, *retSize-1);
        swap(&(obj->array[i]), &(obj->array[swapIndex]));
    }
    return obj->array;
}

void solutionFree(Solution* obj) {
    free(obj->array);
    obj->array = NULL;
    free(obj->original);
    obj->original = NULL;
    free(obj);
    obj = NULL;
    return;
}

/**
 * Your Solution struct will be instantiated and called as such:
 * Solution* obj = solutionCreate(nums, numsSize);
 * int* param_1 = solutionReset(obj, retSize);
 
 * int* param_2 = solutionShuffle(obj, retSize);
 
 * solutionFree(obj);
*/

10、除自身以外数组的乘积

左积*右积

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* productExceptSelf(int* nums, int numsSize, int* returnSize){
    int *leftPro = (int*)malloc(numsSize*sizeof(int));
    int *rightPro = (int*)malloc(numsSize*sizeof(int));
  
    int i;

    leftPro[0] = 1;
    for(i=1; i<numsSize; ++i)
    {
        leftPro[i] = leftPro[i-1]*nums[i-1];
    }
    rightPro[numsSize-1] = 1;
    for(i=numsSize-2; i>=0; --i)
    {
        rightPro[i] = rightPro[i+1]*nums[i+1];
    }
    for(i=0; i<numsSize; ++i)
    {
        leftPro[i] = leftPro[i]*rightPro[i];
    }

    *returnSize = numsSize;
    return leftPro;
}