查找列表中出现奇数次的元素

Question

Let's say we need to find all the elements occurring an odd number of times in a sorted list in O(N) time and O(1) space complexity.

ls = [1,2,2,3,3,3,4,5,5,6,6,6,6,6]        
output = [1,3,4,6]

We are not going to return a new list, perhaps will be overwrite the existing one

I have an approach which uses a hashing technique, but it results in O(N) space complexity.

I have tried bitwise manipulation using XOR, but I am not able to solve the question.

Answer 1

Iterate through the list, counting cases where the present item is the same as the previous one, and overwriting towards the start of the list when it is different and the count is an odd number.

This solution overwrites the existing list rather than allocating a new one, and has O(N) time complexity. Because the new list will be shorter, we have to pop the remaining items from the end of it. (We would normally splice using ls = ls[position:] but that would assign a new list, which isn't allowed.)

def keep_odd_elements(ls):
    count = 0
    write_position = 0
    previous = object()
    for item in ls:
        if item == previous:
            count += 1
        else:
            # Write the odd-counted numbers towards the start of the list
            if count % 2:
                ls[write_position] = previous
                write_position += 1
            count = 1
        previous = item
    if count % 2:
        ls[write_position] = previous
        write_position += 1
    # Remove the leftover items at the end of the list
    for i in range(write_position, len(ls)):
        ls.pop()
    
ls = [1,2,2,3,3,3,4,5,5,6,6,6,6,6]
keep_odd_elements(ls)
print(ls)   # [1, 3, 4, 6]

If we remove the requirement not to allocate a new list, then we can write this much more elegantly:

def get_odd_elements(ls):
    count = 0
    for previous, item in zip([object()] + ls, ls + [object()]):
        if item == previous:
            count += 1
        else:
            if count % 2:
                yield previous
            count = 1

print(list(get_odd_elements([1,2,2,3,3,3,4,5,5,6,6,6,6,6])))

Answer 2

This is C++ code that runs in O(n) and use O(1) auxiliary memory.

The idea behind this code is very simple, we start from left and counting number of occurrence of a number x until we arrive to a number y that not equal x , because of our input is sorted it guarantee that x never appear after y . So it's sufficient to check if number of occurrence of x be odd.

Note that, if the array is not sorted it's provable that, you can't do better than O(nlogn)

 //Find odd numbers in given sorted list

#include <stdio.h>

int main(){
    
  int ArrayLength;
  scanf("%d",&ArrayLength);
  int array[ArrayLength];
  

  //Read input sorted array
  for ( int i = 0; i < ArrayLength; i++)
       scanf("%d",&array[i]);
       

  // Find numbers with odd occurrence 
  int PreviousLocalOdd=array[0];
  int LocalOdd=1;
  for ( int i = 1; i < ArrayLength; i++)
    {

        if (array[i]==PreviousLocalOdd)
            LocalOdd++;
        
        if(array[i]!= PreviousLocalOdd)    
          {  
                if(LocalOdd % 2==1)
                    printf("%d",array[i-1]);
            LocalOdd=1;
            PreviousLocalOdd=array[i];
          }
     
    }
       if(LocalOdd % 2==1)
        printf("%d ",array[ArrayLength-1]);


return 0;
}    

Answer 3

To return an array without creating a new one in the function we can use two ways:

1. Add the answer to the existing array then delete the array elements a the end and return only the extra added answer values.

Cons: Manipulating the given array is not always recommended as the function could be used in other places like a result comparing function, in which case this would fail.

2. To send the address of a blank array from the mail itself. and add elements to it by reference. if we are not solving a prototype given function, we can easily make this addition to not create any extra space in the function itself

• If the elements are always <= n(size of the array) and positive and not in sorted order, you can change the value at any index. At the end loop through the array again and check the values which are negative. Then the positions can be added to answer array.

    for(int i=0; i<arr.size(); i++){
       currElement = mod(arr[i]);
       arr[currElement] = arr[currElement]*-1;
    }
    for(int i=0; i<arr.size(); i++){
       if(arr[i]<0){
          ans.push_back(mod(arr[i]));
       }
    }

• If they are in sorted order, while looping itself you can check if the max occurrence of a number is odd(by adjacent comparison) then add them to final answer.

    prev = -1;
    count= 0;
    for(int i=0; i<arr.size(); i++){
       if(arr[i]==prev){
           count++;
       }else{
          if(count%2!=0)
             ans.push_back(prev);
          count=1;
          prev=arr[i];
       }
    }