Introduction to Data Structures and Algorithms in Python.
Tags: python
Published: 2022-02-21 19:39:09

**_Introduction_**
Data structures are simply the different ways of organizing and storing data in our computers so as to perform operations on the data.



## Bult-in Data Structures

Data structures allow us to organize, store, and manage data for efficient access and modification.

**List**
A list is defined using square brackets and holds data that is separated by commas. It is a type of data used to represent/ store a list of objects in a single variable . It can contain a mix of different data types. We use print()function to print the output on the terminal.
Lists are indexed from 0
Example of a list in Python is as shown below.

```
mylist=["Faith",32,"Kenya"]
print (mylist)
```
Output:

```
[‘Faith’,32,’Kenya’]
```

The append() method adds an item to the end of the list.

```
mylist.append(3)
print(mylist)

```
The insert() method adds an item at a specific place in the list

```
mylist.insert(0, 38)
```

The pop() method removes last element from list

```
numbers.pop()
print(mylist)
```

To access an element on the list

```
print(numbers[0])
```

To check index of an item

```
fruits = ['apple', 'banana', 'orange', 'grape']

index = fruits.index('banana')

print(index)
```


**Tuple**
A tuple is an ordered collection of items. It is a data type for immutable ordered sequences of elements I.e
you can’t add and remove elements from tuples, or sort them in place
A tuple is used to store a sequence of objects.
Tuples are indexed from 0.
We can create tuples using the method below:

```
positions = (4,9,18)
print(positions)
```

To access tuples using their index we use the method shown below:
`print(positions [2])`

To create a list of tuples we use the method shown below:
`positions = [(4,9,18), (30,15, 19)]`

**Set**

Set is a mutable and unordered collection of unique elements. It can permit us to remove duplicate quickly from a list.
A set is mutable, it can be changed or modified once created.

Removing duplicates from a list

```
numbers = [9, 16, 3, 4, 9, 3]
unique_numbers = set(numbers)
print(unique_numbers)

```
Union of sets

```
first_set = {3, 4}
second_set = {5, 6}
print(first | second)

```
Intersection of sets
`print(first_set & second_set)
`
Difference between two sets
`print(first_set - second_set)
`
Symmetric difference
`print(first_set ^ second_set)`

Iterating over elements in a set

```
numbers = {3, 7}
for x in numbers:
    print(x)
```
output

```
3
7
```
**Dictionary**

Dictionary is a mutable and unordered data structure. It permits storing a pair of items (i.e. keys and values).
We can use strings, numbers or tuples as keys.
The value can be any data type.
We can assign one value to multiple keys.
We can create dictionaries using dict() method.

Creating a dictionary 

```
user = {"name": "Faith", "age":32, "hobbies": ["cooking", "singing"]}
print(user)
```

Accessing a specific key

```
print(user["name"])
```

Specifying a default value for keys that do not exist
`print(user.get("email", "Invalid key"))`

Adding a key to the dictionary

```
user["email"] = "lobbystar@gmail.com"
print(user.get("email"))

```
Changing value of a key 

```
user[name] = "Liam"
print(user)

```
To modify several or all values

```
user.update({"name": "David", "age": 21, "email": "kingdavid@gmail.com"})

```
To delete a key

```
del user["hobbies"]
print(user)

```
Looping through keys and values

```
for key, value in user.items():
    print(key, value)
```

## User-defined data structures

These are data structures that are not supported by Python, but can be programmed by the user to function similarly to Python built-in data structures.
We will look at stacks, queues and linked lists.

**Stack**

A stack is a linear data structure that follows the LIFO(Last In First Out) principle.. So, the last element inserted will be removed as the first. The operations are:
    • Push → inserting an element into the stack
    • Pop → deleting an element from the stack
The conditions to check:
    • overflow condition → this condition occurs when we try to put one more element into a stack that is already having maximum elements.
    • underflow condition →this condition occurs when we try to delete an element from an empty stack.

Stacks in Python can be implemented using lists, Collections.deque, queue.LifoQueue

Functions we can perform on stacks

append/ push() -to add an item on top of the stack.
pop() -to remove an item on top of the stack.
peek/ top() - to view the top element of the stack.
size()-returns the size of the stack.
[-1] -to get the item that is on top of the stack. It only works if our stack is not empty.
empty()-to return whether the stack is empty.

**Queue**

A queue is a linear data structure that follows FIFO(First In First Out) principle.
Insertion and deletion in queues happens on the rear-end and front-end.
In Python, queues can be implemented using lists, collection.deque, queue.Queue
Two ends:
    • front → points to starting element
    • rear → points to the last element
There are two operations:
    • enqueue → inserting an element into the queue. It will be done at the rear.
    • dequeue → deleting an element from the queue. It will be done at the front.
There are two conditions:
    • overflow → insertion into a queue that is full
    • underflow → deletion from the empty queue

**Linked list**

A linked list is a data structure for storing a collection of items.
A linked list can be visualized as several boxes connected to each other.
The data used in linked lists can be strings, numbers, characters, etc.
Linked lists can be used to implement stacks, queues and graphs.

 

## Algorithms

Algorithms are instructions that are formulated in a finite and sequential order to solve problems.
When we write an algorithm, we have to know what is the exact problem, determine where we need to start and stop and formulate the intermediate steps.
Algorithms are also the operations that we can perform on different data structures and the set of instructions for executing them.


To learn more about algorithms click [here](https://www.tutorialspoint.com/python_data_structure/python_algorithm_design.htm#:~:text=Algorithm%20is%20a%20step%2Dby,more%20than%20one%20programming%20language.)

You can also read this [article](https://www.geeksforgeeks.org/data-structures/) to learn more about data structures.