A linked list is composed of a chain of objects known as nodes. Each node contains a value and a pointer to the next node in the chain. The first node in a list is known as the head. The last element in the list points to null (indicating the end of the list).

Example implementation of a Node class:
```python
class Node:
    def __init__(self, value, next = None):
        self.value = value
        self.next = next
```

The following example is a Linked List class that creates a single head node:
```python
class LinkedList:
    def __init__(self):
        self.head = None
```

The following snippet creates a linked list with 3 elements:
```python
my_linked_list = LinkedList()                   # create a LinkedList object
my_linked_list.head = Node("Jon")         # sets the head's value to "Jon"
element2 = Node("Sarah")                    # create a Node with value "Sarah"
element3 = Node("Matt")                     # create a Node with value "Matt"
my_linked_list.head.next = element2     # sets the head's next element to element2
element2.next = element3                    # sets element2's next element to element3
```

Linked List

A stack is a data structure that stores items in a "last in, first out" (LIFO) manner. New elements are added to and removed from the end of a stack. When an item is added to a stack, the operation is known as a "push". When an item is removed from a stack, the operation is known as a "pop".

A simple stack can easily be implemented in Python using the List built-in data structure.

```python
stack = []  # empty stack using the List structure.

stack.append(23)
stack.append(98)
stack.append(5)

element1 = stack.pop()   # pops 5 from the stack and sets the value of element1 to 5
element2 = stack.pop()  # pops 98 from the stack and sets the value of element2 to 98
```

Stack

A queue is a data structure that stores elements in a "first in, first out" (FIFO) manner. The least recently added item is the first element to be removed. An element is enqueued when it is added to the queue. An element is dequeued when it is removed from the queue.

A queue can be implemented using the collections module and deque class.

```python
from collections import deque

queue = deque()   # Initialize queue structure

# Enqueues the elements 20, 73 and 32
queue.append(20)
queue.append(73)
queue.append(32)

# Queue now contains [20, 73, 32]
print(queue)

# Dequeue 20
queue.popLeft()

# Queue now contains [73, 32]
print(queue)

Queue

A tree is an abstract data structure that represents a hierarchical tree. A tree contains a root which is connected to subtrees through linked nodes. The tree data structure is inherently recursive, since a node's subtree is also a tree in and of itself.
A node that has a subtree is the "parent" node of the subtree. The nodes within the subtree of the parent node are called "child" nodes. Child nodes that have the same parent are known as "sibling" nodes.

There are many types of tree data structures. A few of them include:
- Binary Tree (Binary Search Tree)
     1. AVL Tree
     2. Red-Black Tree
     3. Splay Tree
     4. Treap
- B-Tree
- N-ary Tree

Tree

Binary Tree Data Structure 

https://opendatastructures.org/ods-python/14_2_B_Trees.html

B - Tree Data Structure 

https://www.ics.uci.edu/~brgallar/week6_3.html

N - Ary Tree Data Structure 

A heap is a data structure that represents a complete binary tree where each interior node is either greater than or less than its leaf node depending on the type of heap.  

For Min- Heap, the root node key must be less than or equal to all of its children for any given subtree in the heap. For Max- Heap, the root node key must be greater than or equal to all of its children for a given subtree in the heap. 

Heap

https://www.section.io/engineering-education/heap-data-structure-python/

Heap Data Structure 

A graph is a data structure that is made up of nodes (vertices) and are connected by arcs (edges). Graphs are most commonly used to represent a network of information. An example of a graph structure is a map of a city. The blocks or buildings represent nodes. These nodes are connected by roads that represent edges. 

Graphs may be weighted or unweighted. Weighted graphs have a numerical value attached to each individual edge. This means that different edges may have different magnitudes. Unweighted graphs do not have weights related to each edge.

Graphs may also be directed or undirected. Directed graphs mean that each edge has a certain direction. As a result, these edges represent a one-way relationship since edges can only be traverse in one direction. On the other hand, undirected graphs mean that each edge has no direction. Therefore, these edges represent a two-way relationship since edges can be traversed in both directions.

Graph

There are other basic data structures that are not defined in the Python standard library. These include:

- Linked List
- Stack
- Queue
- Tree
- Heap
- Graph

Rutgers University

Data structures facilitate the organization of data in computer memory in an efficient manner which further support faster and more flexible data manipulations.


The python interpreter offers the following built-in data structures:


- List
- Set
- Tuple
- Dictionary


Data Structures in Python

Python Documentation

- List is a built-in data type, it is also a collection datatype(  lists accommodate elements/items of various datatype )
- List is also a sequence data type which can accommodate items of various basic data types  like integers, float etc. but usually items in a list are of same basic data type.
-  A list contains values separated by comma inside a square bracket.
- Lists are resizable. Items in a list can be added, removed and modified after the list is created.
- Lists are mutable, that means  contents of a list can be changed.
- Lists can be nested, that means we can create a list containing another list.

``` python
my_list = [1,"1cademy",12.59,True]
my_list
```
Output

``` python
[1, '1cademy', 12.59, True]
```

List

- A set is an unordered collection of data.
- The items in a set are unordered, unmutable, and cannot contain duplicate values.
- Mathematical operations (e.g. union, intersection, difference, symmetric difference) can be performed on sets.
- To create a set, list elements separated by commas within two curly braces.

Example:
```python
set = {"apple", "orange", "banana"}
```


- A tuple is a data structure that can store items within a single variable.
- The items in a tuple are ordered (indexed) and are immutable (cannot be changed).
- Tuples can have duplicate items.
- To create a tuple, surround items (separated by commas) with parentheses.
Ex:
```python
tuple = ('apple', 34, 'banana')
```
- To access an element inside a tuple, use the tuple name along with square brackets and the desired index.
Ex:
```python
tuple[1] # access tuple index 1, which is 34.
```

Tuple

• Dictionary is a built-in data structure. A dictionary is an ordered and mutable collection of objects.
• It consists of Key-Value pairs. Each Key must be Unique.

Syntax:
```python
dictionary = {"key name": value}
```
```python
student_scores = {
    "John" : 76,
    "Peter": 95,
    "Mike": 84
}
```
We can access the Values using the Keys:
```python
print(student_scores["John"])
```
This ```python print() ``` statement would print out the value 76. It is also important to note that keys must map to a unique value. 


Learn Before

Related

Learn After