INTRODUCTION TO ALGORITHMS AND DATA STRUCTURES
Published: 2022-02-21 20:17:17

## Algorithms
An algorithm is a set of instructions used to solve mathematical problems or steps used to accomplish a task in a computer program.
When working with algorithms, it is important to identify the resources used, such as the memory, the operations to perform, the amount of data to work on.
## Data structures
These are methods of organizing and storing data that perform efficient operations. To measure the efficiency of an algorithm, the **Big O-Notation** is used. 
#### Big -O-Notation O(n)
This is a mathematical notation that describes the limiting behaviour of a function when the argument tends towards a particular value or infinity. It is about finding the an asymptotic upper bound. 
It classifies how a function behaves as input grows or gets larger.

Python has 4 built-in data types used to store collections of data.  These data structures are Lists, Tuples Sets, and Dictionaries. These data structures are discussed in this article.
## Lists
Lists in Python are used to store multiple elements.  
A list is made of comma separated characters or values enclosed in square brackets as shown
```python
letters=['a', 'b','c', 'd']
numbers=[1,2,3,4]
```
Elements in a list correspond to an index. The first element in a list corresponds to index 0. For example in numbers, 1 corresponds to index 0 and in letters 'a' correspond to index 0.
```python
letters=['a', 'b','c', 'd']
print(letters[0])
numbers=[1,2,3,4]
print(numbers[0])
```
To determine the length of a list, the `len()` function is used.
### List Functions
**Append**
This function adds an item at the end of a list.
`append(item)`
```python
letters.append('z')
print(letters)
```
**Insert**
This function adds an item at a given index in the list.
`insert(index, item)`
```python
numbers.insert(2, "python")
```
**Count**
This function returns a count of how many times an item occurs in the list.
```python

print(numbers.count(3))
```
**Pop**
This function removes item at a given index)
```python
numbers=[1,2,3,3,3,4,5,6]
print(numbers.pop(5))
```
**Clear**
This function removes all elements in a list.
```python
numbers=[1,2,3,3,3,4,5,6]
print(numbers.clear())
```
## Tuples
Tuples are used to store multiple items in a single variable.
A tuple is a collection of ordered and immutable (unchangeable) elements.
They are written using parentheses.
```python
verterbrates==("mammals", "reptiles", "birds", "fish", "amphibians")
print(verterbrates)
```
To determine the length of a tuple, `len` function is used.
```python
verterbrates==("mammals", "reptiles", "birds", "fish", "amphibians")
print(len(verterbrates))
```

## Dictionaries
Dictionaries are used to store data values in key:value pairs.
A dictionary is a collection of ordered, mutable items that does not allow data duplicates.
```python
profile={name:"Jane", age:12, password:1234}
print(profile["Jane"])
```
## Sets
Sets are collection of unordered items	that are unique. They are created using curly braces. The in keyword makes iu fast to check whether an item is part of a set rather than in a list.
```python
verterbrates={"mammals", "reptiles", "birds", "fish", "amphibians"}
 
if "insects" in verterbrates:
	print(verterbrates)
else:
	print("inverterbrates")
```
Sets can be combined using mathematical operations such as:
**Union:** joins elements of two different sets to form one new set containg elements in either.
**Insertion:** This operator gets elements found in both sets.
**Difference:** Gets items in the first set but not in the second.
**Symmetric difference:** gets items in either sets but not both.
## Queues
This is a data structure that performs First in First Out linear operations. It is usually open at both ends.
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6ui1775mifvuxwrwtye8.jpg)

## Linked List.
These are containers where nodes of data are linked together into a list. It resembles a chain in that data is transferred from beginning to end without skipping a node.
Connecting nodes into a list can extend indefinitely and limit memory.

It is divided into singly and doubly linked lists.
A singly linked list is unidirectional and is only traversed from head to tail. 
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/yse4ptqj865pbcoxkztd.jpg)
A doubly linked list is similar to a singly linked list with reverse iterations.
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4ka1plxucyxgr9xh7ex6.jpg)
To find an item in a linked list, `find` and `contain` functions are used.