kdn251/interviews

Features

• Algorithms and Data Structures - Learning the fundamental building blocks of software engineering to improve problem-solving skills and write more efficient code.
• Coding Challenge Platforms - Solving algorithmic puzzles and data structure problems to improve speed and accuracy for competitive programming or technical assessments.
• Computer Science Study Guides - A centralized hub providing links to educational resources, video lectures, and practice platforms for mastering core technical concepts.
• Interview Preparation Resources - A curated collection of computer science fundamentals, algorithm implementations, and study materials designed for software engineering interview preparation.
• Technical Interview Preparation - Studying core computer science concepts and practicing coding problems to succeed in technical job interviews at technology companies.
• Algorithms - ### Sorting #### Quicksort * Stable: `No` * Time Complexity: * Best Case: `O(nlog(n))` * Worst Case: `O(n^2)` * Average Case: `O(nlog(n))` #### Mergesort * *Mergesort* is also a divide and conquer algorithm. It continuou
• Data Structure Guides - A structured guide covering the implementation and theoretical properties of essential data structures used in software development and problem solving.
• Video Lectures - * Data Structures * UC Berkeley Data Structures * MIT Advanced Data Structures * Algorithms * MIT Introduction to Algorithms * MIT Advanced Algorithms * UC Berkeley Algorithms
• Algorithm Reference Libraries - A comprehensive repository of common sorting, searching, and graph algorithms with detailed explanations of their time and space complexities.
• Software Engineering Fundamentals - Reviewing essential computer science theory and runtime analysis to build a strong foundation for professional software development.
• Big O Notations - * *Big O Notation* is used to describe the upper bound of a particular algorithm. Big O is used to describe worst case scenarios
• Asymptotic Notations - #### Big O Notation * *Big O Notation* is used to describe the upper bound of a particular algorithm. Big O is used to describe worst case scenarios #### Little O Notation * *Little O Notation* is also used to describe a
• Graph Algorithms - * *Kruskal's Algorithm* is also a greedy algorithm that finds a minimum spanning tree in a graph. However, in Kruskal's, the graph does not have to be connected * Time Complexity: `O(|E|log|V|)`
• Graph Traversal Algorithms - * *Depth First Search* is a graph traversal algorithm which explores as far as possible along each branch before backtracking * Time Complexity: `O(|V| + |E|)`
• Greedy Algorithms - * *Greedy Algorithms* are algorithms that make locally optimal choices at each step in the hope of eventually reaching the globally optimal solution * Problems must exhibit two properties in order to implement a Greedy s
• Bit Manipulation Techniques - * Bitmasking is a technique used to perform operations at the bit level. Leveraging bitmasks often leads to faster runtime complexity and helps limit memory usage * Test kth bit: `s & (1 << k);` * Set kth bit: `s |= (1 <
• Minimum Spanning Tree Algorithms - * *Prim's Algorithm* is a greedy algorithm that finds a minimum spanning tree for a weighted undirected graph. In other words, Prim's find a subset of edges that forms a tree that includes every node in the graph * Time
• Heaps - * A *Heap* is a specialized tree based structure data structure that satisfies the *heap* property: if A is a parent node of B, then the key (the value) of node A is ordered with respect to the key of node B with the sam
• Linear Data Structures - ### Linked List * A *Linked List* is a linear collection of data elements, called nodes, each pointing to the next node by means of a pointer. It is a data structure consisting of a group of nodes which together represen
• Linked Lists - * A *Linked List* is a linear collection of data elements, called nodes, each pointing to the next node by means of a pointer. It is a data structure consisting of a group of nodes which together represent a sequence. *
• Queues - * A *Queue* is a collection of elements, supporting two principle operations: *enqueue*, which inserts an element into the queue, and *dequeue*, which removes an element from the queue * **First in, first out data struct
• Trees - * A *Tree* is an undirected, connected, acyclic graph
• Binary Search Trees - * A binary search tree, sometimes called BST, is a type of binary tree which maintains the property that the value in each node must be greater than or equal to any value stored in the left sub-tree, and less than or equ
• Fenwick Trees - * A Fenwick tree, sometimes called a binary indexed tree, is a tree in concept, but in practice is implemented as an implicit data structure using an array. Given an index in the array representing a vertex, the index of
• Segment Trees - * A Segment tree, is a tree data structure for storing intervals, or segments. It allows querying which of the stored segments contain a given point * Time Complexity: * Range Query: `O(log(n))` * Update: `O(log(n))`
• Stacks - * A *Stack* is a collection of elements, with two principle operations: *push*, which adds to the collection, and *pop*, which removes the most recently added element * **Last in, first out data structure (LIFO)**: the m
• Online Judges - * LeetCode * Virtual Judge * CareerCup * HackerRank * CodeFights * Kattis * HackerEarth * Codility * Code Forces * Code Chef * Sphere Online Judge - SPOJ * InterviewBit
• Binary Trees - * A *Binary Tree* is a tree data structure in which each node has at most two children, which are referred to as the *left child* and *right child* * **Full Tree**: a tree in which every node has either 0 or 2 children *
• Taxonomy Frameworks - Categorizes complex computer science concepts into a hierarchical structure to facilitate structured learning and quick reference.
• Live Coding Platforms - * The Daily Byte * Pramp * Gainlo * Refdash * Interviewing.io
• Asymptotic Complexity Models - Uses mathematical notation to define the performance bounds of algorithms, enabling objective comparison of computational efficiency.