shdwkl/ciu.html

## ciu.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Coding Interview University Mind Map (Markmap)</title>
    <style>
        body {
            font-family: sans-serif;
            margin: 0; /* Remove default margin */
            height: 100vh; /* Make body take full height */
        }
        /* Style the container for the mind map */
        .markmap-container {
            width: 100%;  /* Make it take up the full width */
            height: 100%; /* Make it take up the full height */
            display: flex;
            justify-content: center;
            align-items: center;
        }
        svg#markmap {
            width: 100%;
            height: 100%;
        }
    </style>
    <!-- Include the necessary libraries from a CDN -->
    <script src="https://cdn.jsdelivr.net/npm/d3@7"></script>
    <script src="https://cdn.jsdelivr.net/npm/markmap-view"></script>
    <script src="https://cdn.jsdelivr.net/npm/markmap-lib"></script>
    <script src="https://cdn.jsdelivr.net/npm/markmap-toolbar"></script>
</head>
<body>

    <h1>Coding Interview University Mind Map</h1>

    <div class="markmap-container">
      <svg id="markmap"></svg>
    </div>

    <!-- Markdown Data -->
    <script type="text/template" id="markdown-data">
*   **Coding Interview University Notes (6 Months)**

    *   **Core Concepts**
        *   Algorithmic Complexity
            *   Big-O Notation
                *   O(1)
                *   O(log n)
                *   O(n)
                *   O(n log n)
                *   O(n^2)
                *   O(2^n)
                *   O(n!)
            *   Asymptotic Analysis
            *   Best, Average, Worst Case Scenarios

    *   **Data Structures**
        *   Linear
            *   Arrays
                *   Static vs. Dynamic
                *   Operations: Access, Insert, Delete, Search
                *   Time Complexity of Operations
            *   Linked Lists
                *   Singly vs. Doubly vs. Circular
                *   Operations: Insert, Delete, Search, Traverse
                *   Time Complexity of Operations
            *   Stacks
                *   LIFO (Last-In, First-Out)
                *   Operations: Push, Pop, Peek
                *   Time Complexity of Operations, Use Cases (e.g., function call stack)
            *   Queues
                *   FIFO (First-In, First-Out)
                *   Operations: Enqueue, Dequeue, Peek
                *   Time Complexity of Operations, Use Cases (e.g., task scheduling)
        *   Non-Linear
            *   Hash Tables
                *   Hash Functions
                *   Collision Handling (Chaining, Open Addressing)
                *   Operations: Insert, Delete, Search
                *   Time Complexity of Operations, Use Cases (Caching, Lookup Table)
            *   Trees
                *   General Concepts
                    *   Root, Node, Leaf, Edge, Height, Depth
                    *   Types of Trees
                *   Binary Search Trees (BSTs)
                    *   Definition: Ordered Nodes
                    *   Operations: Insert, Delete, Search, Find Min/Max
                    *   Time Complexity (Balanced vs. Unbalanced)
                *   Heaps / Priority Queues
                    *   Min-Heap vs. Max-Heap
                    *   Heapify, Insert, Extract Min/Max
                    *   Time Complexity, Use Cases (e.g., priority scheduling)
                *   Balanced Search Trees
                    *   AVL Trees (concept)
                    *   Red-Black Trees (concept)
                    *   B-Trees (concept)

    *   **Algorithms**
        *   Searching
            *   Binary Search
                *   Iterative vs. Recursive, Time Complexity (O(log n))
        *   Bitwise Operations
            *   AND, OR, XOR, NOT, Shift Left, Shift Right
            *   Use Cases: Setting bits
        *   Tree Traversals
            *   Preorder (Root, Left, Right)
            *   Inorder (Left, Root, Right) - BST specific: sorted order
            *   Postorder (Left, Right, Root)
            *   Breadth-First Search (BFS) - Level Order
            *   Depth-First Search (DFS) - Uses Stack (Pre, In, Post are DFS variants)
        *   Sorting
            *   Selection Sort (O(n^2))
            *   Insertion Sort (O(n^2), good for nearly sorted data)
            *   Heapsort (O(n log n))
            *   Quicksort (Average O(n log n), Worst O(n^2))
            *   Mergesort (O(n log n))
        *   Graph Traversals
            *   Breadth-First Search (BFS) - Uses Queue
            *   Depth-First Search (DFS) - Uses Stack
            *   Topological Sorting

        *   Graphs
            *   Directed vs. Undirected
            *   Representations
                *   Adjacency Matrix
                *   Adjacency List
            * Weighted vs Unweighted, Cyclic vs Acyclic
        *   Recursion
            *   Base Case, Recursive Step
            *   Call Stack, Stack Overflow
        *   Dynamic Programming
            *   Memoization (Top-Down)
            *   Tabulation (Bottom-Up)

    *   **Even More Knowledge**
        *   Design Patterns
            *   Creational, Structural, Behavioral
        *   Combinatorics & Probability
            *   n choose k (combinations)
        *   NP, NP-Complete, Approximation Algorithms
        *   How Computers Process a Program
            *   Compilation, Interpretation, Assembly
            *   Instruction Set Architecture (ISA)
        *   Caches
            *   L1, L2, L3 Cache
            *   Cache Hits/Misses, Locality of Reference
        *   Processes and Threads
            *   Concurrency vs. Parallelism
            *   Multithreading, Synchronization
        *   Testing
            *   Unit Testing, Integration Testing, System Testing
            *   Test-Driven Development (TDD)
        *   String Searching & Manipulations
              * Brute Force, Rabin-Karp, Knuth-Morris-Pratt (KMP)
              * Regular expression
        *   Tries
            *   Prefix Trees, Autocomplete
        *   Floating Point Numbers
            *   IEEE 754 Standard, Precision Issues
        *   Unicode
            *   UTF-8, UTF-16, Character Encoding
        *   Endianness
            *   Big-Endian vs. Little-Endian
        *   Networking
              * OSI Model, TCP/IP Model
              * Sockets, HTTP, HTTPS
              * Client-Server Architecture
    </script>

    <!-- JavaScript to create the mind map -->
    <script>
      const { markmap } = window;
      const {
        Transformer,
        Markmap,
        Toolbar,
      } = window.markmap;  // Access directly from window.markmap

      const transformer = new Transformer();
      const mindmapData = document.getElementById('markdown-data').textContent;

      // 1. Transform Markdown
      const { root, features } = transformer.transform(mindmapData);
      // 2. Get assets
      const { styles, scripts } = transformer.getUsedAssets(features);

      // 3. Load assets
      if (styles) styles.forEach((style) => {
        const link = document.createElement('link');
        link.rel = 'stylesheet';
        link.href = style.data.url;
        document.head.append(link);
      });

      if (scripts) scripts.forEach((script) => {
        const scriptEl = document.createElement('script');
        scriptEl.src = script.data.url;
        document.body.append(scriptEl);
      });

      // Create the Markmap instance
      const mm = Markmap.create(document.querySelector('svg#markmap'), null, root);

      // Add the toolbar
      const toolbar = new Toolbar();
      toolbar.attach(mm);
      document.querySelector('.markmap-container').append(toolbar.render());

    </script>
</body>
</html>
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<title>Coding Interview University Mind Map (Markmap)</title>
	<style>
	body {
	font-family: sans-serif;
	margin: 0; /* Remove default margin */
	height: 100vh; /* Make body take full height */
	}
	/* Style the container for the mind map */
	.markmap-container {
	width: 100%; /* Make it take up the full width */
	height: 100%; /* Make it take up the full height */
	display: flex;
	justify-content: center;
	align-items: center;
	}
	svg#markmap {
	width: 100%;
	height: 100%;
	}
	</style>
	<!-- Include the necessary libraries from a CDN -->
	<script src="https://cdn.jsdelivr.net/npm/d3@7"></script>
	<script src="https://cdn.jsdelivr.net/npm/markmap-view"></script>
	<script src="https://cdn.jsdelivr.net/npm/markmap-lib"></script>
	<script src="https://cdn.jsdelivr.net/npm/markmap-toolbar"></script>
	</head>
	<body>

	<h1>Coding Interview University Mind Map</h1>

	<div class="markmap-container">
	<svg id="markmap"></svg>
	</div>

	<!-- Markdown Data -->
	<script type="text/template" id="markdown-data">
	* Coding Interview University Notes (6 Months)

	* Core Concepts
	* Algorithmic Complexity
	* Big-O Notation
	* O(1)
	* O(log n)
	* O(n)
	* O(n log n)
	* O(n^2)
	* O(2^n)
	* O(n!)
	* Asymptotic Analysis
	* Best, Average, Worst Case Scenarios

	* Data Structures
	* Linear
	* Arrays
	* Static vs. Dynamic
	* Operations: Access, Insert, Delete, Search
	* Time Complexity of Operations
	* Linked Lists
	* Singly vs. Doubly vs. Circular
	* Operations: Insert, Delete, Search, Traverse
	* Time Complexity of Operations
	* Stacks
	* LIFO (Last-In, First-Out)
	* Operations: Push, Pop, Peek
	* Time Complexity of Operations, Use Cases (e.g., function call stack)
	* Queues
	* FIFO (First-In, First-Out)
	* Operations: Enqueue, Dequeue, Peek
	* Time Complexity of Operations, Use Cases (e.g., task scheduling)
	* Non-Linear
	* Hash Tables
	* Hash Functions
	* Collision Handling (Chaining, Open Addressing)
	* Operations: Insert, Delete, Search
	* Time Complexity of Operations, Use Cases (Caching, Lookup Table)
	* Trees
	* General Concepts
	* Root, Node, Leaf, Edge, Height, Depth
	* Types of Trees
	* Binary Search Trees (BSTs)
	* Definition: Ordered Nodes
	* Operations: Insert, Delete, Search, Find Min/Max
	* Time Complexity (Balanced vs. Unbalanced)
	* Heaps / Priority Queues
	* Min-Heap vs. Max-Heap
	* Heapify, Insert, Extract Min/Max
	* Time Complexity, Use Cases (e.g., priority scheduling)
	* Balanced Search Trees
	* AVL Trees (concept)
	* Red-Black Trees (concept)
	* B-Trees (concept)

	* Algorithms
	* Searching
	* Binary Search
	* Iterative vs. Recursive, Time Complexity (O(log n))
	* Bitwise Operations
	* AND, OR, XOR, NOT, Shift Left, Shift Right
	* Use Cases: Setting bits
	* Tree Traversals
	* Preorder (Root, Left, Right)
	* Inorder (Left, Root, Right) - BST specific: sorted order
	* Postorder (Left, Right, Root)
	* Breadth-First Search (BFS) - Level Order
	* Depth-First Search (DFS) - Uses Stack (Pre, In, Post are DFS variants)
	* Sorting
	* Selection Sort (O(n^2))
	* Insertion Sort (O(n^2), good for nearly sorted data)
	* Heapsort (O(n log n))
	* Quicksort (Average O(n log n), Worst O(n^2))
	* Mergesort (O(n log n))
	* Graph Traversals
	* Breadth-First Search (BFS) - Uses Queue
	* Depth-First Search (DFS) - Uses Stack
	* Topological Sorting

	* Graphs
	* Directed vs. Undirected
	* Representations
	* Adjacency Matrix
	* Adjacency List
	* Weighted vs Unweighted, Cyclic vs Acyclic
	* Recursion
	* Base Case, Recursive Step
	* Call Stack, Stack Overflow
	* Dynamic Programming
	* Memoization (Top-Down)
	* Tabulation (Bottom-Up)

	* Even More Knowledge
	* Design Patterns
	* Creational, Structural, Behavioral
	* Combinatorics & Probability
	* n choose k (combinations)
	* NP, NP-Complete, Approximation Algorithms
	* How Computers Process a Program
	* Compilation, Interpretation, Assembly
	* Instruction Set Architecture (ISA)
	* Caches
	* L1, L2, L3 Cache
	* Cache Hits/Misses, Locality of Reference
	* Processes and Threads
	* Concurrency vs. Parallelism
	* Multithreading, Synchronization
	* Testing
	* Unit Testing, Integration Testing, System Testing
	* Test-Driven Development (TDD)
	* String Searching & Manipulations
	* Brute Force, Rabin-Karp, Knuth-Morris-Pratt (KMP)
	* Regular expression
	* Tries
	* Prefix Trees, Autocomplete
	* Floating Point Numbers
	* IEEE 754 Standard, Precision Issues
	* Unicode
	* UTF-8, UTF-16, Character Encoding
	* Endianness
	* Big-Endian vs. Little-Endian
	* Networking
	* OSI Model, TCP/IP Model
	* Sockets, HTTP, HTTPS
	* Client-Server Architecture
	</script>

	<!-- JavaScript to create the mind map -->
	<script>
	const { markmap } = window;
	const {
	Transformer,
	Markmap,
	Toolbar,
	} = window.markmap; // Access directly from window.markmap

	const transformer = new Transformer();
	const mindmapData = document.getElementById('markdown-data').textContent;

	// 1. Transform Markdown
	const { root, features } = transformer.transform(mindmapData);
	// 2. Get assets
	const { styles, scripts } = transformer.getUsedAssets(features);

	// 3. Load assets
	if (styles) styles.forEach((style) => {
	const link = document.createElement('link');
	link.rel = 'stylesheet';
	link.href = style.data.url;
	document.head.append(link);
	});

	if (scripts) scripts.forEach((script) => {
	const scriptEl = document.createElement('script');
	scriptEl.src = script.data.url;
	document.body.append(scriptEl);
	});

	// Create the Markmap instance
	const mm = Markmap.create(document.querySelector('svg#markmap'), null, root);

	// Add the toolbar
	const toolbar = new Toolbar();
	toolbar.attach(mm);
	document.querySelector('.markmap-container').append(toolbar.render());

	</script>
	</body>
	</html>
No results found