剑指offer

1）二维数组中的查找
在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

class Solution {public:    bool Find(int target, vector<vector<int> > array) {        if(array.size() <= 0)            return false;        int rows = array.size();        int cols = array[0].size();        int i = 0, j = cols-1;        while(i < rows && j >= 0)        {            if(array[i][j] == target)                return true;            else if(array[i][j] > target)                j--;            else                i++;        }        return false;    }};

2）替换空格
请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

class Solution {public:    void replaceSpace(char *str,int length) {        if(str == NULL || length <= 0)            return ;        int count = 0;        for(int i=0; i<strlen(str); i++)        {            if(str[i] == ' ')                count++;        }        int newLength = strlen(str) + count * 2 + 1;        if(newLength > length)            return ;        int i = strlen(str) + 1;        int j = newLength;        while(i >= 0 && j > i)        {            if(str[i] == ' ')            {                str[j--] = '0';                str[j--] = '2';                str[j--] = '%';            }            else                str[j--] = str[i];            i--;        }    }};

3)从尾到头打印链表
输入一个链表，从尾到头打印链表每个节点的值

/***  struct ListNode {*        int val;*        struct ListNode *next;*        ListNode(int x) :*              val(x), next(NULL) {*        }*  };*/class Solution {public:    vector<int> res;    vector<int> printListFromTailToHead(ListNode* head) {        if(head == NULL)            return res;        if(head->next)            res = printListFromTailToHead(head->next);        res.push_back(head->val);        return res;    }};

4)重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回

/** * Definition for binary tree * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {        if(pre.size() == 0 || vin.size() == 0)            return NULL;        return constructTree(pre, 0, pre.size()-1, vin, 0, vin.size()-1);    }    TreeNode* constructTree(const vector<int>& pre, int s1, int e1, const vector<int>& vin, int s2, int e2)    {        int i;        for(i=s2; i<=e2; i++)        {            if(vin[i] == pre[s1])                break;        }        if(i > e2)            return NULL;        TreeNode* head = new TreeNode(pre[s1]);        head->left = constructTree(pre, s1+1, s1+i-s2, vin, s2, i-1);        head->right = constructTree(pre, s1+i-s2+1, e1, vin, i+1, e2);        return head;    }};

5)两个栈实现队列
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

class Solution{public:    void push(int node) {        stack1.push(node);    }    int pop() {        if(stack2.empty())        {            while(!stack1.empty())            {                stack2.push(stack1.top());                stack1.pop();            }        }        int res = -1;        if(!stack2.empty())        {            res = stack2.top();            stack2.pop();        }        return res;    }private:    stack<int> stack1;    stack<int> stack2;};

6)旋转数组的最小数字
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

class Solution {public:    int minNumberInRotateArray(vector<int> rotateArray) {        if(rotateArray.size() == 0)            return 0;        int i = 0, j= rotateArray.size()-1;        int mid = i;        while(rotateArray[i] >= rotateArray[j])        {            if(j -  i == 1)            {                mid = j;                break;            }                       mid = (i + j) / 2;            if(rotateArray[i] == rotateArray[mid] && rotateArray[mid] == rotateArray[j])                return midNumber(rotateArray, i, j);            if(rotateArray[mid] >= rotateArray[i])                i = mid;            else if(rotateArray[mid] <= rotateArray[j])                j = mid;                    }        return rotateArray[mid];    }    int midNumber(const vector<int>& rotateArray, int start, int end)    {        int min = rotateArray[start];        for(int i=start+1; i<=end; i++)            if(rotateArray[i] < min)                min = rotateArray[i];        return min;    }};

7)斐波那契数列
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。n<=39

class Solution {public:    int Fibonacci(int n) {        if(n < 2)            return n;        int a = 0, b = 1;        int c = 0;        for(int i=2; i<=n; i++)        {            c = a + b;            a = b;            b = c;        }        return c;    }};

8)跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

class Solution {public:    int jumpFloor(int number) {        if(number == 1)            return 1;        else if(number == 2)            return 2;        int a = 1, b = 2, c;        for(int i=3; i<=number; i++)        {            c = a + b;            a = b;            b = c;        }        return c;    }};

9)变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

class Solution {public:    int jumpFloorII(int number) {  // f(n) = 2^(n-1)        return 1 << (number -1);    }};

10)矩形覆盖
我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
解析：用第一个1×2小矩形去覆盖大矩形的最左边时有两个选择，竖着放和横着放，当竖着放时右边还剩下2×(n-1)的区域，这种情况下的覆盖方法记为f(n-1)
当横着放在左上角的时候，左下角必须横着放一个1×2的小矩形，而右边还剩下2×6的区域，这种情况下的覆盖方法记为f(n-2).

class Solution {public:    int rectCover(int number) {        if(number <= 2)            return number;        int a = 1, b = 2;        int c;        for(int i=3; i<=number; i++)        {            c = a + b;            a = b;            b = c;        }        return c;    }};

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

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

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

class Solution {public:    double Power(double base, int exponent) {        if(equal(base, 0.0) && exponent < 0)            return 0.0;        unsigned int absExponent = abs(exponent);        double result = PowerWithUnsignedExponent(base, absExponent);        if(exponent < 0)            result = 1.0 / result;        return result;    }    bool equal(double num1, double num2)    {        if(num1 - num2 < 0.0000001 && num1 - num2 > -0.0000001)            return true;        return false;    }        double PowerWithUnsignedExponent(double base, unsigned int exponent)    {        if(exponent == 0)            return 1;        else if(exponent == 1)            return base;        double result = PowerWithUnsignedExponent(base, exponent>>1);        result *= result;        if(exponent & 0x1 == 1)            result *= base;        return result;    }};

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

class Solution {public:    void reOrderArray(vector<int> &array) {        int n = array.size();        if(n <= 1)            return ;        vector<int> tmp(n);        int oddCount = 0;        for(int i=0; i<n; i++)        {            if(array[i] & 0x1)            {                tmp[oddCount] = array[i];                oddCount++;            }                       }        for(int i=0; i<n; i++)        {            if((array[i] & 0x1) == 0)   // & 的优先级小于 ==                tmp[oddCount++] = array[i];        }        array = tmp;    }};

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

/*struct ListNode {    int val;    struct ListNode *next;    ListNode(int x) :            val(x), next(NULL) {    }};*/class Solution {public:    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {        if(pListHead == NULL || k == 0)            return NULL;        ListNode* pFast = pListHead;        ListNode* pSlow = pListHead;        for(unsigned int i=0; i<k-1; i++)        {            if(pFast->next == NULL)                return NULL;            pFast = pFast->next;        }        while(pFast->next != NULL)        {            pSlow = pSlow->next;            pFast = pFast->next;        }        return pSlow;    }};

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

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

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

/*struct ListNode {    int val;    struct ListNode *next;    ListNode(int x) :            val(x), next(NULL) {    }};*/class Solution {public:    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)    {        if(pHead1 == NULL)            return pHead2;        else if(pHead2 == NULL)            return pHead1;        ListNode* newHead = NULL;        if(pHead1->val < pHead2->val)        {            newHead = pHead1;            newHead->next = Merge(pHead1->next, pHead2);        }        else        {            newHead = pHead2;            newHead->next = Merge(pHead1, pHead2->next);        }                    return newHead;    }};

17)树的子结构
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

/*struct TreeNode {    int val;    struct TreeNode *left;    struct TreeNode *right;    TreeNode(int x) :            val(x), left(NULL), right(NULL) {    }};*/class Solution {public:    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)    {        if(pRoot1 == NULL || pRoot2 == NULL)            return false;        bool res = false;        if(pRoot1->val == pRoot2->val)            res = IsSubtree(pRoot1, pRoot2);        if(!res)            res = HasSubtree(pRoot1->left, pRoot2) || HasSubtree(pRoot1->right, pRoot2);        return res;    }        bool IsSubtree(TreeNode* pRoot1, TreeNode* pRoot2)    {        if(pRoot2 == NULL)            return true;        if(pRoot1 == NULL)            return false;        if(pRoot1->val != pRoot2->val)            return false;        return IsSubtree(pRoot1->left, pRoot2->left) && IsSubtree(pRoot1->right, pRoot2->right);    }}; 

18)二叉树的镜像
操作给定的二叉树，将其变换为源二叉树的镜像。

/*struct TreeNode {    int val;    struct TreeNode *left;    struct TreeNode *right;    TreeNode(int x) :            val(x), left(NULL), right(NULL) {    }};*/class Solution {public:    void Mirror(TreeNode *pRoot) {        if(pRoot == NULL)            return ;        TreeNode* temp = pRoot->left;        pRoot->left = pRoot->right;        pRoot->right = temp;        if(pRoot->left)            Mirror(pRoot->left);        if(pRoot->right)            Mirror(pRoot->right);    }};

19)顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

class Solution {public:    vector<int> printMatrix(vector<vector<int> > matrix) {        vector<int> res;        int rows = matrix.size();        int cols = matrix[0].size();        if(rows == 0 || cols == 0)            return res;        int left = 0, top = 0;        int right = cols-1, bottom = rows-1;        while(top <= bottom && left <= right)        {            int i, j;            for(j=left; j<=right; j++)                res.push_back(matrix[top][j]);                for(i=top+1; i<=bottom; i++)                res.push_back(matrix[i][right]);            if(top < bottom)            {                for(j=right-1; j>left; j--)                          res.push_back(matrix[bottom][j]);            }                    if(left < right)            {                   for(i=bottom; i>top; i--)                      res.push_back(matrix[i][left]);            }            top++;            left++;            right--;            bottom--;        }        return res;    }};

20)包含min函数的栈
定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。

class Solution {private:    stack<int> s1, s2;public:    void push(int value) {        if(s1.size() > 0 && s1.top() < value)            s2.push(s1.top());        else            s2.push(value);        s1.push(value);       }    void pop() {        s1.pop();        s2.pop();    }    int top() {        return s1.top();    }    int min() {        return s2.top();    }};

21)栈的压入、弹出序列
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列  4, 5, 3, 2, 1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

class Solution {public:    bool IsPopOrder(vector<int> pushV,vector<int> popV) {        stack<int> temp;        int n = pushV.size();        if(n == 0)            return true;        int i =0, j = 0;        while(j < n)        {            while(temp.empty() || temp.top() != popV[j])            {                if(i == n)                    break;                temp.push(pushV[i]);                i++;            }            if(temp.top() != popV[j])                break;                         temp.pop();             j++;        }        if(j == n && temp.empty())            return true;        return false;    }};

22)从上到下打印二叉树
从上往下打印出二叉树的每个节点，同层节点从左至右打印。

/*struct TreeNode {    int val;    struct TreeNode *left;    struct TreeNode *right;    TreeNode(int x) :            val(x), left(NULL), right(NULL) {    }};*/class Solution {public:    vector<int> PrintFromTopToBottom(TreeNode* root) {        vector<int> res;        if(root == NULL)            return res;        queue<TreeNode*> q;        q.push(root);        while(!q.empty())        {            TreeNode* node = q.front();            res.push_back(node->val);            q.pop();            if(node->left)                q.push(node->left);            if(node->right)                q.push(node->right);        }        return res;    }};

23)二叉搜索树的后序遍历序列
 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

class Solution {public:    bool VerifySquenceOfBST(vector<int> sequence) {        if(sequence.size() == 0)            return false;        return VerifyBST(sequence, 0, sequence.size()-1);    }        bool VerifyBST(const vector<int>& sequence, int start, int end)    {        int i, j;        //if(start == end)            //return true;        for(i=start; i<end; i++)        {            if(sequence[i] > sequence[end])                break;        }        j = i - 1;        while(i < end)        {            if(sequence[i] < sequence[end])                return false;            i++;        }        bool left = true;        if(j > start)  //if(j >= start)            left = VerifyBST(sequence, start, j);        bool right = true;        if(j + 1 < end - 1)  //if(j + 1 <= end -1)            right = VerifyBST(sequence, j+1, end-1);               return left && right;    }};

24) 二叉树中和为某一值的路径
输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

/*struct TreeNode {    int val;    struct TreeNode *left;    struct TreeNode *right;    TreeNode(int x) :            val(x), left(NULL), right(NULL) {    }};*/class Solution {public:    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {        vector<vector<int> > res;        if(root == NULL)            return res;        vector<int> solution;        findPath(root, expectNumber, solution, res);        return res;    }        void findPath(TreeNode* root, int expectNumber, vector<int>& solution, vector<vector<int> >& res)    {        int sum = expectNumber - root->val;        solution.push_back(root->val);        if(root->left == NULL && root->right == NULL && sum == 0)        {            res.push_back(solution);            //return ;        }        if(root->left)            findPath(root->left, sum, solution, res);        if(root->right)            findPath(root->right, sum, solution, res);        solution.pop_back();       }};

25)复杂链表的复制
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

/*struct RandomListNode {    int label;    struct RandomListNode *next, *random;    RandomListNode(int x) :            label(x), next(NULL), random(NULL) {    }};*/class Solution {          // 个人版public:    RandomListNode* Clone(RandomListNode* pHead)    {        if(pHead == NULL)            return NULL;        copyList(pHead);        copyRandom(pHead);        return split(pHead);    }        void copyList(RandomListNode* pHead)    {        RandomListNode* pNode = pHead;        while(pNode)        {            RandomListNode* pn = pNode->next;            RandomListNode* p = new RandomListNode(pNode->label);            p->next = pn;            pNode->next = p;            pNode = pn;        }    }        void copyRandom(RandomListNode* pHead)    {        RandomListNode* pNode = pHead;        while(pNode)        {            RandomListNode* pNew = pNode->next;            if(pNode->random)                pNew->random = pNode->random->next;            pNode = pNew->next;        }    }        RandomListNode* split(RandomListNode* pHead)    {        RandomListNode* pNode = pHead;        RandomListNode* pNewHead = pNode->next;        RandomListNode* p = pNode->next;        while(p->next)        {            pNode->next = p->next;            pNode = pNode->next;            p->next = pNode->next;            p = p->next;        }        pNode->next = NULL;        p->next = NULL;               return pNewHead;    }};

class Solution {     // 剑指offerpublic:    RandomListNode* Clone(RandomListNode* pHead)    {        if(pHead == NULL)            return NULL;        copyList(pHead);        copyRandom(pHead);        return split(pHead);    }        void copyList(RandomListNode* pHead)    {        RandomListNode* pNode = pHead;        while(pNode)        {            RandomListNode* pn = pNode->next;            RandomListNode* p = new RandomListNode(pNode->label);            p->next = pn;            pNode->next = p;            pNode = pn;        }    }        void copyRandom(RandomListNode* pHead)    {        RandomListNode* pNode = pHead;        while(pNode)        {            RandomListNode* pNew = pNode->next;            if(pNode->random)                pNew->random = pNode->random->next;            pNode = pNew->next;        }    }        RandomListNode* split(RandomListNode* pHead)    {        RandomListNode* pNode = pHead;        RandomListNode* pNewHead;        RandomListNode* p;        if(pNode)        {            pNewHead = pNode->next;            p = pNode->next;            pNode->next = p->next;            pNode = pNode->next;        }                while(pNode)        {            p->next = pNode->next;            p = p->next;            pNode->next = p->next;            pNode = pNode->next;        }        return pNewHead;    }};

26)二叉搜索树与双向链表
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

/*struct TreeNode {    int val;    struct TreeNode *left;    struct TreeNode *right;    TreeNode(int x) :            val(x), left(NULL), right(NULL) {    }};*/class Solution {public:    TreeNode* Convert(TreeNode* pRootOfTree)    {        if(pRootOfTree == NULL)            return NULL;        TreeNode* pLastNode = NULL;        ConvertNode(pRootOfTree, pLastNode);        while(pLastNode->left != NULL)            pLastNode = pLastNode->left;        return pLastNode;    }        void ConvertNode(TreeNode* pRootOfTree, TreeNode*& pLastNode)    {        if(pRootOfTree == NULL)            return ;        if(pRootOfTree->left)            ConvertNode(pRootOfTree->left, pLastNode);        pRootOfTree->left = pLastNode;        if(pLastNode)            pLastNode->right = pRootOfTree;        pLastNode = pRootOfTree;                if(pRootOfTree->right)            ConvertNode(pRootOfTree->right, pLastNode);    }};

27)字符串的排列
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
输入描述:  输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母

class Solution {public:    vector<string> Permutation(string str) {        vector<string> res;        int n = str.length();        if(n == 0)            return res;        Permutation2(str, 0, n, res);        sort(res.begin(), res.end());        return res;    }        void Permutation2(string& str, int k, int n, vector<string>& res)    {        if(k == n)        {            res.push_back(str);            return ;        }        for(int i=k; i<n; i++)        {            if(str[i] == str[k] && i != k)                continue;            swap(str[k], str[i]);            Permutation2(str, k+1, n, res);            swap(str[k], str[i]);        }    }};

28)数组中出现次数超过一半的数字
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

class Solution {public:    int MoreThanHalfNum_Solution(vector<int> numbers) {        int res = 0;        int count = 0;        for(int i=0; i<numbers.size(); i++)        {            if(count == 0)            {                res = numbers[i];                count++;            }            else if(numbers[i] == res)            {                count++;            }            else            {                count--;            }        }        if(res)        {            count = 0;            for(int i=0; i<numbers.size(); i++)            {                if(numbers[i] == res)                    count++;            }            if(count * 2 <= numbers.size())                res = 0;        }        return res;    }};

29)最小的K个数
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4

// 方法一class Solution {public:    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {        vector<int> res;        int n = input.size();        if(n == 0 || k > n || k <= 0)            return res;        int start = 0, end = n-1;        int mid = partition(input, start, end);        while(mid != k-1)        {            if(mid > k-1)            {javascript:void(0);               end = mid - 1;               mid = partition(input, start, end);            }            else            {                start = mid + 1;                mid = partition(input, start, end);                            }        }        for(int i=0; i<k; i++)            res.push_back(input[i]);        return res;    }        int partition(vector<int>& input, int start, int end)    {        int key = input[start];        while(start < end)        {            while(start < end && input[end] >= key)                end--;            input[start] = input[end];            while(start < end && input[start] <= key)                start++;            input[end] = input[start];        }        input[start] = key;        return start;    }};

// 方法二//利用大根堆，适合处理海量数据    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {        int n = input.size();        if(n == 0 || n < k || k <= 0)            return vector<int>();        multiset<int, greater<int> > leastNumbers;        for(int i=0; i<n; i++)        {            if(i < k)                leastNumbers.insert(input[i]);            else            {                multiset<int, greater<int> >::const_iterator iter = leastNumbers.begin();                if(*iter > input[i])                {                    leastNumbers.erase(iter);                    leastNumbers.insert(input[i]);                }            }        }        vector<int> res(leastNumbers.begin(), leastNumbers.end());        return res;    }

30)连续子数组的最大和
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8 ( 从第0个开始,到第3个为止)。你会不会被他忽悠住？(子向量的长度至少是1)

class Solution {public:    int FindGreatestSumOfSubArray(vector<int> array) {        int n = array.size();        if(n == 0)            return 0;        int sum = 0;        int maxSum = INT_MIN;        for(int i=0; i<n; i++)        {            if(sum <= 0)                sum = array[i];            else                sum += array[i];            if(sum > maxSum)                maxSum = sum;    //maxSum = max(sum, maxSum);        }        return maxSum;    }};

31)整数中1出现的次数(从1到n整数中1出现的次数)
求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数。

    int NumberOf1Between1AndN_Solution(int n)  // 简洁写法    {        int i = 1;        int high = 0, low = 0;        int cur = 0;        int res = 0;        while(n / i)        {            cur = (n / i) % 10;            high = n / (i * 10);            low = n - n / i * i;            if(cur > 1)                res += high * i + i;            else if(cur == 1)                res += high * i + low + 1;            else                res += high * i;            i *= 10;        }        return res;    }

class Solution {public:    int NumberOf1Between1AndN_Solution(int n)    {        int number = n;        int bits = 0;        while(number)        {            bits++;            number /= 10;        }        int res = 0;        int low = 0, high = 0;        int cur = 0;        for(int i=0; i<bits; i++)        {            if(i == 0)            {                low = 0;                cur = n % 10;                high = n / power(10, i+1);            }            else            {                low = n % power(10, i);                cur = (n / power(10, i)) % 10;                if(i == bits - 1)                    high = 0;                else                    high = n / power(10, i+1);            }                        if(cur > 1)                res += high * power(10, i) + power(10, i);            else if(cur == 1)                res += high * power(10, i) + low + 1;            else                res += high * power(10, i);        }        return res;    }        int power(int a, int b)    {        int res = 1;        while(b--)           res *= a;        return res;    }};

32) 把数组排成最小的数
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

class Solution {public:    string PrintMinNumber(vector<int> numbers) {        vector<string> strNum;        for(int i=0; i<numbers.size(); i++)        {            string s = to_string(numbers[i]);            strNum.push_back(s);        }        sort(strNum.begin(), strNum.end(), cmp);        string res = "";        for(int i=0; i<strNum.size(); i++)            res += strNum[i];        return res;    }        static bool cmp(const string s1,const string s2)    {        string num1 = s1 + s2;        string num2 = s2 + s1;        return num1 < num2;    }};

33)丑数
 把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

class Solution {public:    int GetUglyNumber_Solution(int index) {        if(index <= 0)            return 0;                int i = 1;        int two = 0;        int three = 0;        int five = 0;        vector<int> ugly(index, 0);        ugly[0] = 1;        while(i < index)        {            ugly[i] = min(min(ugly[two] * 2, ugly[three] * 3), ugly[five] * 5);            while(ugly[two] * 2 <= ugly[i])                two++;            while(ugly[three] * 3 <= ugly[i])                three++;            while(ugly[five] * 5 <= ugly[i])                five++;                        i++;        }        return ugly[index-1];    }};

34)第一个只出现依次的字符
在一个字符串(1<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置

class Solution {public:    int FirstNotRepeatingChar(string str) {        vector<int> num(256, 0);        int n = str.length();        if(n == 0)            return -1;        for(int i=0; i<n; i++)        {            int c = str[i];            num[c]++;        }        int res = -1;        for(int i=0; i<n; i++)        {            if(num[str[i]] == 1)            {                res = i;                break;            }        }        return res;    }};

35)数组中的逆序对
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
 输入描述:题目保证输入的数组中没有的相同的数字
    数据范围：
        对于%50的数据,size<=10^4
        对于%75的数据,size<=10^5
        对于%100的数据,size<=2*10^5

class Solution {public:    int InversePairs(vector<int> data) {        int n = data.size();        if(n == 0)            return 0;        int count = 0;        MergeSort(data, 0, n-1, count);        return count % 1000000007;    }        void MergeSort(vector<int>& data, int start, int end, int& count)    {        if(start < end)        {            int mid = (start + end) / 2;            MergeSort(data, start, mid, count);            MergeSort(data, mid+1, end, count);            Merge(data, start, mid, mid+1, end, count);        }    }        void Merge(vector<int>& data, int lb, int le, int rb, int re, int& count)    {        int i = le, j = re;        int n = re - lb + 1;        int k = n - 1;        vector<int> tmp(n, 0);        while(i >= lb && j >= rb)        {            if(data[i] > data[j])            {                count += j - rb + 1;                count %= 1000000007;                tmp[k] = data[i];                k--;                i--;            }            else            {                tmp[k] = data[j];                k--;                j--;            }        }        while(i >= lb)        {            tmp[k] = data[i];            k--;            i--;        }        while(j >= rb)        {            tmp[k] = data[j];            k--;            j--;        }        for(i=lb, k=0; i<=re; i++, k++)            data[i] = tmp[k];    }};

36)两个链表的第一个公共结点
输入两个链表，找出它们的第一个公共结点。

/*struct ListNode {    int val;    struct ListNode *next;    ListNode(int x) :            val(x), next(NULL) {    }};*/class Solution {public:    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {        if(pHead1 == NULL || pHead2 == NULL)            return NULL;        int len1 = getLength(pHead1);        int len2 = getLength(pHead2);        int dist = 0;        ListNode* pLong = NULL;        if(len1 > len2)        {            dist = len1 - len2;            pLong = pHead1;        }        else        {            dist = len2 - len1;            pLong = pHead2;        }        for(int i=0; i<dist; i++)        {            pLong = pLong->next;        }        while(pLong)        {            if(pLong->val == pHead2->val)                return pLong;            pLong = pLong->next;            pHead2 = pHead2->next;        }        return NULL;    }        int getLength(ListNode* head)    {        ListNode*p = head;        int count = 0;        while(p)        {            count++;            p = p->next;        }        return count;    }};

37)数字在排序数组中出现的次数
统计一个数字在排序数组中出现的次数

class Solution {public:    int GetNumberOfK(vector<int> data ,int k) {         int n = data.size();         if(n == 0)             return 0;         int left = leftEqual(data, k);         int right = rightEqual(data, k);         if(left != -1 && right != -1)             return right - left + 1;        return 0;    }        int leftEqual(vector<int>& data, int k)    {        int left = 0, right = data.size() - 1;        int mid;        while(left <= right)        {            mid = (left + right) / 2;            if(data[mid] == k)            {                if(mid == left || (mid - 1 >= left && data[mid-1] != k))                    return mid ;                right = mid - 1;            }            else if(data[mid] > k)                right = mid - 1;            else                left = mid + 1;        }        return -1;    }        int rightEqual(vector<int>& data, int k)    {        int left = 0, right = data.size() - 1;        int mid;        while(left <= right)        {            mid = (left + right) / 2;            if(data[mid] == k)            {                if(mid == right || (mid + 1 <= right && data[mid+1] != k))                    return mid;                left = mid + 1;            }            else if(data[mid] > k)                right = mid - 1;            else                left = mid + 1;        }        return -1;    }};

38)二叉树的深度
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

/*struct TreeNode {    int val;    struct TreeNode *left;    struct TreeNode *right;    TreeNode(int x) :            val(x), left(NULL), right(NULL) {    }};*/class Solution {public:    int TreeDepth(TreeNode* pRoot)    {        if(pRoot == NULL)            return 0;        int left = 0;        int right = 0;        if(pRoot->left)            left = TreeDepth(pRoot->left);        if(pRoot->right)            right = TreeDepth(pRoot->right);        return 1 + max(left, right);    }};

39)平衡二叉树
输入一棵二叉树，判断该二叉树是否是平衡二叉树。

class Solution {public:    bool IsBalanced_Solution(TreeNode* pRoot) {        if(pRoot == NULL)            return true;       int depth = 0;       return Balance(pRoot, depth);    }        bool Balance(TreeNode* pRoot, int& depth)  // 后序遍历    {        if(pRoot == NULL)            return true;        int left = 0, right = 0;        if(Balance(pRoot->left, left) && Balance(pRoot->right, right))        {            int dif = left - right;            if(dif >= -1 && dif <= 1)            {                depth = left > right ? left + 1 : right + 1;                return true;            }            }        return false;    }};

40)数组中只出现一次的数字
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字

class Solution {public:    void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {        int n = data.size();        if(n == 0 || n < 2)            return ;        int res = 0;        *num1 = 0;        *num2 = 0;        for(int i=0; i<n; i++)            res ^= data[i];        int k = firstBit(res);        for(int i=0; i<n; i++)        {            if(IsEqualOne(data[i], k))                *num1 ^= data[i];            else                *num2 ^= data[i];        }    }        int firstBit(int res)    {        int count = 0;        while(((res & 0x1) == 0) && (count < 8 * sizeof(int)))        {            res >>= 1;            count++;        }        return count;    }        bool IsEqualOne(int num, int k)    {        return (num >> k) & 0x1;    }};

41)和为S的两个数字
输入一个递增排序的数组和一个数字S，在数组中查找两个数，是的他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
输出描述：对应每个测试案例，输出两个数，小的先输出

class Solution {public:    vector<int> FindNumbersWithSum(vector<int> array,int sum) {        int n = array.size();        if(n == 0 || n < 2)            return vector<int>();        vector<int> res;        int small = 0, big = n - 1;        while(small < big)        {            int curSum = array[small] + array[big];            if(curSum == sum)            {                res.push_back(array[small]);                res.push_back(array[big]);                break;            }            else if(curSum > sum)                big--;            else                small++;        }        return res;    }};

42)和为S的连续正数序列
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
输出描述：输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序

class Solution {public:    vector<vector<int> > FindContinuousSequence(int sum) {        vector<vector<int> > res;        if(sum <= 0)            return res;        int start = 1, end = 2;        int curSum = start + end;        vector<int> solution;        while(start <= sum/2)        {            if(curSum == sum)            {                for(int i=start; i<=end; i++)                    solution.push_back(i);                res.push_back(solution);                solution.clear();                end++;                curSum += end;            }            else if(curSum > sum)            {                curSum -= start;                start++;            }            else            {                end++;                curSum += end;            }        }        return res;    }};

43)翻转单词顺序
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

class Solution {public:    string ReverseSentence(string str) {        int length = str.length();        if(length == 0)            return str;        Reverse(str, 0, length-1);        int start = 0;        int end = 0;        for(int i=0; i<length; i++)        {            if(str[i] == ' ')            {                end = i-1;                Reverse(str, start, end);                start = i+1;            }            if(i == length - 1)            {                end = i;                Reverse(str, start, end);            }        }        return str;    }        void Reverse(string& str, int start, int end)    {        while(start < end)        {            char temp = str[start];            str[start] = str[end];            str[end] = temp;            start++;            end--;        }    }};

44)左旋转字符串
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

class Solution {public:    string LeftRotateString(string str, int n) {        int length = str.length();        if(length == 0 || n < 0)            return str;        n %= length;               Reverse(str, 0, n-1);        Reverse(str, n, length-1);        Reverse(str, 0, length-1);        return str;    }        void Reverse(string& str, int start, int end)    {        while(start < end)        {            char temp = str[start];            str[start] = str[end];            str[end] = temp;            start++;            end--;        }    }};

45)扑克牌的顺子
LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何。为了方便起见,你可以认为大小王是0。

class Solution {public:    bool IsContinuous( vector<int> numbers ) {        int n = numbers.size();        if(n == 0)            return false;        sort(numbers.begin(), numbers.end());        int zero = 0;        int dif = 0;        for(int i=0; i<n; i++)        {            if(numbers[i] == 0)                zero++;            else if(i + 1 < n)            {                if(numbers[i] == numbers[i+1])                    return false;                dif += numbers[i+1] - numbers[i] -1;            }                        }        if(zero >= dif)            return true;        return false;    }};

46)孩子们的游戏 ( 圆圈中最后剩下的数)
每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的
下一个小朋友开始,继续0...m-1报数....这样下去....直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_^)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)

class Solution {public:    int LastRemaining_Solution(int n, int m)   // 环形队列模拟圆圈    {        if(n < 1 || m < 1)            return -1;        list<int> numbers;        int i = 0;        for( ; i<n; i++)            numbers.push_back(i);        list<int>::iterator iter = numbers.begin();        while(numbers.size() > 1)        {               for(i=1; i<m; i++)            {                iter++;                if(iter == numbers.end())                    iter = numbers.begin();            }            list<int>::iterator next = ++iter;            --iter;            numbers.erase(iter);            iter = next;            if(iter == numbers.end())                iter = numbers.begin();        }        return *iter;//numbers.back();            }};

// 方法二：找规律f(n, m) = 0   (n = 1)f(n, m) = [f(n-1,m)+m]%n  (n>1)  int LastRemaining_Solution(int n, int m)    {        if(n < 1 || m < 1)            return -1;        int last = 0;        for(int i=2; i<=n; i++)            last = (last + m) % i;        return last;    }

47)求1+2+3+...+n
求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）

// 利用构造函数class A{public:    A()    {        ++i;        sum += i;    }    static int getSum()    {        return sum;    }    static void reset()    {        i = 0;        sum = 0;    }private:    static int i;    static int sum;};int A::i = 0;int A::sum = 0;class Solution {public:    int Sum_Solution(int n) {        A::reset();        A* a = new A[n];        int res = A::getSum();//A::sum;        delete[] a;        return res;    }};

// 方法二：利用虚函数class A;A* array[2];class A{public:    virtual int sum(int n)    {        return 0;    }};class B : public A{public:    virtual int sum(int n)    {        return ::array[!!n]->sum(n-1) + n;    }};class Solution {public:    int Sum_Solution(int n) {        A a;        B b;        ::array[0] = &a;        ::array[1] = &b;                return ::array[1]->sum(n);    }};

48)不用加减乘除做加法
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号

class Solution {public:    int Add(int num1, int num2)    {        int sum, carray;        do        {            sum = num1 ^ num2;            carry = (num1 & num2) << 1;                        num1 = sum;            num2 = carry;        }while(carry);        return sum;    }};

49)把字符串转换成整数
将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0
输入描述：输入一个字符串,包括数字字母符号,可以为空
输出描述：如果是合法的数值表达则返回该数字，否则返回0

class Solution {public:    int StrToInt(string str) {        int length = str.length();        if(length == 0)            return 0;        int res = 0;        bool flag = false;        for(int i=0; i<length; i++)        {            if(i == 0 && str[i] == '-')                flag = true;            else if(i == 0 && str[i] == '+')                continue;            else if(str[i] >= '0' && str[i] <= '9')            {                res =  res * 10 + str[i] - '0';                if((!flag && res > 0x7FFFFFFF) || (flag && -res < 0x80000000))                    return 0;            }            else                return 0;        }        if(flag)            res *= -1;        return res;    }};

50)数组中重复的数字
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2

class Solution {public:    // Parameters:    //        numbers:     an array of integers    //        length:      the length of array numbers    //        duplication: (Output) the duplicated number in the array number    // Return value:       true if the input is valid, and there are some duplications in the array number    //                     otherwise false    bool duplicate(int numbers[], int length, int* duplication) {        if(numbers == NULL || length <= 0)            return false;        int i = 0;        for(i=0; i<length; i++)        {            if(numbers[i] < 0 || numbers[i] > length - 1)                return false;        }        while(i < length)        {            if(numbers[i] == i)                i++;            else if(numbers[i] > i)            {                if(numbers[i] == numbers[numbers[i]])                {                    *duplication = numbers[i];                    return true;                }                swap(numbers[i], numbers[numbers[i]]);            }                else            {                *duplication = numbers[i];                return true;            }        }        return false;    }};

51)构建乘积数组
给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],其中B中的元素B[i]=A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1]。不能使用除法

class Solution {public:    vector<int> multiply(const vector<int>& A) {        int n = A.size();        if(n == 0)            return vector<int>();        vector<int> B(n, 1);        for(int i=1; i<n; i++)            B[i] = B[i-1] * A[i-1];        int temp = 1;        for(int i=n-2; i>=0; i--)        {            temp *= A[i+1];            B[i] *= temp;        }        return B;    }};

52)正则表达式匹配
请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配

class Solution {public:    bool match(char* str, char* pattern)    {        if(str == NULL || pattern == NULL)            return false;        if(*str == '\0' && *pattern == '\0')            return true;        if(*str != '\0' && *pattern == '\0')            return false;                if(*(pattern+1) == '*')        {            if(*str == *pattern || (*str != '\0' && *pattern == '.'))                return match(str+1, pattern) || match(str+1, pattern+2) || match(str, pattern+2);            return match(str, pattern+2);        }        if(*str == *pattern || (*str != '\0' && *pattern == '.'))            return match(str+1, pattern+1);        return false;    }};

53)表示数值的字符串
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。

class Solution {public:    bool isNumeric(char* string)    {        if(string == NULL || *string == '\0')            return false;        if(*string == '+' || *string == '-')            string++;        bool res = true;        bool flag = false;        scanDigit(string);        while(*string != '\0')        {            if(*string == 'e' || *string == 'E')            {                string++;                if(*string == '\0')                    return false;                if(*string == '+' || *string == '-')                    string++;                scanDigit(string);                if(*string != '\0')                    return false;            }            else if(*string == '.')            {                if(!flag)                    flag = true;                else                    return false;                string++;                scanDigit(string);            }                else            {                res = false;                break;            }        }        return res;    }    void scanDigit(char*& str)    {        while(*str >= '0' && *str <= '9')            str++;    }};

class Solution {                   // 剑指offerpublic:    bool isNumeric(char* string)    {        if(string == NULL || *string == '\0')            return false;        if(*string == '+' || *string == '-')            string++;        if(*string == '\0')            return false;        scanDigit(string);        if(*string != '\0')        {            if(*string == '.')            {                string++;                scanDigit(string);                 if(*string == 'e' || *string == 'E')                   return isExponent(string);            }            else if(*string == 'e' || *string == 'E')                return isExponent(string);            else                return false;        }        return *string == '\0' ? true : false;    }        void scanDigit(char*& str)    {        while(*str != '\0' && *str >= '0' && *str <= '9')            str++;    }        bool isExponent(char*& str)    {        if(*str!= 'e' && *str != 'E')            return false;        str++;        if(*str == '+' || *str == '-')            str++;        if(*str == '\0')            return false;        scanDigit(str);        return *str == '\0' ? true : false;    }};

54)字符流中第一个不重复的字符
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"
输入描述：如果当前字符流没有存在出现一次的字符，返回#字符

class Solution     // 解法一{public:    string str;  //Insert one char from stringstream    void Insert(char ch)    {        str += string(1, ch);    }  //return the first appearence once char in current stringstream    char FirstAppearingOnce()    {        vector<int> hash(256, 0);        char res = '#';        int n = str.length();        for(int i=0; i<n; i++)        {            if(hash[str[i]] == 0)                hash[str[i]] = 1;            else                hash[str[i]] = -1;        }        for(int i=0; i<n; i++)        {            if(hash[str[i]] == 1)            {                    res = str[i];                break;            }        }        return res;    }};

class Solution   // 解法二：剑指offer{private:    int occurence[256];    int index;public:    Solution() : index(0)    {        for(int i=0; i<256; i++)            occurence[i] = -1;    }  //Insert one char from stringstream    void Insert(char ch)    {         if(occurence[ch] == -1)             occurence[ch] = index;         else if(occurence[ch] >= 0)             occurence[ch] = -2;         index++;    }  //return the first appearence once char in current stringstream    char FirstAppearingOnce()    {        char ch = '#';        int minIndex = INT_MAX;        for(int i=0; i<256; i++)        {            if(occurence[i] >= 0 && occurence[i] < minIndex)            {                ch = (char)i;                minIndex = occurence[i];            }        }        return ch;    }};

55)链表中环的入口结点
一个链表中包含环，请找出该链表的环的入口结点。

/*struct ListNode {    int val;    struct ListNode *next;    ListNode(int x) :        val(x), next(NULL) {    }};*/class Solution {public:    ListNode* EntryNodeOfLoop(ListNode* pHead)    {        if(pHead == NULL)            return NULL;        ListNode* pSlow = pHead->next;        ListNode* pFast = pHead->next;        if(pFast)            pFast = pFast->next;        else            return NULL;        while(pFast->next && pSlow != pFast)        {            pSlow = pSlow->next;            pFast = pFast->next;            if(pFast)                pFast = pFast->next;            else                break;        }        if(pSlow != pFast)            return NULL;                int count = 1;        while(pFast->next != pSlow)        {            pFast = pFast->next;            count++;        }                pSlow = pHead;        pFast = pHead;        for(int i=0; i<count; i++)           pFast = pFast->next;        while(pSlow != pFast)        {            pSlow = pSlow->next;            pFast = pFast->next;        }        return pSlow;    }};

56)删除链表中重复的结点
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。
例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

/*struct ListNode {    int val;    struct ListNode *next;    ListNode(int x) :        val(x), next(NULL) {    }};*/class Solution {public:    ListNode* deleteDuplication(ListNode*& pHead)    {        if(pHead == NULL)            return NULL;        ListNode* pre = NULL;        ListNode* p = pHead;        while(p != NULL && p->next != NULL)        {            if(p->val == p->next->val)            {                int key = p->val;                while(p != NULL && p->val == key)                {                    ListNode* pToBeDelete = p;                    p = p->next;                    delete pToBeDelete;                    pToBeDelete = NULL;                }                                if(pre == NULL)                {                    pHead = p;                }                else                {                    pre->next = p;                }            }            else            {                pre = p;                p = p->next;            }          }        return pHead;    }};

57)二叉树的下一个结点
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

/*struct TreeLinkNode {    int val;    struct TreeLinkNode *left;    struct TreeLinkNode *right;    struct TreeLinkNode *next;    TreeLinkNode(int x) :val(x), left(NULL), right(NULL), next(NULL) {            }};*/class Solution {public:    TreeLinkNode* GetNext(TreeLinkNode* pNode)    {        if(pNode == NULL)            return NULL;        if(pNode->right)        {            pNode = pNode->right;            while(pNode->left)            {                pNode = pNode->left;            }            return pNode;        }        TreeLinkNode* pParent = pNode->next;        while(pParent != NULL && pParent->right == pNode)        {            pNode = pParent;            pParent = pParent->next;        }        return pParent;    }};

58)对称的二叉树
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的

/*struct TreeNode {    int val;    struct TreeNode *left;    struct TreeNode *right;    TreeNode(int x) :            val(x), left(NULL), right(NULL) {    }};*/class Solution {public:    bool isSymmetrical(TreeNode* pRoot)    {        if(pRoot == NULL)            return true;        //else if((pRoot->left == NULL && pRoot->right != NULL) || (pRoot->left != NULL && pRoot->right == NULL))          //  return false;        return isSym(pRoot, pRoot);//return isSym(pRoot->left, pRoot->right);    }    bool isSym(TreeNode* pLeft, TreeNode* pRight)    {        if(pLeft == NULL && pRight == NULL)            return true;        if(pLeft == NULL || pRight == NULL)//else if((pLeft == NULL && pRight != NULL) || (pLeft != NULL && pRight == NULL))            return false;        if(pLeft->val != pRight->val)            return false;        return isSym(pLeft->left, pRight->right) && isSym(pLeft->right, pRight->left);    }};

59)把二叉树打印成多行
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行

/*struct TreeNode {    int val;    struct TreeNode *left;    struct TreeNode *right;    TreeNode(int x) :            val(x), left(NULL), right(NULL) {    }};*/class Solution {public:        vector<vector<int> > Print(TreeNode* pRoot) {            vector<vector<int> > res;            if(pRoot == NULL)                return res;            queue<TreeNode*> q;            q.push(pRoot);            int toBePrint = 1;            int nextLevel = 0;            vector<int> numbers;            while(!q.empty())            {                TreeNode* pNode = q.front();                numbers.push_back(pNode->val);                if(pNode->left)                {                    q.push(pNode->left);                    ++nextLevel;                }                if(pNode->right)                {                    q.push(pNode->right);                    ++nextLevel;                }                q.pop();                --toBePrint;                if(toBePrint == 0)                {                    toBePrint = nextLevel;                    nextLevel = 0;                    res.push_back(numbers);                    numbers.clear();                }            }            return res;        }};

60)按之字形顺序打印二叉树
请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

/*struct TreeNode {    int val;    struct TreeNode *left;    struct TreeNode *right;    TreeNode(int x) :            val(x), left(NULL), right(NULL) {    }};*/class Solution {public:    vector<vector<int> > Print(TreeNode* pRoot) {        vector<vector<int> > res;        if(pRoot == NULL)            return res;        vector<int> numbers;        stack<TreeNode*> odd, even;        odd.push(pRoot);        while(!odd.empty() || !even.empty())        {            while(!odd.empty())            {                TreeNode* pNode = odd.top();                numbers.push_back(pNode->val);                if(pNode->left)                    even.push(pNode->left);                if(pNode->right)                    even.push(pNode->right);                odd.pop();            }            if(numbers.size() > 0)            {                res.push_back(numbers);                numbers.clear();            }            while(!even.empty())            {                TreeNode* pNode = even.top();                numbers.push_back(pNode->val);                if(pNode->right)                    odd.push(pNode->right);                if(pNode->left)                    odd.push(pNode->left);                even.pop();            }            if(numbers.size() > 0)            {                res.push_back(numbers);                numbers.clear();            }        }        return res;      }  };

61)序列化二叉树
请实现两个函数，分别用来序列化和反序列化二叉树

/*struct TreeNode {    int val;    struct TreeNode *left;    struct TreeNode *right;    TreeNode(int x) :            val(x), left(NULL), right(NULL) {    }};*/class Solution {public:    char* Serialize(TreeNode *root) {            if(root == NULL)            return "$";        string str = to_string(root->val);        str += ",";        str += Serialize(root->left);        str += Serialize(root->right);        char* s = new char[str.length()+1];        //char* left = Serialize(root->left);        //char* right = Serialize(root->right);        //char* s = new char[strlen(left) + strlen(right) + str.length()+1];        strcpy(s, str.c_str());        //strcat(s, left);        //strcat(s, right);        return s;    }    TreeNode* Deserialize(char *&str) {        if(str == NULL)            return NULL;        if(*str == '$')        {            str++;            return NULL;        }        int val = 0;        while(*str != ',')        {            val = val * 10 + (*str - '0');            str++;        }        str++;        TreeNode* pRoot = new TreeNode(val);        pRoot->left = Deserialize(str);        pRoot->right = Deserialize(str);        return pRoot;    }};

62)二叉搜索树的第k个结点
给定一颗二叉搜索树，请找出其中的第k大的结点。例如， 5 / \ 3 7 /\ /\ 2 4 6 8 中，按结点数值大小顺序第三个结点的值为4。

/*struct TreeNode {    int val;    struct TreeNode *left;    struct TreeNode *right;    TreeNode(int x) :            val(x), left(NULL), right(NULL) {    }};*/class Solution {public:    TreeNode* KthNode(TreeNode* pRoot, int k)    {        if(pRoot == NULL || k <= 0)            return NULL;        return KthNodeCore(pRoot, k);    }    TreeNode* KthNodeCore(TreeNode* pRoot, int& k)    {         if(pRoot == NULL || k <= 0)            return NULL;        TreeNode* res = NULL;        if(pRoot->left != NULL)            res = KthNodeCore(pRoot->left, k);        if(res == NULL)        {            if(k == 1)            {                res = pRoot;                return res;            }            k--;        }        if(res == NULL && pRoot->right != NULL)            res = KthNodeCore(pRoot->right, k);        return res;    }};

63)数据流中的中位数
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值

class Solution {public:    void Insert(int num)    {        if(((min.size() + max.size()) & 0x1) == 0)  // 偶        {            if(max.size() > 0 && max[0] > num)            {                max.push_back(num);                push_heap(max.begin(), max.end(), less<int>());                num = max[0];                pop_heap(max.begin(), max.end(), less<int>());                max.pop_back();            }            min.push_back(num);            push_heap(min.begin(), min.end(), greater<int>());        }        else   // 奇        {            if(min.size() > 0 && min[0] < num)            {                min.push_back(num);                push_heap(min.begin(), min.end(), greater<int>());                num = min[0];                pop_heap(min.begin(), min.end(), greater<int>());                min.pop_back();            }            max.push_back(num);            push_heap(max.begin(), max.end(), less<int>());        }    }    double GetMedian()    {        if(((min.size() + max.size()) & 0x1) == 1)        {              return min[0];              }        else            return (max[0] + min[0])/2.0;    }private:    vector<int> min;  //小根堆    vector<int> max;  //大根堆};

64)滑动窗口的最大值
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。
例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}，{2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

class Solution {public:    vector<int> maxInWindows(const vector<int>& num, unsigned int size)    {        vector<int> res;        int n = num.size();        if(n == 0 || size <=0 || n < size)            return res;        int i;        deque<int> index;        for(i=0; i<size; i++)        {            while(!index.empty() && num[index.back()] <= num[i])                index.pop_back();            index.push_back(i);        }        res.push_back(num[index.front()]);        for(i=size; i<n; i++)        {           while(!index.empty() && num[index.back()] <= num[i])               index.pop_back();           if(!index.empty() && i - index.front() >= size)               index.pop_front();                   index.push_back(i);            res.push_back(num[index.front()]);        }        return res;    }};

65)矩阵中的路径
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。 例如 a b c e s f c s a d e e 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子

class Solution {public:    bool hasPath(char* matrix, int rows, int cols, char* str)    {        if(matrix == NULL || rows < 1 || cols < 1 || str == NULL)            return false;        vector<bool> visited(rows*cols, 0);        /*bool* visited = new bool[rows*cols];        memset(visited, 0, rows*cols);*/        int pathLength = 0;        for(int row=0; row<rows; row++)        {            for(int col=0; col<cols; col++)            {                if(hasPathCore(matrix, rows, cols, row, col, str, pathLength, visited))                    return true;            }        }        //delete[] visited;        return false;    }    bool hasPathCore(char* matrix, int rows, int cols, int row, int col, char* str, int& pathLength, vector<bool>&/*bool**/ visited)    {        if(str[pathLength] == '\0')            return true;        bool res = false;        if(row >= 0 && row < rows && col >= 0 && col < cols && matrix[row*cols+col] == str[pathLength] && !visited[row*cols+col])        {            visited[row*cols+col] = true;            ++pathLength;            res = hasPathCore(matrix, rows, cols, row, col-1, str, pathLength, visited)                || hasPathCore(matrix, rows, cols, row-1, col, str, pathLength, visited)                || hasPathCore(matrix, rows, cols, row, col+1, str, pathLength, visited)                || hasPathCore(matrix, rows, cols, row+1, col, str, pathLength, visited);            if(!res)            {                visited[row*cols+col] = false;                --pathLength;            }        }        return res;    }};

66)机器人的运动范围
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？

class Solution {public:    int movingCount(int threshold, int rows, int cols)    {        if(threshold < 0 || rows < 1 || cols < 1)            return 0;        vector<bool> visited(rows*cols, 0);        //int row = 0, col = 0;        int  res = movingCore(threshold, rows, cols, 0, 0, visited);        return res;    }        int movingCore(int threshold, int rows, int cols, int row, int col, vector<bool>& visited)    {        int res = 0;        if(canMove(threshold, rows, cols, row, col) && !visited[row*cols+col])        {            visited[row*cols+col] = true;            res = 1 + movingCore(threshold, rows, cols, row, col-1, visited)                     + movingCore(threshold, rows, cols, row-1, col, visited)                    + movingCore(threshold, rows, cols, row, col+1, visited)                    + movingCore(threshold, rows, cols, row+1, col, visited);        }        return res;    }        bool canMove(int threshold, int rows, int cols, int row, int col)    {        int sum = 0;        if(row >= 0 && row < rows && col >= 0 && col < cols)        {            while(row)            {                sum += row % 10;                row /= 10;            }            while(col)            {                sum += col % 10;                col /= 10;            }            if(sum <= threshold)                return true;            return false;        }        return false;    }};