Kolade Chris
Data structures and algorithms (DSA) are an important aspect of any programming language. Every language has its own data structures and its way of handling different types of algorithms.
So, as a programmer, no matter what programming language you are working with, data structures and algorithms have to be an important aspect of your day-to-day programming. That’s because we always need them to solve complex problems.
And that’s why I put together this article – to show you what data structures and algorithms are, and to share some resources with you to help you learn them in various languages.
Data structures and algorithms go hand in hand. You may have a set of data arranged in a certain structure which you then pass into an algorithm to execute in a certain way.
But data structures and algorithms are not the same things. So let’s look at them separately.
A data structure is a particular way data is arranged so it can be saved in memory and retrieved for later use.
If you want to read an in-depth guide to data structures in JavaScript, check out this tutorial.
Data can be anything that can be saved. It could be primitive types like string, boolean, integer, or float. Or non-primitive types like arrays, linked list trees, stacks, and queues.
Below is an example of a linked list, stack, and queue in Python:
Here's the code for a linked list:
# Linked list class Node: def __init__(self, data): self.data = data self.next = None class My_linkedlist: def __init__(self): self.head = None def append(self, data): new_node = Node(data) if self.head is None: self.head = new_node return last_node = self.head while last_node.next: last_node = last_node.next last_node.next = new_node def print_list(self): current_node = self.head while current_node: print(current_node.data) current_node = current_node.next linked_list = My_linkedlist() linked_list.append("List weekdays from the start:") linked_list.append("Monday") linked_list.append("Tuesday") linked_list.append("Wednesday") linked_list.append("Thursday") linked_list.append("Friday") linked_list.print_list() """ Output: Weekdays: Monday Tuesday Wednesday Thursday Friday """ print() print() Here's the code for a stack:
# Stack class My_stack: def __init__(self): self.stack = [] def push(self, data): self.stack.append(data) def pop(self): return self.stack.pop() def is_empty(self): return len(self.stack) == 0 def peek(self): return self.stack[-1] stack = My_stack() stack.push("Monday") stack.push("Tuesday") stack.push("Wednesday") stack.push("Thursday") stack.push("Friday") stack.push("Pop Weekdays from the last:") print(stack.pop()) print(stack.pop()) print(stack.pop()) print(stack.pop()) print(stack.pop()) print(stack.pop()) """ Output: Pop Weekdays from the last: Friday Thursday Wednesday Tuesday Monday """ print() print() Here's a video about how to use the stack data structure to solve coding challenges.
And here's the code for a queue:
# Queue from collections import deque class My_queue: def __init__(self): self.queue = deque() def enqueue(self, data): self.queue.append(data) def dequeue(self): return self.queue.popleft() def is_empty(self): return len(self.queue) == 0 def peek(self): return self.queue[0] queue = My_queue() queue.enqueue("Queue weekdays:") queue.enqueue("Monday") queue.enqueue("Tuesday") queue.enqueue("Wednesday") queue.enqueue("Thursday") queue.enqueue("Friday") print(queue.dequeue()) print(queue.dequeue()) print(queue.dequeue()) print(queue.dequeue()) print(queue.dequeue()) print(queue.dequeue()) """ Output: Queue weekdays: Monday Tuesday Wednesday Thursday Friday """ And here's an article about the queue data structure in Java if you want to read more.
The examples above are the common ones you can find in almost all available programming languages. Each programming language has its own way of implementing those data structures.
In the same vein, each programming language has its own data structures exclusive to it. For example, Python has unique data types like tuples, lists, and dictionaries:
Here's how you write a tuple in Python:
# tuple in python person_tuple = ("John Smith", 26, "Python Engineer") Here's an example of a list:
# list in python fruits_list = ["apple", "orange", "Cashew", "Mango"] Here's an article that compares tuples and lists in Python to help you understand how they work and what their main differences are.
And here's a dictionary:
# dictionary in python person = "name": "John Doe", "age": 28, "occupation": "Software Developer"> Here's a guide to dictionaries in Python - what they are and how to work with them.
And in JavaScript, we have sets, objects, and its own way of implementing arrays:
// Set in JavaScript const uniqueFruits = new Set(["Mango", "Cashew", "Strawberry", "Coconut", "Mango"]); // Array in JavaScript const sportsArray = ["Football", "Tennis", "Athletics", "Badminton"]; // Object in JavaScript const player = < name: "Enzo Fernandez", age: 22, sport: "Footballer", club: "Chelsea", country: "Argentina" >; These are all examples of data structures that we can use to work with our data.
If you want to learn Data Structures from a Google engineer, here's a course you might enjoy.
Now let's look at algorithms.
In programming, an algorithm is a set of steps for solving a known problem. The problems solved by an algorithm could be sorting a set of data, searching through available data, or even encrypting data.
There are a number of types of algorithms available today. There’s no particular way the types are characterized, but there are broad categories like sorting and searching algorithms.
Examples of sorting algorithms are merge sort, bubble sort, selection sort, and others. And examples of searching algorithms are exponential search, binary search, jump search, and others.
There are other types of algorithms like hashing, greeting algorithms, brute force algorithms, and more.
Here’s an example of a bubble sort algorithm in Python:
# Bubble sort in Python def bubble_sort(arr): n = len(arr) for i in range(n): for j in range(0, n-i-1): if arr[j] < arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] return arr arr = [10, 8, 9, 5, 7, 6, 3, 2, 1, 4] print("Array in descending order:", bubble_sort(arr)) # Array in descending order: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] Here's an article with more examples if you want to read further.
And here’s an example of binary search algorithm in Python:
def binary_search_demo(arr, x): low = 0 high = len(arr) - 1 mid = 0 while low 2 if arr[mid] < x: low = mid + 1 elif arr[mid] > x: high = mid - 1 else: return mid return -1 arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] x = 9 result = binary_search_demo(arr, x) if result != -1: print("Element is present at index", result) else: print("Element is not present in the array") # Output: Element is present at index 8 Here's an in-depth tutorial about Binary Search in Python if you want to learn more.
You can write algorithms with any programming language out there. Each programming language has its way of implementing a particular algorithm.
At the end of the day, no matter which language you use, an algorithm is still an algorithm. For instance, you can implement a bubble sort algorithm or any other type of algorithm with any programming language.
But in some instances, choosing a language to write an algorithm depends on the exact programming language you’re using in your project.
If you’re developing a web solution and you’re already using PHP or Node JS, then you might have to write the algorithm you need in PHP or JavaScript.
The first step towards learning algorithms starts when you begin to learn a programming language.
At this point, the fundamentals are very important because there’s no way you can understand complex coding concepts without them.
If you’re learning web development, for example, you need to understand HTML, CSS, and the basics of JavaScript very well.
The next thing to do is to step beyond the basics and understand data structures very well. That’s because, on many occasions, you’ll be passing various data into an algorithm as the input.
You can then pick up the theoretical aspects of the algorithm. Those include what an algorithm is and the different types of algorithms.
After you understand the theory, the next thing is practicals. Learn how to implement various algorithms, then continue to practice until you understand them.
Here are several online video and text-based resources for learning algorithms:
If you’re just starting out with JavaScript, the freeCodeCamp’s JavaScript Algorithms and Data Structures Certification curriculum would make a great start.
Here are some videos from the freeCodeCamp YouTube channel that can help you learn algorithms:
This article took you through:
If you want to learn algorithms, you should look at the resources provided in this article. They are a good place to start learning algorithms in the languages they are available in.
