JZ11 - JZ15

JZ11 二进制中1的个数

该题中求二进制中1，考虑从低位出发，每次消除最低位的1，如
检测数字是n，那么其与n-1的与运算，会导致最低位的1变为0，通过这个性质，我们保存与运算的结果，
并将其存放在n中，只需要记录一共进行了多少次与运算后，n=0，就可以得到1的个数，代码如下：

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

JZ12 数值的整数次方

干脆文章名改为二进制的妙用吧
本题意在不使用pow() 库函数，如何得到答案，很简单，连乘对不对，但为了将时间复杂度降低到O(logn);采用的是二进制的方法，如果指数小于零，先对乘方数字进行翻转，并将指数变为正数之后再进行计算；

class Solution {
public:

    double Power(double b, int n) {
        if (n < 0) {
            b = 1 / b;
            n = -n;
        }
        double x = b; // 记录x^0, x^1, x^2 ...
        double ret = 1.0;
        while (n) {
            if (n&1) {
                ret *= x; // 二进制位数是1的，乘进答案。
            }
            x *= x;
            n >>= 1;
        }
        return ret;
    }
};

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

调整顺序，分奇偶，那么可以先看看有多少奇数，定义两个指针，分别指向奇数和偶数的开头；

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param array int整型vector 
     * @return int整型vector
     */
    vector<int> reOrderArray(vector<int>& array) {
        // write code here
        int low=0,mid=0;
        for(int i=0;i<array.size();i++){
            if(array[i] & 1) mid++;
        }
        vector<int> ans(array.size(),0);
        for(int i=0;i<array.size();i++){
            if(array[i] & 1) ans[low++]=array[i];
            else ans[mid++]=array[i];
        }
        return ans;
    }
};

JZ14 链表中倒数最后k个结点

描述：
输入一个长度为n的链表，设链表中的元素的值为ai，输出一个链表，该输出链表包含原链表中从倒数第k个结点至尾节点的全部节点。
如果该链表长度小于k，请返回一个长度为 0 的链表。

//这很难不让人想到链表中的翻转，就等价于输出前n个结点，让第n个节点指向nullptr即可；
同时也可以定义一个int变量记录链表长度，如果长度小于返回值K，那么直接返回nullptr；

方法二：栈

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    ListNode* FindKthToTail(ListNode* pHead, int k) {
        // write code here
        stack<ListNode *> s;
        ListNode *p=pHead,*ans=nullptr;
        while(p){
            s.push(p);
            p=p->next;
        }
        int i=0;
        if(k>s.size()) return ans;
        while(i<k){
            i++;
            ans=s.top();
            s.pop();
        }
        return ans; 
    }
};

方法1，标记起始位置：

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    ListNode* FindKthToTail(ListNode* pHead, int k) {
        // write code here
        ListNode* p = pHead,* q = pHead;
        int count = 0;
        while(p){
            p = p->next;
            count++;
        }
        if(count<k) return nullptr;
        else{
            while(count-- > k){
                q = q->next;
            }
            return q;
        }
        return nullptr;
    }
};

JZ15 反转链表

经典空间复杂度O(1),时间复杂度O(n)

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        ListNode *cur=pHead,*pre=nullptr,*temp;
        while(cur){
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

基本无难题，注意时间和空间复杂度，做到最简最佳