Please enable JavaScript.

Coggle requires JavaScript to display documents.

learn algorithm and data structures, why study data structure and…

- - - - topic
        
        Big-O notation and complexity
        
        Stacks
        
        Queues
        
        Trees
        
        Heaps
        
        Graphs and Graph Algorithms
        
        Linked lists
        
        Sorting
        
        Searching
      - for cs and ee grads
      - Master the Coding Interview: Data Structures + Algorithms
  - - - I am offering teaching in the following Areas:
        
        Time complexity
        
        Array
        
        Stack
        
        Queue
        
        Hash Table / Dictionary
        
        Linked List
        
        Tree
        
        Trie
        
        Heaps
        
        Graph
        
        Math
        
        Binary Search
        
        Sorting Algorithms
        
        String
        
        Two Pointers
        
        Tree Traversals
        
        BFS and DFS
        
        Backtracking
        
        Bit Manipulation
        
        Dynamic Programming
        
        Greedy Algorithm
- - - - Identify a list of ~100 core problems. Many sites give you 100 curated problems.
        Here’s another way:
        Get these two books:
        Elements of Programming Interviews
        Cracking the Coding Interview.
        Collectively, they give you a good variety of hand-picked problems. If you want a structured course for this, check out InterviewCamp.io
        
        For example:
        Interviewer: “So you initialized an array-backed list. Good. Now let’s say you reach its capacity, what happens when you try to add another element?”
        Candidate: blank “What do you mean capacity? I can keep adding elements to this list.”
        Interviewer: facepalm
        In this case, the candidate had been using Python, and there’s no concept of list capacity. You just keep adding elements. But that’s not what happens under the hood. You need to know what data structures back a list, and how that works.
        
        Here’s another example:
        Let’s say you’re asked to Implement a Queue using just Stacks (a popular question). This is a modified data structure. If you haven’t implemented either of those before, you’ll have trouble getting started.
        Now, this doesn’t mean you need to know every implementation’s code. Some data structures are pretty hard to implement – for example, deleting a node from a Binary Search Tree is not trivial to code. But you should know how it works.
        
        Here is a list of data structures to master:
        Arrays and Lists
        2D Arrays
        Strings
        Linked List
        Stack
        Queue
        Hash Table & Hash Set
        Heap
        Graphs
        Binary Tree
        Binary Search Tree
        Trie
        
        https://www.hackerearth.com/practice/
        
        spaced repetition
        
        “I solve many questions but can’t solve them a week later! How do I remember solutions?”
        The key is to not remember solutions. The key is to practice them. When you see a problem, you should immediately be able to break it down and re-create the solution. This is different from rote learning. You’re recognizing different components, breaking them down and solving the problem.
        
        3 days
        
        a week
        
        a month
        
        It will become second nature to you.
        
        Step 5: Isolate techniques that are reused. Isolate actual code blocks.
        This is where the Depth-First approach gets exciting. As you solve these problems, you’ll start to notice patterns.
        Let’s say you solved 5 problems that used Binary Search. You can isolate the Binary Search code and practice it over and over. You know it will be used in similar problems.
        And this is one of many techniques you can isolate. Here are some other common ones:
        Depth First Search
        Recursion + Memoization
        Hash Table + Linked List combination
        Searching a Binary Tree etc.
        Now, you have a collection of techniques you can apply to new problems.
        
        Step 6: Now, it’s time for Breadth.
        Let’s say you’ve mastered your core problems. Using common data structures is second nature to you. You can now look beyond your core set. Because you’ve implemented so many techniques already, you don’t even have to code all the new questions.
        During this time, try to solve realistic interview problems. Once you get good, there’s a tendency to focus on really hard problems. The thought process is – “if I can solve these really hard problems, then interview problems will be a piece of cake!”. That’s not usually the case. Techniques in really hard problems often have nothing to do with interview-level problems.
        
        Step 7: Practice on paper
        We recommend practicing on paper at some point in your prep. When you code without an IDE and Stack Overflow, it takes you away from your comfort zone.
        Here are some benefits of practicing on paper:
        You’re forced to plan your code before writing. You can’t just go back and retype.
        You will start learning correct language syntax and data structure usage. With an IDE, code used to write itself.
        You can take a paper and pen anywhere with you to practice.
        And more importantly, it is a realistic simulation of a whiteboard interview.
- - - - define fields in a record or class and the routines or methods.
    - - other programmers can’t tamper with the software.