绝对最佳答案及分析：
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，就可以进行多少次这样的操作。

public class Solution {
    public double Power(double base, int exponent) {
        //数字的正数次方
        int flag=1;
        if(base==0)
            return 0;
        if(exponent<0){
            exponent=-exponent;
            flag=0;
            
        }
        double result=1;
        for(int i=0;i<exponent;i++){
            result*=base;
        }   
        
        if(flag==1){
            return result;
        }else{
            return result=1/result;
        }
        
  }
}

import java.util.ArrayList;
public class Solution {
    ArrayList<Integer> list=new ArrayList<Integer>();
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        int rows=matrix.length;   /矩阵的行数
        int cols=matrix[0].length; 矩阵的列数
        int start=0;
        while(rows>start*2&&cols>start*2){
            shundayin(matrix,rows,cols,start);
            start++;
        }
        return list;
    }
    
    
    public void shundayin(int[][] matrix,int rows,int cols,int start){
        
        /首先从左到右进行遍历
        for(int i=start;i<cols-start;i++){
            list.add(matrix[start][i]);
        }
        
        //接着从右到下进行遍历
        for(int j=start+1;j<rows-start;j++){
            list.add(matrix[j][cols-start-1]);
        }
        //接着从下到左进行遍历
        for(int k=cols-start-2;k>=start&&rows-start-1!=start;k--){
            list.add(matrix[rows-start-1][k]);
        }
        //接着从左到上开始比遍历
        for(int n=rows-start-2;n>start&&cols-start-1!=start;n--){
            list.add(matrix[n][start]);
        }
        
    }
}

public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> al = new ArrayList<Integer>();
        if (k > input.length) {
            return al;
        }
        for (int i = 0; i < k; i++) {
            for (int j = 0; j < input.length - i - 1; j++) {
                if (input[j] < input[j + 1]) {
                    int temp = input[j];
                    input[j] = input[j + 1];
                    input[j + 1] = temp;
                }
            }
            al.add(input[input.length - i - 1]);
        }
        return al;
    }

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list=new ArrayList<Integer>();
        if(input.length==0||input==null||input.length<k){
            return list;
        }

        
        for(int i=(k-1)/2;i>=0;i--){
            Adjust(input,i,k-1);
        }
        
        for(int i=k;i<input.length;i++){
            if(input[0]>input[i]){
                input[0]=input[i];
                Adjust(input,0,k-1);                
            }
        }
        
        for(int i=0;i<k;i++){
            list.add(input[i]);
        }
        return list;
    }
    
    
    ///构建一个大根堆
    public void Adjust(int[] input,int start,int end){
        int temp=input[start];
        int child=start*2+1;
        
        while(child<=end){
            
            if(child+1<=end&&input[child]<input[child+1])
                child++;
            
            if(input[child]<temp)
                break;
            
            input[start]=input[child];
            start=child;
            child=start*2+1;
        }
        input[start]=temp;
    }
}