剑指offer(51---57)

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]。不能使用除法。（注意：规定B[0] = A[1] * A[2] * … * A[n-1]，B[n-1] = A[0] * A[1] * … * A[n-2];）

此题我们可以将B分成两部分，分别代表A[i]的前半部分和后半部分，即B1[i]=A[0] * A[1] …*A[i-1]，B2[i]=A[i+1] * A[i+2]…*A[n-1]，一开始每个元素都初始化为1，然后逐步向上乘即可，实现代码：

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

52、正则表达式匹配

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

这个题我们可以做以下分析：
首先我们知道这个使用递归的方式，在处理完当前的，处理下一个就是做递归，因此确定递归终止条件就是如果到了当前字符两者*str和 pattern都为’\0’，说明已经匹配完成了，返回true，如果str不为’\0’，*pattern为’\0’表示当前还没有将str匹配完成，因此返回false，接下来我们实现过程：
我们要考虑的是开始匹配时，要么匹配成功，要么匹配失败，还要考虑下一个字符是否是 ’ * '，因此可分为：
（1）下一个字符不是 ’ * '：
1》如果当前字符匹配成功（匹配成功的意思是 *str == *pattern或者 *str != ‘\0’ && *pattern == ‘.’），那么就要继续向后匹配，此时str向后走一步，pattern向后走一步递归；
2》如果当前字符匹配不成功，由于下一个也不是 ’ * '，所以也没有办法让当前的字符出现0次，因此直接返回false。
（2）下一个字符是 ’ * ’
1》如果当前字符匹配成功，由于下一个字符是 ’ * '，而 ’ * '可以表示前一个字符出现0次、1次或多次两种情况
a、当 ’ * '表示前一个字符出现0次，由于此时前一个字符已经匹配成功了，而此时又让它出现0次，那只能走到pattern+2（忽略前一个字符和 ’ * '所占的两个位置），继续递归判断；
b、当 ’ * '表示前一个字符出现一次或多次，意思就是可能出现多次，因此str不用动，从pattern+1处继续递归判断；
2》如果当前字符匹配不成功，由于下一个字符是 ’ * '，而由于前一个字符已经匹配不成功了，则必须让他出现0次，因此下一次str不用动，pattern走两步，也就是变成了1》里面的a情况。

class Solution {
public:
    bool match(char* str, char* pattern)
    {
        //递归终止条件
        //考虑如果当前str的字符为'\0'，pattern的当前字符也是'\0'，返回true
        if(*str == '\0' && *pattern == '\0')
            return true;
        //如果当前str的字符不是'\0'但是pattern当前的字符是'\0'，表示不匹配，返回false
        if(*str != '\0' && *pattern == '\0')
            return false;
        //开始匹配，分为两种情况，即pattern下一个字符是*和不是*
        if(*(pattern+1)!='*')
            //下一个字符不是'*'，分为当前字符匹配成功和不成功
        {
            //如果当前字符匹配成功（包含str当前字符不是'\0'并且当前pattern为.也表示成功），则继续匹配下一个
            if((*str == *pattern)||(*str !='\0' && *pattern == '.'))
                return match(str+1,pattern+1);
            //如果当前字符没有匹配成功，则返回false
            else
                return false;
        }
        else//下一个字符是'*'，也分为当前字符匹配成功和不成功，*也表示前面的字符出现0次、1次或多次两种情况
        {
            //如果当前字符匹配成功
            if((*str == *pattern)||(*str != '\0' && *pattern == '.'))
               //如果表示前面的字符出现0次的情况，下一次递归从pattern+2开始，str不用走
               //如果表示前面的字符出现1次或多次的情况，下一次递归从str+1，pattern不变开始
               return match(str,pattern+2) || match(str+1,pattern);
            else//当前匹配不成功
                return match(str,pattern+2);
        }
    }
};

53、表示数值的字符串

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

我们要知道哪种情况不是，观察上述例子，一共考虑以下几种情况：
（1）如果当前字符是e或者E，不能是最后一个字符（12e的情况），不能有两个e或者E；
（2）如果当前字符是正负号，此时如果正负号有第二次出现了，要在e或者E的后面（-1E-16的情况）；如果正负号是第一次出现，则如果不是在第一个字符，也要在e或者E的后面；
（3）如果当前字符是小数点，则e或者E后面不能有小数点（12e+4.3的情况），或者小数点不能出现两次（1.2.3的情况）；
（4）非法情况，当前字符不能小于’0’，不能大于’9’。

class Solution {
public:
    bool isNumeric(char* string)
    {
        bool sign=false;//表示是否有正负号
        bool decimal=false;//表示是否有小数点
        bool hasE=false;//表示是否有e或E
        for(int i=0;i<strlen(string);++i)
        {
            //出现e的情况
            if(string[i] == 'e' || string[i] == 'E')
            {
                //e不能是最后一个字符
                if(i == strlen(string)-1)
                    return false;
                //不能又有一个e
                if(hasE)//意思是此时字符串之中已经有e了
                    return false;
                //不是以上情况，将hasE设为true，表示有一个e了
                hasE = true;
            }
            //出现正负号的情况
            else if(string[i] == '+' || string[i] == '-')
            {
                //如果是第二次出现正负号，则必须在e的后面，不然返回false
                if(sign && string[i-1] != 'e' && string[i-1] != 'E')
                    return false;
                //如果是第一次出现正负号，并且不是出现在第一个，则也要在e之后
                if(!sign && i>0 && string[i-1] != 'e' && string[i-1] != 'E')
                    return false;
                sign = true;//不是以上情况，将sign设为true，表示此时有正负号了
            }
            //出现小数点的情况
            else if(string[i] == '.')
            {
                //e的后面不能有小数点，并且小数点不能重复出现
                if(hasE || decimal)
                    return false;
                decimal = true;
            }
            else//非法的情况
            {
                if(string[i] <'0' || string[i] >'9')
                    return false;
            }
        }
        return true;
    }
};

54、字符流中第一个不重复的字符

请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。

拿到这个题我们知道每次重新输入字符串只要重新统计每个字符出现的次数，使用hashtable，然后遍历看哪个字符出现一次即可。

class Solution
{
public:
    string str;
    char hashtable[256]={0};
  //Insert one char from stringstream
    void Insert(char ch)
    {
        str+=ch;
        hashtable[ch]++;//统计插入的ch出现的次数
    }
  //return the first appearence once char in current stringstream
    char FirstAppearingOnce()
    {
        int len=str.size();
        for(int i=0;i<len;++i)
        {
            if(hashtable[str[i]]==1)
                return str[i];
        }
        return '#';
    }
};

55、循环中环的入口结点

给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

首先要保证有环，也就是使用快慢指针，快指针走两步，慢指针走一步，如果相遇，说明有环，此时慢指针从头开始每次走一步，快指针从相遇点每次走一步，直到再次相遇，这个相遇点就是入口点

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* EntryNodeOfLoop(ListNode* pHead)
    {
        ListNode *fast = pHead;
        ListNode *slow = pHead;
        //先找到相遇点
        while(fast && fast->next)//快指针走两步，慢指针走两步，如果有环，则一定会相遇
        {
            fast = fast->next->next;
            slow = slow->next;
            if(fast == slow)//找到相遇点了
                break;
        }
        if(!fast || !fast->next)
            return nullptr;//说明根本不能不能构成一个环
        slow = pHead;
        //找到相遇点，slow从起点出发，fast从第一个相遇点出发，两位每人各走一步，直到相遇，这个第二个相遇点就是入口点
        while(fast!=slow)
        {
            fast = fast->next;
            slow = slow->next;
        }
        return slow;
    }
};

56、删除链表中重复的结点

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

我们构造一个假结点fackNode作为pHead的前驱，让每一个结点都有前驱来进行删除，pre此时指向fackNode，两个指针p1指向pHead，p2指向pHead->next，比较p1和p2额值，如果不相等，就三个指针都往后走，如果相等，p2继续往后走，直到为空或者与p1的值不相等，然后将p1到p2之间的结点删除（也就是重复结点的删除），即pre的next指向p2，p1指向p2，如果p2还没有走到nullptr，就想后走一步继续循环直到p2为nullptr即可。
实现代码：

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
        ListNode* fackNode = new ListNode(0);//构造一个假结点作为头结点的前驱，保证每个结点都有前驱
        fackNode->next = pHead;
        ListNode* pre = fackNode;
        ListNode* p1 = pHead;
        ListNode* p2 = pHead->next;
        if(pHead == nullptr)
            return nullptr;
        while(p2!=nullptr)
        {
            if(p1->val != p2->val)//不重复时三个指针都往后走
            {
                pre = p1;
                p1 = p1->next;
                p2 = p2->next;
            }
            else//重复时，p2继续向后走，直到走到末尾或者不重复
            {
                while(p2!=nullptr && p1->val == p2->val)
                {
                    p2 = p2->next;
                }
                //删除p1到p2之间的结点
                pre->next=p2;
                p1=p2;
                if(p2 !=nullptr)//只要p2没有走到nullptr，就继续循环
                {
                    p2=p2->next;
                }
            }
        }
        return fackNode->next;
    }
};

57、二叉树的下一个结点

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

按照中序遍历的顺序来遍历，那么此时我们就要分情况：
（1）如果pNode有右孩子，那么它的下一个就是它的右子树的最左边的结点；
（2）如果pNode没有右孩子，此时也要分两种情况：
a、pNode如果是它的父节点的左孩子，那么此时它的下一个就是它的父节点；
b、如果pNode是它的父节点的右孩子，此时它的下一个就要向上找，此时让pNode指向它的父节点，即继续向上遍历父节点的父节点，即如图要找1的下一个节点这种情况，4是他的父节点，它是父节点的右孩子，它的下一个应该是2，此时pNode走到4，循环下一次判断就是a这种情况：

实现代码，其中next指的是父节点域：

/*
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==nullptr)
            return nullptr;
        if(pNode->right!=nullptr)
        {//如果pNode有右孩子，找他的右子树最左边的结点
            pNode=pNode->right;
            while(pNode->left!=nullptr)
                pNode=pNode->left;
            //找到了最左边的，返回
            return pNode;
        }
        //pNode没有右孩子
        //只要pNode有父节点，执行以下：
        while(pNode->next!=nullptr)
        {
        //分为两种情况，第一种它是父节点的左孩子,则它的下一个节点就是它的父节点
            TreeLinkNode* parent=pNode->next;
            if(pNode == parent->left)
                return parent;
            //如果它是父节点的右孩子，则他走到他的父节点处，继续向上遍历父节点的父节点，执行循环
            pNode=pNode->next;
        }
        return nullptr;
    }
};