面试之leetcode链表

1 数组

(1)数组的插入

如果是插入到最后，那么不用移动O(1)，如果插入位置在中间为O(n).所以最好O(1),最坏O(N),平均O(N)，为了插入能达到O(1)，插入O(1).引入了链表

2 链表

单链表查找慢O(n)，但是插入和删除O(1)

3 案例

(1)案例1 反转链表

c++版本

 class Solution {
 public:
     ListNode* reverseList(ListNode* head) {
           ListNode *prev = NULL; //前指针节点
         ListNode *curr = head; //当前指针节点
         //每次循环，都将当前节点指向它前面的节点，然后当前节点和前节点后移
         while (curr != NULL) {
             ListNode *nextTemp = curr->next; //临时节点，暂存当前节点的下一节点，用于后移
             curr->next = prev; //将当前节点指向它前面的节点
             prev = curr; //前指针后移
             curr = nextTemp; //当前指针后移
         }
         return prev;
     }
 };

python版本

 class Solution(object):
     def reverseList(self, head):
         """
         :type head: ListNode
         :rtype: ListNode
         """
         cur,prev=head,None
         while cur:
             cur.next,prev,cur=prev,cur,cur.next
         return prev

(2)案例2 判断环

方法1:使用set存放节点的地址

方法2:快慢指针，正常情况下一个快一个慢不会相遇，所以判定条件就是是否相遇

c++版本：

 class Solution {
 public:
     bool hasCycle(ListNode *head) {
        if(head==NULL)
        {
            return false;
        }
         ListNode *plow=head;
         ListNode *pfast = head->next;
         while(pfast!=plow)
         {
             if(!pfast||!pfast->next)
             {
                 return false;
             }
             pfast=pfast->next->next;
             plow=plow->next;

         }
         return true;

     }
 }; 

py版本

 class Solution(object):
     def hasCycle(self, head):
         """
         :type head: ListNode
         :rtype: bool
         """
         fast=slow=head
         while slow and fast and fast.next:
             slow=slow.next
             fast=fast.next.next
             if slow is fast:
                 return True
         return False