逻辑分析

1.表示数值的字符串

请实现一个函数用来判断字符串是否表示数值（包括整数和小数）

例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。

 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。

逻辑分析：

（1）. 正负号在字符串中最多可出现两次，而 “.” 及 “e” 在字符串中最多可出现一次，故需对 “+”，“-” 单独处理，字符串开始或者 “e” 的后面碰到 “+”，“-” 直接越过就好。

（2）.定义x digit e 标记是否有整数，小数点，和e，初值均为0

（3）.字符串的第一位，只可能是“+”，“-”，或者数值。“+”，“-” 直接越过，开始每个字符都进行字符串不为空的判断的大循环

1.数值就持续判断，直到遇到第一个不是数值的字符。

2.第一个不是数值的字符只能是 “.” 或者 “e” ，否则就不是字符串。

3.因 “e” 前面可能有 “.” ，故先判断“.” ，如果 “.” 前面没有数字或者出现过，则返回错误；否则标记 digit=1，当前指针后移，重新进入判断的大循环

4.如果 “e” ，如果前面未出现整数或者前面出现过 “e” ，则返回错误；否则 标记 e=1，当前指针后移；再判断是否有“+”，“-”,有就直接越过；因 “e”后面必须有数值，故若当前指针为空，则返回错误；否则重新进入判断的大循环

class Solution {
public:
    bool isNumeric(char* str)
    {
        if(str == NULL)
            return false;
        if(*str == '+' || *str == '-')
            ++str;
        if(*str == '\0')
            return false;
        int x = 0;        //标记整数部分
        int digit = 0;    //标记小数点
        int e = 0;        //标记e的状态
        while(*str != '\0')
        {
            if(*str >= '0' && *str <= '9')
            {
                ++str;
                x=1;      //标记整数部分的状态
            }else{
                if(*str == '.')
                {                            
                    if(digit > 0 || e > 0)  //前面已经出现过小数点或小数点之前存在e，则返回false
                        return false;
                    ++str;
                    digit = 1;
                }else if(*str == 'e' || *str == 'E')
                {
                    if(x == 0 || e > 0)
                        return false; //前面没有数值或之前存在e，则返回false
                    ++str;
                    e=1;                //标记e表示已经出现过
                    if(*str == '+' || *str == '-')  //e之后可以出现+-号再加整数
                        ++str;
                    if(*str == '\0')
                        return false;
                }else
                    return false;
            }
        }return true;
    }
};

2.删除链表中重复结点

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点

不保留，返回链表头指针。

 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

 输入：“” , 1 , 1->1->1->2->2 , 1->2->3->3->4->4

逻辑分析：

（1）因链表是有序的，故可以只比较相邻结点，引入前指针pre，头结点若重复，处理方式和内部结点相同

（2）只要链表中至少有两个结点，则进入判断是否重复的大循环

1.定义flag，标记当前结点是否重复

2.若当前结点和后一个结点重复，删除后一个重复结点，直到后面没有与当前结点的重复结点 

3.判断当前结点是否为删除操作后的重复结点，若是，判断当前结点是否有前节点，无前结点头指针指向当前结点的下一节点，有头结点删除当前结点；若当前结点非重复结点，则指针后移；重新进入大循环

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
        if(pHead == NULL || pHead->next == NULL)
            return pHead;
        
        ListNode* p = pHead;
        ListNode* pre = NULL;
       
        while(p && p->next)
        {
            bool flag = false;              //每次都是删除后面重复节点，标记当前节点是否是重复节点
            while(p->next && p->val == p->next->val)
            {
                p->next = p->next->next;     //重复，则一直删除p后面的重复节点
                flag=true;
            }
            if(flag)                        //当前节点为重复节点
            {
                if(pre == NULL)              //当前节点没有前节点，此时pHead应后移
                {
                    pHead = p->next;
                    p = pHead;
                }else{
                    p = p->next;              //当前节点p应删除，故找到p的下一节点
                    pre->next = p;            //利用前节点，此时删除当前节点p
                }
            }else{
                pre = p;                       //当前节点非重复节点，则p后移
                p = p->next;                    //进入下一次循环判断
            }
        }
        return pHead;
    }
};