leetcode刷题纪实（五）

面试题02.06

编写一个函数，检查输入的链表是否是回文的。

class Solution {    
public 
    boolean isPalindrome(ListNode head) {        
    //进阶        
    //思路：把链表分为两部分，反转后半部分的链表，然后一一比较值是否相等        
    //如果链表中没有元素 || 只有一个元素，那么返回True        
    if (head == null || head.next == null)            
        return true;                
        //找到中间节点，slow，注意pre.next=null是将链表截断成两部分        
    ListNode pre = head;        
    ListNode slow = pre.next;        
    ListNode fast = slow.next;                
    while (fast != null && fast.next != null) {            
        pre = slow;            
        slow = slow.next;            
        fast = fast.next.next;        
    }        
    if (pre != null)            
        pre.next = null;        //反转后半部分链表        
        pre = null;        
        while (slow != null) {            
            ListNode tempNode = slow.next;            
            slow.next = pre;            
            pre = slow;            
            slow = tempNode;        
        }        
        //注意这个条件 pre != null && head != null        
        //设想一个情况，链表节点有奇数个，那么肯定有一部分的链表比另一部分的链表多一个节点        
        //但是其实我们不必关注多出的这个节点。        
        //eg:1->2->5->2->1。前半部分链表：1->2。后半部分(未反转)：5->2->1;后半部分(反转后)：1->2->5。        
        //可以看到，最后的一个节点其实是不用去比较的，因为这个节点刚好是原链表最中间的那个节点。        
        while (pre != null && head != null) {            
            if (pre.val != head.val)                
                return false;            
            pre = pre.next;            
            head = head.next;        
        }                
        return true;      
    }    
}

很好的一种方法，利用快慢指针来定位中点位置，然后利用翻转后半段链表来判断是否回文
除此之外比如说利用一个辅助数组那种，就没有这个性能好了

链表的easy好像是做完了，接着看一看树吧

leetcode100

给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
其实解决树的问题就是迭代和递归的常规思路嘛，一定要熟练

class Solution {
public:    
    bool isSameTree(TreeNode* p, TreeNode* q) {        
        if(p==NULL&&q==NULL)return true;        
        if(p==NULL&&q!=NULL)return false;        
        if(p!=NULL&&q==NULL)return false;        
        if(p->val!=q->val)return false;        
        return isSameTree(p->left,q->left)&&isSameTree(p->right,q->right);    
    }
};

递归

class Solution {
public:    
    bool isSameTree(TreeNode* p, TreeNode* q) {        
        stack<TreeNode*> S;        
        S.push(q);        
        S.push(p);        
        TreeNode* p_temp;        
        TreeNode* q_temp;        
        while(!S.empty()){            
            p_temp=S.top();            
            S.pop();            
            q_temp=S.top();            
            S.pop();            
            if(p_temp==NULL&&q_temp==NULL)continue;            
            else if(p_temp!=NULL&&q_temp==NULL)return false;            
            else if(p_temp==NULL&&q_temp!=NULL)return false;            
            else if(p_temp->val!=q_temp->val)return false;            
            else{                
                S.push(q_temp->right);                
                S.push(p_temp->right);                
                S.push(q_temp->left);                
                S.push(p_temp->left);            
            }        
        }        
        return true;    
    }
};

迭代