面试题剑指offer21-30

21栈的压入、弹出序列

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

思想：
//合法性检验
//定义一个辅助栈将入栈序列插入到辅助栈中
//比较辅助栈顶值是否等于出栈序列值，
//如果相等则辅助栈出栈，出栈序列指向下一个，如果辅助栈为空说明是弹出序列
//如果不相等，则继续入栈，

例如
入栈1,2,3,4,5
出栈4,5,3,2,1
首先1入辅助栈，此时栈顶1≠4，继续入栈2
此时栈顶2≠4，继续入栈3
此时栈顶3≠4，继续入栈4
此时栈顶4＝4，出栈4，弹出序列向后一位，此时为5，,辅助栈里面是1,2,3
此时栈顶3≠5，继续入栈5
此时栈顶5=5，出栈5,弹出序列向后一位，此时为3，,辅助栈里面是1,2,3

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        if(pushV.size()==0||popV.size()==0)
            return false; //合法性检验
        stack<int>st;  //定义辅助栈
        int j=0;
        for(int i=0;i<pushV.size();i++)
        {
            st.push(pushV[i]);  //入栈序列插入辅助栈 
            while(!st.empty()&&st.top()==popV[j])
            {//如果栈顶元素与出栈序列元素相等
                st.pop();  //1出栈，2出栈序列元素指向下一个
                j++;
            }
        }
        if(st.empty())  //辅助栈为空说明出栈完成了
            return true;
        else
            return false; //否则凉凉
    }
};

22从上往下打印二叉树

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

思想：层序遍历，借助队列完成。

//合法性检验
//根结点先入队列
//判断队首是否为空，为空则遍历结束
//不为空，访问队首元素，队首元素出队列
//如果队首元素的左右孩子存在，则左右孩子入队列
//循环2-4过程

class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {

        queue<TreeNode*> qu;
        vector<int> ve;
        if(root==NULL)  //合法性检验
            return ve;
        qu.push(root);  //根节点入队列
        while(!qu.empty())   //队列不为空则开始遍历
        {
            root=qu.front();   //访问队首元素，出队列
            ve.push_back(root->val);
            qu.pop();
            if(root->left!=NULL)// 判断队首元素左右孩子是否存在
                qu.push(root->left);  //存在则入队列
            if(root->right!=NULL)
                qu.push(root->right);
        }
        return ve;
    }
};

23二叉搜索树的后序遍历序列

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

思想：
1、根据根结点划分区间
2、二叉搜素树根结点的值比左子树大，根结点值比右子树小
3、将左子树，右子树结点分别插入区间
4、递归判断左右子树是否符号二叉搜索树
5、当左右子树同时为真时则说明符合
图解如下：

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        int len=sequence.size();
        if(sequence.empty()||len==0) //合法性检验
            return false;
        int root=sequence[len-1]; //找到根结点
        vector<int> leftVery;
        int i=0;       //    【0，i）左子树区间
        for(;i<len-1;i++)
        {
            if(sequence[i]<root)    //插入左子树结点值
                leftVery.push_back(sequence[i]);
            else
                break;
        }
        vector<int> rightVery;
        for(int j=i;j<len-1;j++)   //【i，len-1）右子树区间
        {
            if(sequence[j]>root)  //插入右子树结点值
                rightVery.push_back(sequence[j]);
            else
                return false;
        }
        bool left=true;
        if(!leftVery.empty())  //左子树是否符合二叉搜索树
                left=VerifySquenceOfBST(leftVery);
        bool right=true;
        if(!rightVery.empty()) //右子树是否符合二叉搜索树
                right=VerifySquenceOfBST(rightVery);
        return (left&&right);    //必须同时满足
    }
};

24二叉树中和为某一路径的值

25复杂链表的复制

//创建结点A1插入到A的后面
//指向任意域A1->random=A->random->next;
//根据奇数偶数拆分为两个链表

class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        if(!pHead) return NULL;
        RandomListNode *cur = pHead; 
        while(cur!=NULL){
            //创建新节点并赋值
            RandomListNode *node = new RandomListNode(cur->label);
            node->next = cur->next;
            cur->next = node;
            
            cur = node->next; //头节点指向原链表下一个节点进入下一次循环
        }
        cur = pHead;
        while(cur!=NULL){
            RandomListNode *node = cur->next; //node指向新节点
            if(cur->random!=NULL){     //新节点指向其任意域          
                node->random = cur->random->next;
            }
            cur = node->next; //头节点指向原链表的下一个节点
        }
        //拆分
        RandomListNode *pCloneHead = pHead->next; //第一个偶节点
        RandomListNode *tmp;         	
        cur = pHead;               //cur指向第一个奇节点
        while(cur->next!=NULL){    
            tmp = cur->next;          //tmp指向偶节点
            cur->next =tmp->next;      //偶节点指向->偶节点的下一个
            cur = tmp;                 //
        }
        return pCloneHead;
    }
};

26二叉搜索树与双向链表

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

27字符串排列

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

思绪：这里用到字符串全排列函数 next_permutation()
头文件#include <! algorithm !>
字符串一个一个插入到vector中，然后对vector中的字符进行全排列

class Solution {
public:
    vector<string> Permutation(string str) {
        vector<string>v;
        if(str=="")return v;
        do{
            v.push_back(str);
        }while(next_permutation(str.begin(),str.end()));
        return v;
    }
};

28 数组中出现次数超过一半的数字

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

思绪：如果数组中数字出现的次数超过了一半，那么对他进行排列之后，这个数字一定在后半部分中

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
            //用当前数与下一个数字比较，如果相等time++，如果不相等time--
             //如果time为0则赋下一个值，依次向后比较
              //判断数字出现的次数是否为数组长度的一半
        if(numbers.empty())
            return 0;
        int time=1;
        int result=numbers[0];
        for(int i=1;i<numbers.size();i++)
        {
            if(result==numbers[i])
                  time++;
            else if(time==0)
            {
                result=numbers[i];
                time=1;
            }
            else
            {
                 time--;
            }
        }
        time=0;
        for(int i=0;i<numbers.size();i++)
        {
            if(result==numbers[i])
            {
                 time++;
            }
        }
        return (time>numbers.size()/2)?result:0;
    }
};

29最小的K个数

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

思想：1调用算法库进行排序（适合少量数据）
2创建大堆（进行删除操作）（适合大量数据）

class Solution {
public:
    //调用算法对齐排序，然后输出
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> output;
        if(input.empty()||k>input.size())
            return output;
        sort(input.begin(),input.end());
        for(int i=0;i<k;i++)
        {
            output.push_back(input[i]);
        }
        return output;
    }
};

30连续子数组最大和

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

思想： 动态规划
定义初始状态量
寻找递推式
循环

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        int sum=array[0];  //初始状态量
        int max=array[0];
        
        for(int i=1;i<array.size();i++)  //循环
        {
            sum=GetMax(sum+array[i],array[i]);//递推式
            if(sum>max)
                max=sum;   
        }
        return max;
    }
    int GetMax(int a, int b)
    {
        return (a>b)? a:b;
    }
};