Majority Element, Gray Code

Majority Element

Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times.
You may assume that the array is non-empty and the majority element always exist in the array.

Two pass solution

public int majorityElement(int[] num) {
    int n=num.length;
    HashMap<Integer, Integer> map=new HashMap<Integer, Integer>();
    for(int i=0;i<n;i++){
        if(!map.containsKey(num[i])) map.put(num[i], 1);
        else map.put(num[i], map.get(num[i])+1);
        if(map.get(num[i])>=(n/2)+1) return num[i];
    }
    return 0;
}

Moore voting algorithm

Basic idea of the algorithm is if we cancel out each occurrence of an element e with all the other elements that are different from e then e will exist till end if it is a majority element. This takes O(n) time.

  
  public int majorityElement(int[] num) {
    int n=num.length, count=1;
    int tmp=num[0];
    for(int i=1;i<n;i++){
        if(count==0) {tmp=num[i];count++;}
        else if(num[i]==tmp) count++;
        else count--;
    }
    return tmp;     
}

---

Gray Code

The gray code is a binary numeral system where two successive values differ in only one bit.
Given a non-negative integer n representing the total number of bits in the code, print the sequence of gray code. A gray code sequence must begin with 0.
For example, given n = 2, return [0,1,3,2]. Its gray code sequence is:

00 - 0
01 - 1
11 - 3
10 - 2

Note:
For a given n, a gray code sequence is not uniquely defined.
For example, [0,2,3,1] is also a valid gray code sequence according to the above definition.
For now, the judge is able to judge based on one instance of gray code sequence. Sorry about that.

Recursive solution

For 3 bit case: [0,1,3,2,6,7,5,4], we found that the first four numbers in case n=3 are the same as the the numbers in case n=2. Besides, [6,7,5,4] = [2+4,3+4,1+4,0+4].

public List<Integer> grayCode(int n) {
    List<Integer> ret = new ArrayList<Integer>();
    if (n == 0) {
        ret.add(0);
        return ret;
    }
    
    ret = grayCode(n - 1);
    
    for (int i = ret.size() - 1; i >= 0; i--) {
        int num = ret.get(i);
        num += 1 << (n - 1);
        ret.add(num);
    }
    
    return ret;
}

Iterative Solution

Use the above mentioned mirror image property:

public ArrayList<Integer> grayCode(int n) {
  ArrayList<Integer> result = new ArrayList<Integer>();
  if (n == 0) {
    result.add(0);
    return result;
  }
  ;
  result.add(0);
  result.add(1);
  for (int i = 1; i < n; i++) {
    ArrayList<Integer> tmp = new ArrayList<Integer>(result);
    Integer a = 1 << i;
    for (int k = result.size() - 1; k >= 0; k--) {
      tmp.add(result.get(k) + a);
    }
    result = tmp;
  }
  return result;
}