[LeetCode][算法初级] [数组] 21-24

21 从排序数组中删除重复元素

https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/1/array/21/

维护两个下标，一个代表处理完成的数组的末尾，一个代表正在被处理的下标。

遍历数组，将不重复的数字顺次放进数组前部即可。

int removeDuplicates(int* nums, int numsSize) {
    if(numsSize==0)
        return 0;
    int pre = 0,cur = 0;
    while(cur<numsSize)
    {
        if(nums[pre]==nums[cur])
            cur++;
        else
            nums[++pre] = nums[cur++];
    }
    return pre+1;
}

22 买卖股票的最佳时机II

https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/1/array/22/

最主要的是需要判断何时卖出。条件有：1，后项低于当前项；2，后项超出下标边界。

需要维护一个变量来保存买入价，在卖出的时候计算收益，并更新买入价即可。

int maxProfit(int* prices, int pricesSize) {

    int i=0,buy=prices[0],sell=prices[0];
    int profit=0;
    buy = prices[0];
    while (i<pricesSize){
        if(i+1 == pricesSize || prices[i] > prices[i+1]){
            profit+=prices[i]-buy;
            buy = prices[i+1];
        }
        i++;
    }
    return profit;
}

23 旋转数组

https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/1/array/23/

需要利用到一个性质：

将数组A划分为数组a,b,c，即A=abc，用 「'」 来表示逆置，有：

cba= ( a'b'c' )'

当按照题目要求的位置将数组A分为a和b两个部分时，旋转数组的结果是 A=ab -> A=ba=(a'b')'。

只需要执行3次置逆操作即可。

void reverse(int *nums, int size){
    int i=0,j=size -1;
    while(i<j){
        nums[i] = nums[j]+nums[i];
        nums[j] = nums[i] - nums[j];
        nums[i] = nums[i] - nums[j];
        i++;
        j--;
    }
}
void rotate(int* nums, int numsSize, int k) {
    int i=0, c=0;
    k = k%numsSize;
    reverse(nums, numsSize-k);
    reverse(nums+numsSize-k,k);
    reverse(nums,numsSize);

}

而ruby里自带这个函数，赞美。

# @param {Integer[]} nums
# @param {Integer} k
# @return {Void} Do not return anything, modify nums in-place instead.
def rotate(nums, k)
    nums.rotate!(-k)
end

这样搞的跟作弊一样。还是来看一下ruby里的实现吧。

http://ruby-doc.org/core-2.3.1/Array.html#method-i-rotate

static VALUE
rb_ary_rotate_m(int argc, VALUE *argv, VALUE ary)
{
    VALUE rotated;
    const VALUE *ptr;
    long len, cnt = 1;

    switch (argc) {
      case 1: cnt = NUM2LONG(argv[0]);
      case 0: break;
      default: rb_scan_args(argc, argv, "01", NULL);
    }

    len = RARRAY_LEN(ary);
    rotated = rb_ary_new2(len);
    if (len > 0) {
        cnt = rotate_count(cnt, len);
        ptr = RARRAY_CONST_PTR(ary);
        len -= cnt;
        ary_memcpy(rotated, 0, len, ptr + cnt);
        ary_memcpy(rotated, len, cnt, ptr);
    }
    ARY_SET_LEN(rotated, RARRAY_LEN(ary));
    return rotated;
}

Emmm不是原地算法，memcpy简单粗暴。

24 存在重复

https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/1/array/24/

一开始的思路是利用快排的算法，在排序过程中，发现相等的数时更新结果。

但是提交之后结果不对。虽然结果和预期都是false，还是判断为错误。已经提交到反馈。

int partition(int* arr, int l,int r, int pivot, bool* flag){
    int j = l, i = l + 1;
    for (;i < r; i++){
        if(arr[i] == pivot){
            *flag = true;
        }else if(arr[i]<pivot){
            j++;
            swap(arr,i,j);
        }
    }
    swap(arr, l, j);
    return j;
}

void swap(int* arr, int i, int j){
    arr[i] += arr[j];
    arr[j] = arr[i] - arr[j];
    arr[i] = arr[i] - arr[j];
}

void quicksort(int* arr, int l, int r, bool* flag){
    int pivot = arr[l];
    int j = 0;
    if(l>=r) return;
    j = partition(arr, l, r, pivot, flag);
    quicksort(arr, l, j - 1, flag);
    quicksort(arr, j + 1, r, flag);
}

bool containsDuplicate(int* nums, int numsSize) {
    bool res = false;
    if(numsSize == 0 ) return false ;
    quicksort(nums, 0, numsSize-1, &res);
    return res;
}

而用ruby就超简单了：

# @param {Integer[]} nums
# @return {Boolean}
def contains_duplicate(nums)
    return nums.uniq.size != nums.size
end

ruby真是魔法仙女棒。