数据结构——Leetcode刷题（数组）

面试题 17.04. 消失的数字

数组nums包含从0到n的所有整数，但其中缺了一个。请编写代码找出那个缺失的整数。你有办法在O(n)时间内完成吗？

注意：本题相对书上原题稍作改动

int missingNumber(int* nums, int numsSize){
    //相加作差求解
    int num = numsSize;
    int ret = 0;
    for(size_t i = 1 ; i <= num ; i++)
    {
        ret += i;
    }
    for(size_t j = 0 ; j < num ; j++)
    {
        ret -= nums[j]; 
    }
    return ret;


    //使用squrt排序
    
    //异或求解

    int num = numsSize;
    int ret = 0;
    for(size_t i = 1 ; i <= num ; i++)
    {
        ret ^= i;
    }
    for(size_t j = 0 ; j < num ; j++)
    {
        ret ^= nums[j]; 
    }
    return ret;

}

189. 轮转数组

给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

void rotate(int* nums, int numsSize, int k){
    k = k % numsSize;
    // 变长数组
    int tmp[numsSize];

    // 后k个拷贝到前面
    int j = 0;
    for(int i = numsSize-k; i < numsSize; ++i)
    {
        tmp[j] = nums[i];
        ++j;
    }

    //前n-k个拷贝到后面
    for(int i = 0; i < numsSize-k; ++i)
    { 
        tmp[j] = nums[i];
        ++j;
    }
        for(int i = 0; i < numsSize; ++i)
    {
        nums[i] = tmp[i];//将数组拷贝回原数组
    }
}


//三次翻转
void reservse(int*a, int begin, int end)
{
	while (begin < end)
	{
		int tmp = a[begin];
		a[begin] = a[end];
		a[end] = tmp;

		++begin;
		--end;
	}
}

void rotate(int* nums, int numsSize, int k)
{
	k = k % numsSize;

	reservse(nums, 0, numsSize - k - 1);
	reservse(nums, numsSize - k, numsSize - 1);
	reservse(nums, 0, numsSize - 1);
}

27. 移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

//使用双指针从零位置开始依次向后
int removeElement(int* nums, int numsSize, int val){
    int src = 0;
    int dest = 0; 
    while (src <= numsSize - 1)
    {
        if (nums[src] != val)
        {
            nums[dest] = nums[src];
            dest++;
            src++;
        }
        else
        {
            src++;
        }
    }
    return dest;
}

26. 删除有序数组中的重复项

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。

不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

int removeDuplicates(int* nums, int numsSize){
    int src = 1;
    int dest = 0;
    while (src < numsSize)
    {
        if (nums[src] == nums[dest])
        {
            src++;
            // nums[src-1] = nums[src];
        }
        else
        {
            dest++;
            nums[dest] = nums[src];
            src++;
        }
    }
    return dest+1;
}

88. 合并两个有序数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
    int n1 = m-1;
    int n2 = n-1;
    int end = m+n-1;

    while (n1 >= 0&&n2 >= 0)
    {
        if(nums1[n1] > nums2[n2])
        {
            nums1[end--] = nums1[n1--];
            // end--;
            // n1--;
        }
        else
        {
            nums1[end--] = nums2[n2--];
            // end--;
            // n2--;
        }
    }
    while (n2 >= 0)
    {
        nums1[end--] = nums2[n2--];
        // end--;
        // n2--;
    }
    // while (n1 > 0)
    // {
    //     nums1[end] = nums1[n1];
    //     end--;
    //     n1--;
    // }
}