leetcode 169,190,191,665,342,476,1290

169　　这算是个经典的问题了

 　　不讲码德可以这样做  时间复杂度(nlogn)

    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        return nums[nums.length/2];
    }

　　但是题目要求O(n)时间复杂度和O1空间复杂度，看了下题解，有个很神奇的解法，关于为什么这样做是对的，可以看官方题解 点击→ 传送门  

class Solution {
    public int majorityElement(int[] nums) {
    int k = 0;
        int tp = 0;
        for (int i = 0; i < nums.length; i++) {
            if (k == 0){
                tp = nums[i];
            }
            k += nums[i] == tp?1:-1;
        }
        return tp;
    }
}

190  简单题我重拳出击

  public static int reverseBits(int n) {
        int k = 0;
        for (int i = 0; i < 32; i++) {
            int t = (n>>i)&1;
            k^=(t<<(31-i));
        }
        return k;
  }

191

    public static int hammingWeight(int n) {
        int k = 0;
        for (int i = 0; i < 32; i++) {
            int t = (n>>i)&1;
            if (t == 1){
                k++;
            }
        }

        return k;
    }

231

    public static boolean isPowerOfTwo(int n) {
        if (n <= 0) return false;
        return  (n&(n-1)) == 0 ;
    }

268

class Solution {
    public int missingNumber(int[] nums) {
      int k = (nums.length+1)*(nums.length)/2;
        for (int num : nums) {
            k-=num;
        }

        return k;
    }
}

　　不过这题考察的是位运算,所以正确答案应该如下

    public static int missingNumber(int[] nums) {
        int s = 0;
        for (int i = 0; i <= nums.length; i++) {
            s ^= i;
        }
        for (int i = 0; i < nums.length; i++) {
            s ^= nums[i];
        }

        return s;
    }

665 这题虽然简单  不过因为要考虑到方方面面的情况，所以错误率极高，能一次通过也是难得。。。。

    public static boolean checkPossibility(int[] nums) {
        if (nums.length <=2){
            return true;
        }
        if (nums.length == 3  ){
            return !(nums[0] > nums[1] && nums[1] >nums[2]);
        }
        int k = 0;
        for (int i = 0; i < nums.length-1; i++) {
            if (i == nums.length-2 && k == 0){
                return true;
            }
            if (nums[i] > nums[i + 1]) {
                if (k >= 1){
                    return false;
                }
                k++;
                if (nums[i+1] > nums[i+2]) {
                    return false;
                }
                if (i == 0){
                    continue;
                }
                if (i > 0 && nums[i] > nums[i+2] && nums[i-1] > nums[i+1]   ){
                    return false;
                }

            }
        }

        return true;
    }

342 4的幂

 　　这题其实和2的幂有点像不过关键在于4的幂结果是这样的 1  100    10000   1000000   也就是说1会出现在0位    2位  4位  6位  关键应该是怎么能快速判断这个    不用循环的话  看题解的话普遍就是用  1010101010101010101010101010101 这个和n做与操作，如果结果为0说明是在奇数位就不符合

　　代码应该是如何的这种

bool isPowerOfFour(int num) {
    if (num < 0 || num & (num-1)){//check(is or not) a power of 2.
        return false;
    }
    return num & 0x55555555;//check 1 on odd bits
}

371 两数之和

 　　暴力解法。。

public static int getSum1(int a, int b) {
        int k = a|b;
        int s = a&b;
        boolean pre = false;
        int result = 0;
        for (int i = 0; i < 32; i++) {
            int p = (s>>i)&1;
            int t = (k>>i)&1;


            if (pre){
                //进位运算
                if (t ==1){//当前两有一个为1
                    if (p==1){
                        //进位 当前为1
                        result = result^(1<<i);
                        pre = true;
                    }else {
                        //进位 当前为0;
                        pre = true;
                    }
                }else {
                    //不进位  当前为1
                    result = result^(1<<i);
                    pre = false;
                }
            }else {
                if (t ==1){//当前两有一个为1
                    if (p==1){
                        //进位 当前为0
                        pre = true;
                    }else {
                        //不进位 当前为1;
                        result = result^(1<<i);
                        pre = false;
                    }
                }
            }
        }

        return result;
    }

476

    public static int findComplement(int num) {
       int hight = 0;
       while ((num>>hight) != 0){
           num^=(1<<hight);
           hight++;
       }
       return num;
    }

693

    public static boolean hasAlternatingBits(int n) {
        boolean one = (n&1) == 1;
        for (int i = 1; i < 32; i++) {
            if ((n >>i) == 0){
                return true;
            }
            boolean tone = ((n >>i)&1) == 1;
            if ((one && tone) || (!one && !tone)){
                return false;
            }
            one = tone;
        }
        return true;
    }

1290

class Solution {
    public boolean hasAlternatingBits(int n) {
        boolean one = (n&1) == 1;
        for (int i = 1; i < 32; i++) {
            if ((n >>i) == 0){
                return true;
            }
            boolean tone = ((n >>i)&1) == 1;
            if ((one && tone) || (!one && !tone)){
                return false;
            }
            one = tone;
        }
        return true;
    }
}