leetcode刷题纪实（一）

用leetcode开始刷题，每天不多做，大概3-5道题就OK
从易到难，先做链表题目

leetcode21

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
解法一：

class Solution 
{
public:    
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) 
    {        
        struct ListNode *l,*head ;        
        head = new ListNode;        
        l = head;        
        if(l1==NULL)return l2;        
        if(l2==NULL)return l1;        
        while(l1&&l2){           
            if(l1->val<l2->val){                
                l->next=l1;                
                l1=l1->next;                
                l=l->next;            
            }            
            else{                
                l->next=l2;                
                l2=l2->next;                
                l=l->next;            
            }        
        }        
        l->next=l1?l1:l2;        
        return head->next;    
    }
};

这个应该是上数据结构课的时候学会的最初级的代码，效率确实是不行，注意一点就是要创建一个head头结点，而不能只创建l节点，这样会使链表头在操作中丢失，注意这一点就行

解法二：

class Solution 
{    
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {        
        if(l1 == null) {            
            return l2;        
        }        
        if(l2 == null) {            
            return l1;        
        }
        if(l1.val < l2.val) {            
            l1.next = mergeTwoLists(l1.next, l2);            
            return l1;        
         } 
         else {            
             l2.next = mergeTwoLists(l1, l2.next);            
             return l2;        
         }    
     }
 }

非常简洁的递归方式，而且可以说是一目了然，学习一下

leetcode83

难度简单273给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

class Solution 
{public:    
    ListNode* deleteDuplicates(ListNode* head) 
    {        
        if(head==NULL){            
            return head;        
        }        
        ListNode *l1=head;        
        ListNode *l2=l1->next;        
        while(l2!=NULL){            
            if(l1->val==l2->val){                
            l2=l2->next;                
            l1->next=l2;            
        }            
        else{                
            l2=l2->next;                
            l1=l1->next;            
        }        
    }        
    return head;
}
};

很简单的双指针应用，应该是没啥问题的，就是在开头要注意一下head是空的情况单独讨论一下，不然会报错尝试用空指针进行赋值

class Solution 
{public:    
    ListNode* deleteDuplicates(ListNode* head) {        
        if(!head||!head->next)            
            return head;        
        head->next=deleteDuplicates(head->next);        
        if(head->val==head->next->val) head=head->next;        
            return head;    
    }
};

同样的递归法，学习一下