Random stuff

Author: theEmbeddedGeorge

Data_Struct_Implementation/endianessSwap/README.md

@@ -39,6 +39,33 @@ int main (int argc, char *argv[]) {
 	return 0;
 }
 
+class Solution {
+public:
+    uint32_t reverseBits(uint32_t n) {
+        n = (n << 16) | (n >> 16);
+        n = ((n << 8) & 0xff00ff00) | ((n >> 8) & 0x00ff00ff);
+        n = ((n << 4) & 0xf0f0f0f0) | ((n >> 4) & 0x0f0f0f0f);
+        n = ((n << 2) & 0xcccccccc) | ((n >> 2) & 0x33333333);
+        n = ((n << 1) & 0xaaaaaaaa) | ((n >> 1) & 0x55555555);
+        
+        return n;
+    }
+};
+class Solution {
+public:
+    uint32_t reverseBits(uint32_t n) {
+        uint32_t ret{};
+        int m = 32;
+        
+        while(m --) {
+            ret <<= 1;
+            ret |= (n & 0x1);
+            n >>= 1;
+        }
+        
+        return ret;
+    }
+};
 ```
 
 ## Reference

Interview/Company/facebook/algorithm_prepare.md

@@ -37,11 +37,18 @@
 5. Add two number II        Medium
 6. Linked List Insertion Sort       Medium
 7. Swap Nodes in Pairs      Medium
+8. Odd Even Linked List     Medium
+9. Insert into a Cyclic Sorted List     Medium
+10. Rotate List     Medium
 
 ## String
 1. Valid Anagram        Easy
 2. Integer to English Words     Hard
 
+## Bits Manipulation
+
+## Data Structure
+1. LRU cache
 
 ## Implementation
 
@@ -1472,4 +1479,182 @@ public:
         return sentinal.next;
     }
 };
+```
+### **Odd Even Linked List**
+
+***Big O:*** O(N) speed, O(1) space
+```
+Tips:
+
+Construct the even and odd linked list first. Then hook the even list to the tail of the odd list.
+```
+```c++
+class Solution {
+public:
+    ListNode * oddEvenList(ListNode * head) {
+        // write your code here
+        if (!head || !head->next)
+            return head;
+
+        ListNode odd, even, *iterator, *odd_it, *even_it;
+        iterator = head;
+        odd_it = &odd;
+        even_it = &even;
+        
+        int count = 1;
+        while (iterator) {
+            if (count % 2 != 0) {
+                odd_it->next = iterator;
+                odd_it = odd_it->next;
+            }
+            else {
+                even_it->next = iterator;
+                even_it = even_it->next;
+            }
+            count ++;
+            iterator = iterator->next;
+        }
+        even_it->next = nullptr;
+        odd_it->next = even.next;
+
+        return odd.next;
+    }
+};
+```
+
+### **Insert into a Cyclic Sorted List**
+
+***Big O:*** O(N) speed, O(1) space
+```
+Tips:
+
+Pre and cur node for single linked list. Watch out for corner cases.
+```
+```c++
+class Solution {
+public:
+    ListNode * insert(ListNode * head, int x) {
+        // write your code here
+        if (!head) {
+            ListNode *new_node = new ListNode(x, nullptr);
+            new_node->next = new_node;
+            return new_node;
+        }
+
+        ListNode *pre = nullptr, *cur = head;
+        do {
+            pre = cur;
+            cur = cur->next;
+
+            if (pre->val <= x && cur->val >= x)
+                break;
+            if (pre->val > cur->val && (x > pre->val || x < cur->val))
+                break;
+        } while (cur != head);
+
+        ListNode *new_node = new ListNode(x, cur);
+        pre->next = new_node;
+
+        return head;
+    }
+};
+```
+### **Rotate List**
+
+***Big O:*** O(N) speed, O(1) space
+```
+Tips:
+
+Count the nodes and count the effective move. Then rotate starting from the last node. Be careful of step = 1 case.
+```
+```c++
+class Solution {
+public:
+    ListNode * rotateRight(ListNode * head, int k) {
+        // write your code here
+        if (!head || !head->next)
+            return head;
+
+        int nodes_num = 1;
+        ListNode* iterator = head;
+        while (iterator->next) {
+            nodes_num ++;
+            iterator = iterator->next;
+        }
+        int effective_move = k%nodes_num;
+        if (effective_move == 0) return head;
+
+        iterator->next = head;
+        int step = nodes_num - effective_move;
+        while (step--) {
+            iterator = iterator->next;
+        }
+
+        ListNode *new_head = iterator->next;
+        iterator->next = nullptr;
+
+        return new_head;
+    }
+};
+```
+
+### **LRU cache**
+
+***Big O:*** O(1) speed, O(n) space
+```
+Tips:
+
+Double linked list + hashmap
+
+Use stl list to store the data and unordered hash map to record the position of the nodes.
+```
+```c++
+#include <list>
+
+class LRUCache {
+public:
+    struct LRUNode {
+        int value;
+        int key;
+        
+        LRUNode(int k, int v) : key(k), value(v) {}
+    };
+    
+    LRUCache(int capacity) : cap(capacity) {}
+
+    int get(int key) {
+        if (!kv.count(key)) {
+            return -1;
+        }
+        move_front(key);
+        return values.front().value;
+    }
+
+    void set(int key, int value) {
+        if (!kv.count(key)) {
+            values.emplace_front(key, value);
+            kv[key] = values.begin();
+            if (values.size() > cap) {
+                kv.erase(values.back().key);
+                values.pop_back();
+            }
+        } else {
+            kv[key]->value = value;
+            move_front(key);
+        }
+    }
+    
+private:
+    int move_front(int key) {
+        LRUNode node = *kv[key];
+        values.erase(kv[key]);
+        values.push_front(node);
+        kv[key] = values.begin();
+    }
+    
+private:
+    int cap;
+    std::list<LRUNode> values;
+    std::unordered_map<int, list<LRUNode>::iterator> kv;
+};
 ```

Interview/Company/intuitive/README.md

@@ -68,7 +68,7 @@ please.
 - A abstration data struture that groups all modules and their fans together as well as handles fan hardware related operation such as module temperature value updating and fan speed duty cycle seting and calculation.
 
 ***Fan Control Client:***
-- A program that performs temperature reading and send them out either as a reply to server's request, nor as whenever it feels appropriate to (e.g. need urgent fan speed increase due to overheat)
+- A program that performs temperature reading and send them out either as a reply to server's request, or as whenever it feels appropriate to (e.g. need urgent fan speed increase due to overheat)
 - In real-world scenario, client module process usually has other tasks. However in our app demo, client is assumed to have one task only - to read temperature and send out to server whenever it needs to.
 
 ***Server Msg Queue***

README.md

@@ -54,7 +54,7 @@
 3. [Endianess Check](Data_Struct_Implementation/endianess/README.md)
 4. [Swap Endianess](Data_Struct_Implementation/endianessSwap/README.md)
 5. Signness Check
-6. [Array of Bits](Data_Struct_Implementation/bitsArray/README.md)
+6. [Array of Bits (bit sets/bit map)](Data_Struct_Implementation/bitsArray/README.md)
 7. Low Pass Filter
 8. [Memory map IO register manipulation](Data_Struct_Implementation/memoryMap/memory_map_io.md)
 9. Timer list
@@ -115,11 +115,11 @@
 
 ### D. Basic Algorithms
 1. [Sort](https://www.cnblogs.com/onepixel/p/7674659.html)
-   1.  [Bubble Sort](/Data_Struct_Implementation/bubbleSort/bubbleSort.md)
-   2.  [Merge Sort](/Data_Struct_Implementation/mergeSort/mergeSort.md)
-   3.  [Quick Sort](/Data_Struct_Implementation/quickSort/quicksort.md)
-   4.  [Heap Sort](/Data_Struct_Implementation/heapSort/heapSort.md)
-   5.  [Insertion Sort](/Data_Struct_Implementation/insertionSort/insertionSort.md)
+   1.  [Bubble Sort](Data_Struct_Implementation/bubbleSort/bubbleSort.md)
+   2.  [Merge Sort](Data_Struct_Implementation/mergeSort/mergeSort.md)
+   3.  [Quick Sort](Data_Struct_Implementation/quickSort/quicksort.md)
+   4.  [Heap Sort](Data_Struct_Implementation/heapSort/heapSort.md)
+   5.  [Insertion Sort](Data_Struct_Implementation/insertionSort/insertionSort.md)
    6.  Binary Insertion Sort
 2.  Search
     1.  [Hash](Data_Struct_Implementation/hashTable/README.md)
@@ -173,6 +173,10 @@
     2.  Memory Hardware
     3.  [Virtual Addressing/Memory](Operating_System/virtual_memory.md)
 5.  File System Management
+    1.  Operations on Files
+    2.  Virtual File System
+    3.  Concrete File System
+    4.  Inodes
 6.  Device I/O Management
 7.  RTOS
     1.  FreeRTOS