Skip to content
BranchesTags

Repository files navigation

Advanced Data Structures & Algorithms with Python

Course Schedule

Course Dates: Monday, March 20 – Friday, May 12, 2017 (7 weeks)

Class Times: Monday, Wednesday, Friday 1–3pm (21 class sessions)

Class 1: Monday, March 20 – Number Bases

Class 2: Wednesday, March 22 – Recursion & Search Algorithms

Class 3: Friday, March 24 – String Algorithms

Class 4: Monday, March 27 – List, Array & Linked List

Class 5: Wednesday, March 29 – List, Stack & Queue

Class 6: Friday, March 31 – Map & Hash Table

Class 7: Monday, April 3 – Set & Circular Buffer

Class 8: Wednesday, April 5 – Trees

Class 9: Friday, April 7 – Tree Traversals

Class 10: Monday, April 10 – Iterative Sorting Algorithms

Class 11: Wednesday, April 12 – Integer Sorting Algorithms

Class 12: Friday, April 14 – Divide-and-Conquer Recursion

Class 13: Monday, April 17 – Recursive Algorithm Analysis

Class 14: Wednesday, April 19 – Priority Queue & Heap

Class 15: Friday, April 21 – Sorting Algorithms Recap

Class 16: Monday, May 1 – Graphs

Class 17: Wednesday, May 3 – Graph Traversals & Components

Class 18: Friday, May 5 – Graph Spanning Trees & Shortest Paths

Class 19: Monday, May 8 – Rotating Binary Search Trees

Class 20: Wednesday, May 10 – Trie & Multiple Key Trees

Class 21: Friday, May 12 – Memoization & Dynamic Programming

Working with this GitHub repository

This repository (located at https://github.com/MakeSchool-18/Data-Structures) is the course's origin repository which will contain course materials including links, slides, and challenges. Note that you cannot commit or push to the origin repository. However, you can fork it to maintain your own version of it and push your code there. Here's an overview of what your repository setup should look like:

Repository Overview

Follow these steps to set up your own course repository:

  1. Clone this repository on your computer: git clone git@github.com:MakeSchool-18/Data-Structures.git

  2. Fork this repository on GitHub to create your own version of this repo on your GitHub account, which should also be named Data-Structures

  3. Add your GitHub repository as a remote to the local one on your computer (note: you need to give a name to the remote, e.g. your first name): git remote add <first-name> git@github.com:<github-user>/Data-Structures.git

  4. Link the local repo to your remote GitHub repo: git push -u <first-name> master

  5. When you want to access new course materials, just pull from the origin remote repo: git pull origin master

  6. When you've completed a challenge and want to share it for code review, commit your work and push it to your own remote repo with: git push

About

Product College course on Advanced Data Structures & Algorithms with Python

make.sc/data-structures-plan-q4

Resources

Readme
Activity
Custom properties

Stars

7 stars

Watchers

2 watching

Forks

22 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - MakeSchool-18/Data-Structures: Product College course on Advanced Data Structures & Algorithms with Python · GitHub
Skip to content
BranchesTags
Repository files navigation
Advanced Data Structures & Algorithms with Python
Course Schedule
Course Dates: Monday, March 20 – Friday, May 12, 2017 (7 weeks)
Class Times: Monday, Wednesday, Friday 1–3pm (21 class sessions)
Class 1: Monday, March 20 – Number Bases
Class 2: Wednesday, March 22 – Recursion & Search Algorithms
Class 3: Friday, March 24 – String Algorithms
Class 4: Monday, March 27 – List, Array & Linked List
Class 5: Wednesday, March 29 – List, Stack & Queue
Class 6: Friday, March 31 – Map & Hash Table
Class 7: Monday, April 3 – Set & Circular Buffer
Class 8: Wednesday, April 5 – Trees
Class 9: Friday, April 7 – Tree Traversals
Class 10: Monday, April 10 – Iterative Sorting Algorithms
Class 11: Wednesday, April 12 – Integer Sorting Algorithms
Class 12: Friday, April 14 – Divide-and-Conquer Recursion
Class 13: Monday, April 17 – Recursive Algorithm Analysis
Class 14: Wednesday, April 19 – Priority Queue & Heap
Class 15: Friday, April 21 – Sorting Algorithms Recap
Class 16: Monday, May 1 – Graphs
Class 17: Wednesday, May 3 – Graph Traversals & Components
Class 18: Friday, May 5 – Graph Spanning Trees & Shortest Paths
Class 19: Monday, May 8 – Rotating Binary Search Trees
Class 20: Wednesday, May 10 – Trie & Multiple Key Trees
Class 21: Friday, May 12 – Memoization & Dynamic Programming
Working with this GitHub repository
This repository (located at https://github.com/MakeSchool-18/Data-Structures) is the course's origin repository which will contain course materials including links, slides, and challenges.
Note that you cannot commit or push to the origin repository.
However, you can fork it to maintain your own version of it and push your code there. Here's an overview of what your repository setup should look like:
Repository Overview
Follow these steps to set up your own course repository:
  1. Clone this repository on your computer:
git clone git@github.com:MakeSchool-18/Data-Structures.git
  2. Fork this repository on GitHub to create your own version of this repo on your GitHub account, which should also be named Data-Structures
  3. Add your GitHub repository as a remote to the local one on your computer (note: you need to give a name to the remote, e.g. your first name):
git remote add <first-name> git@github.com:<github-user>/Data-Structures.git
  4. Link the local repo to your remote GitHub repo:
git push -u <first-name> master
  5. When you want to access new course materials, just pull from the origin remote repo:
git pull origin master
  6. When you've completed a challenge and want to share it for code review, commit your work and push it to your own remote repo with:
git push
About
Product College course on Advanced Data Structures & Algorithms with Python
make.sc/data-structures-plan-q4
Resources
Readme
Activity
Custom properties
Stars
7 stars
Watchers
2 watching
Forks
22 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - MakeSchool-18/Data-Structures: Product College course on Advanced Data Structures & Algorithms with Python · GitHub
Skip to content
BranchesTags
Repository files navigation
Advanced Data Structures & Algorithms with Python
Course Schedule
Course Dates: Monday, March 20 – Friday, May 12, 2017 (7 weeks)
Class Times: Monday, Wednesday, Friday 1–3pm (21 class sessions)
Class 1: Monday, March 20 – Number Bases
Class 2: Wednesday, March 22 – Recursion & Search Algorithms
Class 3: Friday, March 24 – String Algorithms
Class 4: Monday, March 27 – List, Array & Linked List
Class 5: Wednesday, March 29 – List, Stack & Queue
Class 6: Friday, March 31 – Map & Hash Table
Class 7: Monday, April 3 – Set & Circular Buffer
Class 8: Wednesday, April 5 – Trees
Class 9: Friday, April 7 – Tree Traversals
Class 10: Monday, April 10 – Iterative Sorting Algorithms
Class 11: Wednesday, April 12 – Integer Sorting Algorithms
Class 12: Friday, April 14 – Divide-and-Conquer Recursion
Class 13: Monday, April 17 – Recursive Algorithm Analysis
Class 14: Wednesday, April 19 – Priority Queue & Heap
Class 15: Friday, April 21 – Sorting Algorithms Recap
Class 16: Monday, May 1 – Graphs
Class 17: Wednesday, May 3 – Graph Traversals & Components
Class 18: Friday, May 5 – Graph Spanning Trees & Shortest Paths
Class 19: Monday, May 8 – Rotating Binary Search Trees
Class 20: Wednesday, May 10 – Trie & Multiple Key Trees
Class 21: Friday, May 12 – Memoization & Dynamic Programming
Working with this GitHub repository
This repository (located at https://github.com/MakeSchool-18/Data-Structures) is the course's origin repository which will contain course materials including links, slides, and challenges.
Note that you cannot commit or push to the origin repository.
However, you can fork it to maintain your own version of it and push your code there. Here's an overview of what your repository setup should look like:
Repository Overview
Follow these steps to set up your own course repository:
  1. Clone this repository on your computer:
git clone git@github.com:MakeSchool-18/Data-Structures.git
  2. Fork this repository on GitHub to create your own version of this repo on your GitHub account, which should also be named Data-Structures
  3. Add your GitHub repository as a remote to the local one on your computer (note: you need to give a name to the remote, e.g. your first name):
git remote add <first-name> git@github.com:<github-user>/Data-Structures.git
  4. Link the local repo to your remote GitHub repo:
git push -u <first-name> master
  5. When you want to access new course materials, just pull from the origin remote repo:
git pull origin master
  6. When you've completed a challenge and want to share it for code review, commit your work and push it to your own remote repo with:
git push
About
Product College course on Advanced Data Structures & Algorithms with Python
make.sc/data-structures-plan-q4
Resources
Readme
Activity
Custom properties
Stars
7 stars
Watchers
2 watching
Forks
22 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - MakeSchool-18/Data-Structures: Product College course on Advanced Data Structures & Algorithms with Python · GitHub
Skip to content
BranchesTags
Repository files navigation
Advanced Data Structures & Algorithms with Python
Course Schedule
Course Dates: Monday, March 20 – Friday, May 12, 2017 (7 weeks)
Class Times: Monday, Wednesday, Friday 1–3pm (21 class sessions)
Class 1: Monday, March 20 – Number Bases
Class 2: Wednesday, March 22 – Recursion & Search Algorithms
Class 3: Friday, March 24 – String Algorithms
Class 4: Monday, March 27 – List, Array & Linked List
Class 5: Wednesday, March 29 – List, Stack & Queue
Class 6: Friday, March 31 – Map & Hash Table
Class 7: Monday, April 3 – Set & Circular Buffer
Class 8: Wednesday, April 5 – Trees
Class 9: Friday, April 7 – Tree Traversals
Class 10: Monday, April 10 – Iterative Sorting Algorithms
Class 11: Wednesday, April 12 – Integer Sorting Algorithms
Class 12: Friday, April 14 – Divide-and-Conquer Recursion
Class 13: Monday, April 17 – Recursive Algorithm Analysis
Class 14: Wednesday, April 19 – Priority Queue & Heap
Class 15: Friday, April 21 – Sorting Algorithms Recap
Class 16: Monday, May 1 – Graphs
Class 17: Wednesday, May 3 – Graph Traversals & Components
Class 18: Friday, May 5 – Graph Spanning Trees & Shortest Paths
Class 19: Monday, May 8 – Rotating Binary Search Trees
Class 20: Wednesday, May 10 – Trie & Multiple Key Trees
Class 21: Friday, May 12 – Memoization & Dynamic Programming
Working with this GitHub repository
This repository (located at https://github.com/MakeSchool-18/Data-Structures) is the course's origin repository which will contain course materials including links, slides, and challenges.
Note that you cannot commit or push to the origin repository.
However, you can fork it to maintain your own version of it and push your code there. Here's an overview of what your repository setup should look like:
Repository Overview
Follow these steps to set up your own course repository:
  1. Clone this repository on your computer:
git clone git@github.com:MakeSchool-18/Data-Structures.git
  2. Fork this repository on GitHub to create your own version of this repo on your GitHub account, which should also be named Data-Structures
  3. Add your GitHub repository as a remote to the local one on your computer (note: you need to give a name to the remote, e.g. your first name):
git remote add <first-name> git@github.com:<github-user>/Data-Structures.git
  4. Link the local repo to your remote GitHub repo:
git push -u <first-name> master
  5. When you want to access new course materials, just pull from the origin remote repo:
git pull origin master
  6. When you've completed a challenge and want to share it for code review, commit your work and push it to your own remote repo with:
git push
About
Product College course on Advanced Data Structures & Algorithms with Python
make.sc/data-structures-plan-q4
Resources
Readme
Activity
Custom properties
Stars
7 stars
Watchers
2 watching
Forks
22 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - MakeSchool-18/Data-Structures: Product College course on Advanced Data Structures & Algorithms with Python · GitHub
Skip to content
BranchesTags
Repository files navigation
Advanced Data Structures & Algorithms with Python
Course Schedule
Course Dates: Monday, March 20 – Friday, May 12, 2017 (7 weeks)
Class Times: Monday, Wednesday, Friday 1–3pm (21 class sessions)
Class 1: Monday, March 20 – Number Bases
Class 2: Wednesday, March 22 – Recursion & Search Algorithms
Class 3: Friday, March 24 – String Algorithms
Class 4: Monday, March 27 – List, Array & Linked List
Class 5: Wednesday, March 29 – List, Stack & Queue
Class 6: Friday, March 31 – Map & Hash Table
Class 7: Monday, April 3 – Set & Circular Buffer
Class 8: Wednesday, April 5 – Trees
Class 9: Friday, April 7 – Tree Traversals
Class 10: Monday, April 10 – Iterative Sorting Algorithms
Class 11: Wednesday, April 12 – Integer Sorting Algorithms
Class 12: Friday, April 14 – Divide-and-Conquer Recursion
Class 13: Monday, April 17 – Recursive Algorithm Analysis
Class 14: Wednesday, April 19 – Priority Queue & Heap
Class 15: Friday, April 21 – Sorting Algorithms Recap
Class 16: Monday, May 1 – Graphs
Class 17: Wednesday, May 3 – Graph Traversals & Components
Class 18: Friday, May 5 – Graph Spanning Trees & Shortest Paths
Class 19: Monday, May 8 – Rotating Binary Search Trees
Class 20: Wednesday, May 10 – Trie & Multiple Key Trees
Class 21: Friday, May 12 – Memoization & Dynamic Programming
Working with this GitHub repository
This repository (located at https://github.com/MakeSchool-18/Data-Structures) is the course's origin repository which will contain course materials including links, slides, and challenges.
Note that you cannot commit or push to the origin repository.
However, you can fork it to maintain your own version of it and push your code there. Here's an overview of what your repository setup should look like:
Repository Overview
Follow these steps to set up your own course repository:
  1. Clone this repository on your computer:
git clone git@github.com:MakeSchool-18/Data-Structures.git
  2. Fork this repository on GitHub to create your own version of this repo on your GitHub account, which should also be named Data-Structures
  3. Add your GitHub repository as a remote to the local one on your computer (note: you need to give a name to the remote, e.g. your first name):
git remote add <first-name> git@github.com:<github-user>/Data-Structures.git
  4. Link the local repo to your remote GitHub repo:
git push -u <first-name> master
  5. When you want to access new course materials, just pull from the origin remote repo:
git pull origin master
  6. When you've completed a challenge and want to share it for code review, commit your work and push it to your own remote repo with:
git push
About
Product College course on Advanced Data Structures & Algorithms with Python
make.sc/data-structures-plan-q4
Resources
Readme
Activity
Custom properties
Stars
7 stars
Watchers
2 watching
Forks
22 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - MakeSchool-18/Data-Structures: Product College course on Advanced Data Structures & Algorithms with Python · GitHub
Skip to content
BranchesTags
Repository files navigation
Advanced Data Structures & Algorithms with Python
Course Schedule
Course Dates: Monday, March 20 – Friday, May 12, 2017 (7 weeks)
Class Times: Monday, Wednesday, Friday 1–3pm (21 class sessions)
Class 1: Monday, March 20 – Number Bases
Class 2: Wednesday, March 22 – Recursion & Search Algorithms
Class 3: Friday, March 24 – String Algorithms
Class 4: Monday, March 27 – List, Array & Linked List
Class 5: Wednesday, March 29 – List, Stack & Queue
Class 6: Friday, March 31 – Map & Hash Table
Class 7: Monday, April 3 – Set & Circular Buffer
Class 8: Wednesday, April 5 – Trees
Class 9: Friday, April 7 – Tree Traversals
Class 10: Monday, April 10 – Iterative Sorting Algorithms
Class 11: Wednesday, April 12 – Integer Sorting Algorithms
Class 12: Friday, April 14 – Divide-and-Conquer Recursion
Class 13: Monday, April 17 – Recursive Algorithm Analysis
Class 14: Wednesday, April 19 – Priority Queue & Heap
Class 15: Friday, April 21 – Sorting Algorithms Recap
Class 16: Monday, May 1 – Graphs
Class 17: Wednesday, May 3 – Graph Traversals & Components
Class 18: Friday, May 5 – Graph Spanning Trees & Shortest Paths
Class 19: Monday, May 8 – Rotating Binary Search Trees
Class 20: Wednesday, May 10 – Trie & Multiple Key Trees
Class 21: Friday, May 12 – Memoization & Dynamic Programming
Working with this GitHub repository
This repository (located at https://github.com/MakeSchool-18/Data-Structures) is the course's origin repository which will contain course materials including links, slides, and challenges.
Note that you cannot commit or push to the origin repository.
However, you can fork it to maintain your own version of it and push your code there. Here's an overview of what your repository setup should look like:
Repository Overview
Follow these steps to set up your own course repository:
  1. Clone this repository on your computer:
git clone git@github.com:MakeSchool-18/Data-Structures.git
  2. Fork this repository on GitHub to create your own version of this repo on your GitHub account, which should also be named Data-Structures
  3. Add your GitHub repository as a remote to the local one on your computer (note: you need to give a name to the remote, e.g. your first name):
git remote add <first-name> git@github.com:<github-user>/Data-Structures.git
  4. Link the local repo to your remote GitHub repo:
git push -u <first-name> master
  5. When you want to access new course materials, just pull from the origin remote repo:
git pull origin master
  6. When you've completed a challenge and want to share it for code review, commit your work and push it to your own remote repo with:
git push
About
Product College course on Advanced Data Structures & Algorithms with Python
make.sc/data-structures-plan-q4
Resources
Readme
Activity
Custom properties
Stars
7 stars
Watchers
2 watching
Forks
22 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - MakeSchool-18/Data-Structures: Product College course on Advanced Data Structures & Algorithms with Python · GitHub
Skip to content
BranchesTags
Repository files navigation
Advanced Data Structures & Algorithms with Python
Course Schedule
Course Dates: Monday, March 20 – Friday, May 12, 2017 (7 weeks)
Class Times: Monday, Wednesday, Friday 1–3pm (21 class sessions)
Class 1: Monday, March 20 – Number Bases
Class 2: Wednesday, March 22 – Recursion & Search Algorithms
Class 3: Friday, March 24 – String Algorithms
Class 4: Monday, March 27 – List, Array & Linked List
Class 5: Wednesday, March 29 – List, Stack & Queue
Class 6: Friday, March 31 – Map & Hash Table
Class 7: Monday, April 3 – Set & Circular Buffer
Class 8: Wednesday, April 5 – Trees
Class 9: Friday, April 7 – Tree Traversals
Class 10: Monday, April 10 – Iterative Sorting Algorithms
Class 11: Wednesday, April 12 – Integer Sorting Algorithms
Class 12: Friday, April 14 – Divide-and-Conquer Recursion
Class 13: Monday, April 17 – Recursive Algorithm Analysis
Class 14: Wednesday, April 19 – Priority Queue & Heap
Class 15: Friday, April 21 – Sorting Algorithms Recap
Class 16: Monday, May 1 – Graphs
Class 17: Wednesday, May 3 – Graph Traversals & Components
Class 18: Friday, May 5 – Graph Spanning Trees & Shortest Paths
Class 19: Monday, May 8 – Rotating Binary Search Trees
Class 20: Wednesday, May 10 – Trie & Multiple Key Trees
Class 21: Friday, May 12 – Memoization & Dynamic Programming
Working with this GitHub repository
This repository (located at https://github.com/MakeSchool-18/Data-Structures) is the course's origin repository which will contain course materials including links, slides, and challenges.
Note that you cannot commit or push to the origin repository.
However, you can fork it to maintain your own version of it and push your code there. Here's an overview of what your repository setup should look like:
Repository Overview
Follow these steps to set up your own course repository:
  1. Clone this repository on your computer:
git clone git@github.com:MakeSchool-18/Data-Structures.git
  2. Fork this repository on GitHub to create your own version of this repo on your GitHub account, which should also be named Data-Structures
  3. Add your GitHub repository as a remote to the local one on your computer (note: you need to give a name to the remote, e.g. your first name):
git remote add <first-name> git@github.com:<github-user>/Data-Structures.git
  4. Link the local repo to your remote GitHub repo:
git push -u <first-name> master
  5. When you want to access new course materials, just pull from the origin remote repo:
git pull origin master
  6. When you've completed a challenge and want to share it for code review, commit your work and push it to your own remote repo with:
git push
About
Product College course on Advanced Data Structures & Algorithms with Python
make.sc/data-structures-plan-q4
Resources
Readme
Activity
Custom properties
Stars
7 stars
Watchers
2 watching
Forks
22 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - MakeSchool-18/Data-Structures: Product College course on Advanced Data Structures & Algorithms with Python · GitHub
Skip to content
BranchesTags
Repository files navigation
Advanced Data Structures & Algorithms with Python
Course Schedule
Course Dates: Monday, March 20 – Friday, May 12, 2017 (7 weeks)
Class Times: Monday, Wednesday, Friday 1–3pm (21 class sessions)
Class 1: Monday, March 20 – Number Bases
Class 2: Wednesday, March 22 – Recursion & Search Algorithms
Class 3: Friday, March 24 – String Algorithms
Class 4: Monday, March 27 – List, Array & Linked List
Class 5: Wednesday, March 29 – List, Stack & Queue
Class 6: Friday, March 31 – Map & Hash Table
Class 7: Monday, April 3 – Set & Circular Buffer
Class 8: Wednesday, April 5 – Trees
Class 9: Friday, April 7 – Tree Traversals
Class 10: Monday, April 10 – Iterative Sorting Algorithms
Class 11: Wednesday, April 12 – Integer Sorting Algorithms
Class 12: Friday, April 14 – Divide-and-Conquer Recursion
Class 13: Monday, April 17 – Recursive Algorithm Analysis
Class 14: Wednesday, April 19 – Priority Queue & Heap
Class 15: Friday, April 21 – Sorting Algorithms Recap
Class 16: Monday, May 1 – Graphs
Class 17: Wednesday, May 3 – Graph Traversals & Components
Class 18: Friday, May 5 – Graph Spanning Trees & Shortest Paths
Class 19: Monday, May 8 – Rotating Binary Search Trees
Class 20: Wednesday, May 10 – Trie & Multiple Key Trees
Class 21: Friday, May 12 – Memoization & Dynamic Programming
Working with this GitHub repository
This repository (located at https://github.com/MakeSchool-18/Data-Structures) is the course's origin repository which will contain course materials including links, slides, and challenges.
Note that you cannot commit or push to the origin repository.
However, you can fork it to maintain your own version of it and push your code there. Here's an overview of what your repository setup should look like:
Repository Overview
Follow these steps to set up your own course repository:
  1. Clone this repository on your computer:
git clone git@github.com:MakeSchool-18/Data-Structures.git
  2. Fork this repository on GitHub to create your own version of this repo on your GitHub account, which should also be named Data-Structures
  3. Add your GitHub repository as a remote to the local one on your computer (note: you need to give a name to the remote, e.g. your first name):
git remote add <first-name> git@github.com:<github-user>/Data-Structures.git
  4. Link the local repo to your remote GitHub repo:
git push -u <first-name> master
  5. When you want to access new course materials, just pull from the origin remote repo:
git pull origin master
  6. When you've completed a challenge and want to share it for code review, commit your work and push it to your own remote repo with:
git push
About
Product College course on Advanced Data Structures & Algorithms with Python
make.sc/data-structures-plan-q4
Resources
Readme
Activity
Custom properties
Stars
7 stars
Watchers
2 watching
Forks
22 forks
Report repository
Releases
Packages
Contributors
Languages