Discover data structures and algorithms using Python. Gain insights into solving real-world problems and typical interview questions with detailed reviews, explanations, and hands-on coding exercises.

Data structures and algorithms are among the most fundamental concepts of Computer Science. Whether it’s real-world problems you’re trying to solve or the typical coding question asked in an interview, almost every problem requires you to demonstrate a deep understanding of data structures and algorithms. 

This course is a detailed review of some of the most common data structures and algorithms that you’ll see in interviews and your everyday work. With implementation details, thorough explanations, and hands-on coding exercises, you’ll quickly gain the confidence you need to solve any problem, no matter the situation.

Data Structures and Algorithms in Python

In this lesson, we investigate how to count the occurrence of nodes with a specified data element. We will consider how one may solve this problem in both an iterative and recursive manner, and we will code the solution to both of these approaches in Python.

As an example, have a look at the illustration below where we have a linked list with the following elements:

```
1 - 1 - 2 - 1
```
You can see that the number of occurrences of `1` in the linked list is `3`. 

# Iterative Implementation

Our approach to iteratively solving this problem is straightforward. We'll traverse the linked list and count the occurrences as we go along. Let's go ahead and code it in Python!

def count_occurences_iterative(self, data):
  count = 0
  cur = self.head
  while cur:
      if cur.data == data:
          count += 1
      cur = cur.next
  return count 

## Explanation
`count_occurences_iterative` takes in `data` as one of the input parameters. On **line 2** and **line 3**, `count` and `cur` are initialized to `0` and `self.head` respectively. `count` will keep count of the number of occurrences of `data` while `cur` is used for the linked list traversal. The `while` loop on **line 4** runs until `cur` becomes equal to `None`. `cur` is updated to `cur.next` in each iteration (**line 7**).  

On **line 5**, there is a simple check to see if `cur.data` is equal to `data`. If the data of the current node is equal to `data` that we are looking for, `count` is incremented by `1`. This is how the number of occurrences will be counted. 

On **line 8**, `count` after being updated in the `while` loop, is returned from the method. 

Hope the iterative implementation is clear. 


# Recursive Implementation
Let's turn to the recursive implementation now. 

In this lesson, we will learn how to count occurrences​ of a data element in a linked list. 

Introduction

Stack

Singly Linked Lists

Circular Linked Lists

Doubly Linked Lists

Arrays

Binary Trees

Binary Search Trees

Binary Search

Recursion

String Processing

Count Occurrences

Iterative Implementation #