A **stack** data structure is a so-called **LIFO (Last In, First Out)** data structure. It means that the last item inserted in the stack will be the first item removed. And, of course, it is very important that we can **access only the last element** in a data structure exclusively when dealing with the stack.

import numpy as np

class Stack:
    def __init__(self):
        self.stack = np.array([])  # Initialize an empty NumPy array

    def push(self, item):
        self.stack = np.append(self.stack, item)  # Append the item to the end of the array

    def pop(self):
        if not self.is_empty():
            return_value = self.stack[-1]  # Store the value to return
            self.stack = np.delete(self.stack, -1)  # Remove the last item from the array
            return return_value  # Return the removed item
        else:
            return None  # Return None if the stack is empty


# Example usage:
stack = Stack()

stack.push(1)
stack.push(2)
stack.push(3)

print("Stack:", stack.stack)

print("Pop:", stack.pop())
print("Stack after pop:", stack.stack)

It is important to remember that a stack is an abstract data type. It means that it only **defines behavior but not a concrete implementation**. The stack abstract data type can be implemented either with the help of the **array** or **linked list** data structure.

Usually, in concrete implementations of the stack, two basic methods are used: 
- `push()` - inserts an item into a stack; 
- `pop()` - removes the last inserted item from a stack.

## Basic operations time complexity

<!DOCTYPE html>
<html>
<head>
  <style>
    table {
      width: 80%;
      margin: 20px auto;
      border-collapse: collapse;
      border: 1px solid #ddd;
    }
    th,
    td {
      padding: 10px;
      text-align: left;
    }
    th {
      background-color: #f2f2f2;
    }
    tr:nth-child(even) {
      background-color: #f2f2f2;
    }
    tr:hover {
      background-color: #ddd;
    }
    th strong {
      font-weight: bold;
    }
    td strong {
      font-weight: bold;
    }
  </style>
</head>
<body>

<table>
  <tr>
    <th>Method</th>
    <th>Array Implementation</th>
    <th>Doubly Linked List Implementation</th>
  </tr>
  <tr>
    <td>push()</td>
    <td>O(1)</td>
    <td>O(1)</td>
  </tr>
  <tr>
    <td>pop()</td>
    <td>O(1)</td>
    <td>O(1)</td>
  </tr>
 
 
</table>

</body>
</html>


In a stack, which element is at the bottom?

The understanding of data structures and algorithms: this is what sets advanced professionals apart from the rest. In the modern world of growing data, it is very important to be able to process large amounts of data efficiently. 

In this course, you will study the most basic data structures that help us to deal with huge amounts of data as well as implement the most basic and crucial concepts on your own so you’ll get a deeper understanding of how each data structure works and you'll be able to decide what data structure best suited for your task.

When we start learning something new, it is very important to get familiar with the subject of our study first. So let's dive deeper into what we will learn about in this course.

Arrays and lists serve as foundational data structures in programming, with Python employing them extensively. This section provides an overview of these structures, delving into their concepts and highlighting their implementation nuances within the Python programming language.

There are many applied tasks in which it is necessary to operate with large amounts of structured data and simple data structures such as an array or a linked list may no longer be enough for these purposes. In this section, we'll look at the concept of an abstract data type and how different ADTs allow us to efficiently manage large amounts of data.

In the real world, one often has to deal with tasks in which it is necessary to model complex dependencies between various nodes of a system or domain. Graphs can help us with this. In this section, we will learn what a graph is and how to represent it in computer memory efficiently.

Algorithms and Data Structures Overview

Stacks

Stack implementation

Basic operations time complexity

In a stack, which element is at the bottom?

Method	Array Implementation	Doubly Linked List Implementation
push()	O(1)	O(1)
pop()	O(1)	O(1)