Array element removal problem

One . The basis of array theory

1. Remove the underlying logic of array elements ： displacement 、 Cover
2. Function implementation ：del、pop()、remove() etc.  

Two . The brute force algorithm （ Double cycle ）

     0.  Refer to the original topic ： come from Leetcode Question bank 27 topic

          27. Remove elements

1.   Algorithm ideas （ Please refer to me in Leetcode Explanation of the question written on ）
   Novice ——python Solve the problem of removing elements with violence https://leetcode.cn/problems/remove-element/solution/by-zi-shan-long-wang-nr8n/
2. Detailed code

   class Solution(object):
       def removeElement(self, nums, val):
           """
           :type nums: List[int]
           :type val: int
           :rtype: int
           """
           n=len(nums)
           # count Record val The number of 
           # i Is a cyclic variable used to indicate the position 
           count=0
           i=0
   
           # Violent solution , Double cycle 
           # The first loop traverses the array elements 
           while (i<n-count):
               #  Judge whether it is equal to val, Equality enters the second cycle ; Unequal variables plus 1 Continue with the first loop 
               if nums[i]==val:
                   #  The second loop traverses all the elements after the equal elements and moves the whole forward one bit 
                   for j in range(i+1,n):
                       nums[j-1]=nums[j]
                   count+=1
               else:
                   i+=1
           #  Returns the difference between the length of the array and the number of repetitions 
           return n-count
   

3. Complexity of time and space ： Time complexity ：O(n^2)          Spatial complexity ：O(1)

  3、 ... and . Double pointer algorithm

     0.  Refer to the original topic ： come from Leetcode Question bank 26 topic

        26. Remove duplicate items from an ordered array

1. Algorithm ideas ： One for loop + Speed two pointers to replace the double in the violent solution for loop , The fast pointer is used to find the elements of the new array （ A new array is an array that does not contain duplicate elements ）, Need to follow for Loop through all elements in the original array ; The slow pointer is used to point to the position where the subscript of the new array is updated （ The update condition is whether the element referred to by the fast pointer is in the slice array in front of the slow pointer ）, Output as return value
2. Code implementation ：

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        #  Initialize speed pointer 
        fast=slow=0
        #  Into the loop 
        while fast<len(nums):
            #  Judge whether the elements are repeated 
            if nums[fast] not in nums[:slow]:
                #  Update the elements that meet the requirements 
                nums[slow]=nums[fast]
                slow+=1
            fast+=1
        return slow

Four . Related topic recommendation

283. Move zero

844. Compare strings with backspace

977. The square of an ordered array