foreword

The sequence table is no stranger to everyone, so let's practice the related OJ questions directly, and by the way, enhance the proficiency of direct mastery. This article records the process of my doing some questions, ok, not much to say, directly enter the theme.

Question 1: 27. Remove elements

1. Original title link

Portal: 27. Remove Elements

2. Topic description

Given an array nums and a value val, you need to remove all elements whose value is equal to val in place , and return the new length of the removed array .

Instead of using extra array space , you have to use only O(1) extra space and modify the input array in place.

The order of elements can be changed. You don't need to consider elements in the array beyond the new length.

illustrate:

Why is the returned value an integer, but the output answer is an array?

Note that the input array is passed "by reference", which means that changes to the input array within the function are visible to the caller.

You can imagine the internal operation as follows:

// nums are passed "by reference". That is, without making any copies of the arguments
int len = removeElement(nums, val);

// Modifications to the input array in the function are visible to the caller.
// Based on the length returned by your function, it will print out all elements in the array within that length.
for (int i = 0; i < len; i++) { print(nums[i]); }

Example 1:

Input: nums = [3,2,2,3], val = 3
Output: 2, nums = [2,2]
Explanation: The function should return a new length of 2, and the first two elements in nums are both 2. You don't need to consider elements in the array beyond the new length. For example, the new length returned by the function is 2, and nums = [2,2,3,3] or nums = [2,2,0,0] would also be considered the correct answer.
Example 2:

Input: nums = [0,1,2,2,3,0,4,2], val = 2
Output: 5, nums = [0,1,4,0,3]
Explanation: The function should return the new length 5, and the first five elements in nums are 0, 1, 3, 0, 4. Note that these five elements can be in any order. You don't need to consider elements in the array beyond the new length.

3. The code function given

4. Thought analysis

Let's take a look. In fact, this question is essentially a question of deleting elements. The key is how do we delete them? How to delete:

Idea 1: Direct Method

Come up directly without saying a word, just traverse it directly, let the value of val be compared with the elements in the array, is it val? If yes, keep going. If not, let the following elements move forward and cover them directly until the traversal is completed. Think about it carefully, what is the time complexity of this? O(N^2) why why why? Worst case: most of the array is val, delete a data is n-1, n-2. n-3... This is an arithmetic sequence. According to the arithmetic sum formula, the time complexity is of course O(N^2).

Idea 2: space for time

How do you want to optimize it at this point? Let’s start with a simple one, how to convert the time complexity to O(N) and make it as low as possible

Many people will easily think of: open up an array, exchange space for time, put the value that is not val into the new array, and copy the value of the new array. The time complexity is O(N) and the space complexity is O(N)

? ? It's time to change your mind

Idea 3: Double pointer: time complexity is O(N), space complexity is O(1)

Define two pointers src and dst, both pointing to the first element at the beginning.

1. If the src position is not val, put it in the dest position, then src++, dst++

2. If the scr position is val, src++

3.dst is the new length

4. Code implementation

After talking about the idea, I probably have a basic framework in my heart. Next, we will directly implement our code.

int removeElement(int* nums, int numsSize, int val){
    int src = 0,dst = 0;
    while(src <numsSize)
    {
        if(nums[src] !=val)
        {
            nums[dst] = nums[src];
            src++;
            dst++;
        }
        else
        {
            src++;
        }
    }
    return dst;
}

Look directly at our effect code map

Time beat 100%.