剑指offer【整理】-Java版-02

7. 二进制中1的个数

输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

绝对最佳答案及分析：

public class Solution {
    public int NumberOf1(int n) {
        int count = 0;
        while(n!= 0){
            count++;
            n = n & (n - 1);
         }
        return count;
    }
}

答案正确:恭喜！您提交的程序通过了所有的测试用例

分析一下代码：  这段小小的代码，很是巧妙。

如果一个整数不为0，那么这个整数至少有一位是1。如果我们把这个整数减1，那么原来处在整数最右边的1就会变为0，原来在1后面的所有的0都会变成1(如果最右边的1后面还有0的话)。其余所有位将不会受到影响。

举个例子：一个二进制数1100，从右边数起第三位是处于最右边的一个1。减去1后，第三位变成0，它后面的两位0变成了1，而前面的1保持不变，因此得到的结果是1011.我们发现减1的结果是把最右边的一个1开始的所有位都取反了。这个时候如果我们再把原来的整数和减去1之后的结果做与运算，从原来整数最右边一个1那一位开始所有位都会变成0。如1100&1011=1000.也就是说，把一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0.那么一个整数的二进制有多少个1，就可以进行多少次这样的操作。

8.  数值的整数次方

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

public class Solution {
    public double Power(double base, int e) {
        int x = Math.abs(e);
        if(base==0.0||base==1.0){
            return base;
        }
        if(e==0){
            return 1.0;
        }
        double res = 1,tem = base;
        while(x>0){
            if((x&1)!=0){
                res *= tem;
            }
            tem *= tem;
            x >>= 1;
        }
        return e > 0 ? res : 1/res;
  }
}

9.  调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

方法1： 类似 冒泡排序      

public class Solution {
    public void reOrderArray(int [] arr) {
        if(arr==null||arr.length==0||arr.length==1){
            return;
        }
        int temp = 0;
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if((arr[j]%2==0)&&(arr[j+1]%2!=0)){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

方法2： 新建一个长度相同的数组，查出奇数个数 填空即可；

public class Solution {
    public void reOrderArray(int [] array) {
        if(array.length==0||array.length==1) return;
        int oddCount=0,oddBegin=0;
        int[] newArray=new int[array.length];
        for(int i=0;i<array.length;i++){
            if((array[i]&1)==1) oddCount++;
        }
        for(int i=0;i<array.length;i++){
            if((array[i]&1)==1) newArray[oddBegin++]=array[i];
            else newArray[oddCount++]=array[i];
        }
        for(int i=0;i<array.length;i++){
            array[i]=newArray[i];
        }
    }
}

10. 链表中倒数第k个结点

输入一个链表，输出该链表中倒数第k个结点。

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindKthToTail(ListNode h,int k) {
		if(h==null||k<1){
            return null;
        }
        ListNode c = h;
        int n = 0;
        while(c!=null){
            n++;
            c = c.next;
        }
        int p = n-k;
        if(p==0){
            return h;
        }else if(p<0){
            return null;
        }else{
            c = h; 
            while(p>0){
                c = c.next;
                p--;
            }
            return c;
        }
    }
}

11.  反转链表

输入一个链表，反转链表后，输出链表的所有元素。

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode h) {
	if(h==null||h.next==null){
            return h;
        }
        ListNode pre = null,next = null;
        while(h!=null){
            next = h.next;
            h.next = pre;
            pre = h;
            h = next;
        }
        return pre;
    }
}

12.  合并两个排序的链表

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode h1,ListNode h2) {
        if(h1==null){
            return h2;
        }
        if(h2==null){
            return h1;
        }
        ListNode h0 = h1.val<h2.val?h1:h2;
        ListNode cur = h0;
        h1 = h0==h1 ? h1.next:h1;
        h2 = h0==h2 ? h2.next:h2;
        while(h1!=null&&h2!=null){
            if(h1.val<h2.val){
                cur.next = h1;
                h1 = h1.next;
            }else{
                cur.next = h2;
                h2 = h2.next;
            }
            cur = cur.next;
        }
        while(h1!=null){
            cur.next = h1;
            cur = cur.next;
            h1 = h1.next;
        }
        while(h2!=null){
            cur.next = h2;
            cur = cur.next;
            h2 = h2.next;
        }
        return h0;
    }
}