二进制算法题+回文链表

---

一、剑指 Offer II 002. 二进制加法

1. 先计算两个字符串公共的部分，需要维护三个变量：两个数组的指针idx+一个进位变量up
2. 注意，这里用StringBuffer来存储结果，先存储的是个位，所以最后需要reverse一下。

    public String addBinary(String a, String b) {
        char[] ca = a.toCharArray();
        char[] cb = b.toCharArray();
        // for(int i=ca.length-1;i>=0;i--){
        //     int sum = ca[i]+cb[i];
        //     if(sum>1){

        //     }
        // }

        int idxa = ca.length-1;
        int idxb = cb.length-1;
        int up=0;
        StringBuffer sb = new StringBuffer();//用来记录最终结果
        while(idxa>=0&&idxb>=0){//先计算公共的部分
            int val = (ca[idxa]-'0')+(cb[idxb]-'0')+up;
            sb.append(val%2);
            up=val/2;
            idxa--;
            idxb--;
        }
        while(idxa>=0){
            int val = (ca[idxa]-'0')+up;
            sb.append(val%2);
            up=val/2;
            idxa--;
        }
        while(idxb>=0){
            int val = (cb[idxb]-'0')+up;
            sb.append(val%2);
            up=val/2;
            idxb--;
        }
        if(up==1){
            sb.append("1");
        }
        return sb.reverse().toString();

    }

21分钟

二、693. 交替位二进制数

1. 如何看一个字符是否在变化？维护一个temp变量来记录他上一次的结果。
2. 模拟十进制转二进制：先对2求余得到低位，再除以2得到下一个数。

    public boolean hasAlternatingBits(int n) {
        int temp=-1;
        while(n>0){
            int wei = n%2;
            if(wei==temp){
                return false;
            }
            temp=wei;
            n=n/2;
        }
        return true;
    }

10分钟

三、剑指 Offer 15. 二进制中1的个数

• 自己看到题目的第一想法

• 看完题解之后的想法

• 自己实现过程中遇到的问题总结

    public int hammingWeight(int n) {
        // String s = String.valueOf(n);
        String s = Integer.toBinaryString(n);
        int num=0;
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)=='1'){
                num++;
            }
        }
        return num;
    }

29分钟

四、剑指 Offer II 027. 回文链表

1. 链表无法双指针遍历，所以先反转后半段链表（这里需要先知道中心点）。
2. 有几个地方需要注意：1.如果是奇数节点，需要中心点向后移动一位。2.判断回文的终止条件是右指针为空。

    public boolean isPalindrome(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while(fast!=null&&fast.next!=null){
            slow=slow.next;
            fast=fast.next.next;
        }//先找到中心点
        // if(fast!=null){
        //     fast=fast.next;
        // }
        if(fast!=null){
            slow=slow.next;
        }
        ListNode right = reverse(slow);
        ListNode left=head;
        // while(left!=null&&right!=null){
        while(right!=null){
            if(left.val!=right.val){
                return false;
            }
            left=left.next;
            right=right.next;
        }
        return true;

    }
    public ListNode reverse(ListNode head){
        ListNode pre = null;
        ListNode cur = head;
        while(cur!=null){
            ListNode next = cur.next;
            cur.next=pre;
            pre = cur;
            cur=next;
        }
        return pre;

    }

总结