2022-08-15

[Zheaoli]

2022-08-15

[SaraadKun]

641. 设计循环双端队列

class MyCircularDeque {

    int N, head, tail, sz;
    int[] data;

    public MyCircularDeque(int k) {
        this.N = k;
        this.data = new int[N];
        this.head = 0;
        this.tail = 0;
        this.sz = 0;
    }

    public boolean insertFront(int value) {
        if (sz == N) {
            return false;
        }
        head = sz == 0 ? head : (head + 1) % N;
        data[head] = value;
        sz++;
        return true;
    }

    public boolean insertLast(int value) {
        if (sz == N) {
            return false;
        }
        tail = sz == 0 ? tail : (tail + N - 1) % N;
        data[tail] = value;
        sz++;
        return true;
    }

    public boolean deleteFront() {
        if (sz == 0) {
            return false;
        }
        head = sz == 1 ? head : (head + N - 1) % N;
        sz--;
        return true;
    }

    public boolean deleteLast() {
        if (sz == 0) {
            return false;
        }
        tail = sz == 1 ? tail : (tail + 1) % N;
        sz--;
        return true;
    }

    public int getFront() {
        return sz == 0 ? -1 : data[head];
    }

    public int getRear() {
        return sz == 0 ? -1 : data[tail];
    }

    public boolean isEmpty() {
        return sz == 0;
    }

    public boolean isFull() {
        return sz == N;
    }
}

---

WeChat: Saraad

[gongpeione]

/*
 * @lc app=leetcode id=141 lang=typescript
 *
 * [141] Linked List Cycle
 */

// @lc code=start
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     val: number
 *     next: ListNode | null
 *     constructor(val?: number, next?: ListNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.next = (next===undefined ? null : next)
 *     }
 * }
 */

function hasCycle(head: ListNode | null): boolean {
    // const m = new Map();
    // while(head) {
    //     if (m.has(head)) {
    //         return true;
    //     }
    //     m.set(head, true);
    //     head = head.next;
    // }
    // return false;

    let slow = head;
    let fast = head;

    while (fast) {
        if (!fast.next?.next) {
            return false;
        }

        slow = slow.next;
        fast = fast.next.next;

        if (fast === slow) {
            return true;
        }
    }

    return false;
};
// @lc code=end

---

微信id: 弘树 来自 vscode 插件

[dreamhunter2333]

#
# @lc app=leetcode.cn id=641 lang=python3
#
# [641] 设计循环双端队列
#

# @lc code=start
class Node:
    def __init__(self, value: int, pre: "Node" = None, post: "Node" = None) -> None:
        self.value = value
        self.pre = pre
        self.post = post

class MyCircularDeque:

    def __init__(self, k: int):
        self.max_size = k
        self.size = 0
        self.head = Node(0)
        self.tail = Node(0)
        self.head.post = self.tail
        self.tail.pre = self.head

    def insertFront(self, value: int) -> bool:
        if self.size >= self.max_size:
            return False
        node = Node(value)
        post_node = self.head.post
        post_node.pre = node
        self.head.post = node
        node.post = post_node
        node.pre = self.head
        self.size += 1
        return True

    def insertLast(self, value: int) -> bool:
        if self.size >= self.max_size:
            return False
        node = Node(value)
        pre_node = self.tail.pre
        pre_node.post = node
        self.tail.pre = node
        node.post = self.tail
        node.pre = pre_node
        self.size += 1
        return True

    def deleteFront(self) -> bool:
        if self.size <= 0:
            return False
        post_node = self.head.post
        next_node = post_node.post
        self.head.post = next_node
        next_node.pre = self.head
        self.size -= 1
        return True

    def deleteLast(self) -> bool:
        if self.size <= 0:
            return False
        pre_node = self.tail.pre
        next_node = pre_node.pre
        self.tail.pre = next_node
        next_node.post = self.tail
        self.size -= 1
        return True

    def getFront(self) -> int:
        if self.size <= 0:
            return -1
        return self.head.post.value

    def getRear(self) -> int:
        if self.size <= 0:
            return -1
        return self.tail.pre.value

    def isEmpty(self) -> bool:
        return self.size <= 0

    def isFull(self) -> bool:
        return self.size == self.max_size

# @lc code=end

---

微信id: 而我撑伞 来自 vscode 插件