From 9f11ec1399472c946b8c0e9e94722cd952eac5eb Mon Sep 17 00:00:00 2001 From: RDCynthia Date: Sun, 12 Apr 2020 12:34:27 +0800 Subject: [PATCH] week 06 homework commit --- second/week_06/81/BoundedBlockingQueue.md | 54 +++++++++++ second/week_06/81/MyCircularDeque.md | 84 +++++++++++++++++ second/week_06/81/MyCircularQueue.md | 35 +++++++ second/week_06/81/MyHashMap.md | 78 ++++++++++++++++ second/week_06/81/MyHashSet.md | 72 +++++++++++++++ second/week_06/81/MyLinkedList.md | 106 ++++++++++++++++++++++ 6 files changed, 429 insertions(+) create mode 100644 second/week_06/81/BoundedBlockingQueue.md create mode 100644 second/week_06/81/MyCircularDeque.md create mode 100644 second/week_06/81/MyCircularQueue.md create mode 100644 second/week_06/81/MyHashMap.md create mode 100644 second/week_06/81/MyHashSet.md create mode 100644 second/week_06/81/MyLinkedList.md diff --git a/second/week_06/81/BoundedBlockingQueue.md b/second/week_06/81/BoundedBlockingQueue.md new file mode 100644 index 0000000..a627c20 --- /dev/null +++ b/second/week_06/81/BoundedBlockingQueue.md @@ -0,0 +1,54 @@ +```java +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.ReentrantLock; + +public class BoundedBlockingQueue { + + private int[] data; + private int left; + private int right; + private ReentrantLock lock; + private Condition isFull; + private Condition isEmpty; + + public BoundedBlockingQueue(int capacity) { + data = new int[capacity]; + lock = new ReentrantLock(); + isFull = lock.newCondition(); + isEmpty = lock.newCondition(); + } + + public void enqueue(int element) throws InterruptedException { + ReentrantLock lock = this.lock; + lock.lock(); + try { + while (right - left == data.length) + isFull.await(); + data[right++ % data.length] = element; + isEmpty.signal(); + } finally { + lock.unlock(); + } + } + + public int dequeue() throws InterruptedException { + ReentrantLock lock = this.lock; + lock.lock(); + try { + while (right - left == 0) + isEmpty.await(); + int value = data[left++ % data.length]; + isFull.signal(); + return value; + } finally { + lock.unlock(); + } + } + + public int size() { + return right - left; + } + +} + +``` \ No newline at end of file diff --git a/second/week_06/81/MyCircularDeque.md b/second/week_06/81/MyCircularDeque.md new file mode 100644 index 0000000..bef8310 --- /dev/null +++ b/second/week_06/81/MyCircularDeque.md @@ -0,0 +1,84 @@ +```java +public class MyCircularDeque3 { + + private int head; + private int tail; + private int len; + private int[] obj; + + public MyCircularDeque3(int k) { + this.obj = new int[k]; + } + + public boolean insertFront(int value) { + if (!isFull()) { + if (!isEmpty()) head = (head - 1 + obj.length) % obj.length; + obj[head] = value; + len++; + return true; + } + return false; + } + + public boolean insertLast(int value) { + if (!isFull()) { + if (!isEmpty()) tail = (tail + 1) % obj.length; + obj[tail] = value; + len++; + return true; + } + return false; + } + + public boolean deleteFront() { + if (!isEmpty()) { + if (len > 1) head = (head + 1) % obj.length; + len--; + return true; + } + return false; + } + + public boolean deleteLast() { + if (!isEmpty()) { + if (len > 1) tail = (tail - 1 + obj.length) % obj.length; + len--; + return true; + } + return false; + } + + public int getFront() { + return isEmpty() ? -1 : obj[head]; + } + + public int getRear() { + return isEmpty() ? -1 : obj[tail]; + } + + public boolean isEmpty() { + return len == 0; + } + + public boolean isFull() { + return len == obj.length; + } + + /*public static void main(String[] args) { + + MyCircularDeque obj = new MyCircularDeque(2); + System.out.println(obj.insertFront(7)); + System.out.println(obj.deleteLast()); + System.out.println(obj.getFront()); + System.out.println(obj.insertLast(5)); + System.out.println(obj.insertFront(0)); + System.out.println(obj.getFront()); + System.out.println(obj.getRear()); + System.out.println(obj.getFront()); + System.out.println(obj.getFront()); + System.out.println(obj.getRear()); + System.out.println(obj.insertLast(5)); + }*/ +} + +``` \ No newline at end of file diff --git a/second/week_06/81/MyCircularQueue.md b/second/week_06/81/MyCircularQueue.md new file mode 100644 index 0000000..46949e2 --- /dev/null +++ b/second/week_06/81/MyCircularQueue.md @@ -0,0 +1,35 @@ +```java +public class MyCircularQueue { + + int[] data; + int left, right; + + public MyCircularQueue(int k) { + data = new int[k]; + } + + public boolean enQueue(int value) { + return !isFull() && (data[right++ % data.length] = value) != -1; + } + + public boolean deQueue() { + return !isEmpty() && ++left != -1; + } + + public int Front() { + return !isEmpty() ? data[left % data.length] : -1; + } + + public int Rear() { + return !isEmpty() ? data[(right - 1) % data.length] : -1; + } + + public boolean isEmpty() { + return left == right; + } + + public boolean isFull() { + return right - left == data.length; + } +} +``` \ No newline at end of file diff --git a/second/week_06/81/MyHashMap.md b/second/week_06/81/MyHashMap.md new file mode 100644 index 0000000..4c43880 --- /dev/null +++ b/second/week_06/81/MyHashMap.md @@ -0,0 +1,78 @@ +```java +public class MyHashMap { + + static final int length = 1 << 14; + static final Node[] data = new Node[length]; + + + static class Node { + int key; + int value; + Node next = null; + + Node(int key, int value) { + this.key = key; + this.value = value; + } + } + + public MyHashMap() { + + } + + public void put(int key, int value) { + int hash = key & (length - 1); + Node node = data[hash]; + if (node == null) { + node = new Node(key, value); + data[hash] = node; + } else { + while (true) { + if (node.key == key) { + node.value = value; + break; + } + if (node.next == null) { + node.next = new Node(key, value); + break; + } + node = node.next; + } + } + } + + + public int get(int key) { + int hash = key & (length - 1); + Node node = data[hash]; + if (node == null) return -1; + while (true) { + if (node.key == key) return node.value; + if (node.next == null) return -1; + node = node.next; + } + } + + public void remove(int key) { + int hash = key & (length - 1); + Node node = data[hash]; + Node prev = null; + if (node != null) { + while (true) { + if (node.key == key) { + if (prev == null) + data[hash] = node.next; + else + prev.next = node.next; + break; + } + if (node.next != null) { + prev = node; + node = node.next; + } else break; + } + } + } +} + +``` \ No newline at end of file diff --git a/second/week_06/81/MyHashSet.md b/second/week_06/81/MyHashSet.md new file mode 100644 index 0000000..850a61d --- /dev/null +++ b/second/week_06/81/MyHashSet.md @@ -0,0 +1,72 @@ +```java +public class MyHashSet { + + static final int length = 1 << 10; + static final Node[] data = new Node[length]; + + static class Node { + int key; + Node next = null; + + Node(int key) { + this.key = key; + } + } + + public MyHashSet() { + + } + + public void add(int key) { + int hash = key & (length - 1); + Node node = data[hash]; + if (node == null) { + node = new Node(key); + data[hash] = node; + } else { + while (true) { + if (node.key == key) { + break; + } + if (node.next == null) { + node.next = new Node(key); + break; + } + node = node.next; + } + } + } + + public void remove(int key) { + int hash = key & (length - 1); + Node node = data[hash]; + Node prev = null; + if (node != null) { + while (true) { + if (node.key == key) { + if (prev == null) + data[hash] = node.next; + else + prev.next = node.next; + break; + } + if (node.next != null) { + prev = node; + node = node.next; + } else break; + } + } + } + + public boolean contains(int key) { + int hash = key & (length - 1); + Node node = data[hash]; + if (node == null) return false; + while (true) { + if (node.key == key) return true; + if (node.next == null) return false; + node = node.next; + } + } +} +``` \ No newline at end of file diff --git a/second/week_06/81/MyLinkedList.md b/second/week_06/81/MyLinkedList.md new file mode 100644 index 0000000..974db93 --- /dev/null +++ b/second/week_06/81/MyLinkedList.md @@ -0,0 +1,106 @@ +```java +public class MyLinkedList { + + private Node head = null; + private Node tail = null; + private int size = 0; + + static class Node { + int value; + Node prev; + Node next; + + Node(int value) { + this.value = value; + } + } + + public MyLinkedList() { + + } + + public int get(int index) { + if (index >= 0 && index < size) { + Node node = head; + while (index-- > 0) { + node = node.next; + } + return node.value; + } + return -1; + } + + public void addAtHead(int val) { + Node node = new Node(val); + if (head == null) + head = tail = node; + else { + node.next = head; + head.prev = node; + head = node; + } + ++size; + } + + public void addAtTail(int val) { + Node node = new Node(val); + if (tail == null) + head = tail = node; + else { + tail.next = node; + node.prev = tail; + tail = node; + } + ++size; + } + + public void addAtIndex(int index, int val) { + if (index <= size) { + if (index <= 0) + addAtHead(val); + else if (index == size) + addAtTail(val); + else { + Node node = head; + while (index-- > 0) { + node = node.next; + } + Node prev = node.prev; + Node newNode = new Node(val); + prev.next = newNode; + newNode.prev = prev; + newNode.next = node; + node.prev = newNode; + ++size; + } + } + } + + public void deleteAtIndex(int index) { + if (index >= 0 && index < size) { + Node node = head; + while (index-- > 0) { + node = node.next; + } + Node prev = node.prev; + Node next = node.next; + + if (prev == null) { + head = next; + } else { + prev.next = next; + } + + if (next == null) { + tail = prev; + } else { + next.prev = prev; + } + + --size; + } + } + +} + +``` \ No newline at end of file -- Gitee