## DEV Community

Mercy wanyonyi

Posted on • Updated on

# Introduction to Data Structures and Algorithims with Python

Data Structures and Algorithims have always been approached with a skeptical attitude of being very hard. It is probaly the terms that scare most people. I have however learnt that the best way is to take a bottom-up approcah: starting from the basic stuff to the complex ones.

This article will help you understand the basics of data structures and algorithims, their importance and eventually how you can implement them in a real-life situation.

## What are Data Structures?

Simply put, Data Structures are ways in which data is organised in order to easily access, manipulate and share it. They therefore allow effective operations in onces code. At the end of this article, you will realise that using the right data structure improves the effectiveness of your code by far.

#### Prerequisite

In my previous article, we introduces ourselves to some basic data structures that are a necessary prerequisite to this course.

The data structures that we will talk about here are categorised into two groups as shown below:

### Linear Data Structures

These are structures that work on one data then moves to the next hence the 'linear'. Among them we have:

##### Arrays

In python, Arrays are more or less like lists. However, an array is immutable and contains data of the same type unlike a list can contain different types of data. Arrays are very important data structures especiassly when it comes to recursive functions.

The example above is an array of integers with thier indices shown below.
The following are ways ways in which one can manipulate arrays

``````'''an array of integers'''
#int array [10]= {1,2,3,4,5,6,7,8,9,10}
arrayName=[1,2,3,4,5,6,7,8,9,10]

arrayName.append[11]
print (arrayName)
#
[1,2,3,4,5,6,7,8,9,10]

#Removing Items from an Array
#removes 1st item
arrayName.remove

#output
#[2,3,4,5,6,7,8,9,10]

#removing item im arr[3]
arrayName.pop[3]

#output
#[1,2,3,5,6,7,8,9,10]

``````

Lisked lists are data structures that consist of nodes connected with pointers. These nodes are made up of data and memory location of the next node as shown below:

The first node is called the head node. If the linked list is empty then the value of the head node is "None".If the list is long, we will have access to the other node sequentially starting from the head node.There are however other linked lisyed that can be traversedd differentlty. The last node doesn't contain any address value but it has a data value(×=0).

Linked lists can be categorised into three groups

``````   - Singly Linked List

``````

These are linked that can be accessed only in forward direction starting with the first data.

In this lists one node has two pointer: one to the next node and the other to the previous node apart from the first and last node.

This isa linked list where the head and the last node are connected such that the address value of the last node belongs to the first node.

The following are ways in which the mentioned linked lists can be implemented.

``````#Singly Linked Lists

#Node class

Class Node:
def__init__(self, dataval=None)
self.dataval=dataval
self.nextval=None

def__init__(self)
def PrintList (self)
While printval is not None:
print (printval.dataval) #printing the first data value value

printval=printval.nextval # the first node.

#calling the list

N2=Node("Tue")
N3=Node("Wed")
N4=Node("Thur")
N5=Node("Fri")

N2.nextval=N4
N4.dataval=N5

MyList.PrintList()

#Output
Mon
Tue
Wed
Thur
Fri

``````

## Stacks

As the word implies, stacks are structures that store data arranged in a Last-in-First out manner.
One can alter a stack from only one end. Adding and removing items from the stack are carried by the push and pop operations.

``````#creatibg a stack
def stack ():
stack =[]
return stack

#Empty stack
def IsEmpty (stack):
return len (stavk)==0

def push (stack,item):
stack.append (item)
Print ("pushed item; "+item)

#removing item
def pop (stack)
If pop (IsEmpty (stack))
return "stack is empty"
return stack.pop ()

``````