面试之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