Data Structures Overview

Definition: A way to organize and store data for efficient access and modification.
Types of Data Structures:
1. Linear Data Structures:
  - Arrays: Collection of elements stored at contiguous memory locations.
  - Linked Lists: A sequence of nodes where each node contains data and a reference to the next node.
  - Stacks: Last-In-First-Out (LIFO) structure; supports push and pop operations.
  - Queues: First-In-First-Out (FIFO) structure; supports enqueue and dequeue operations.
2. Non-linear Data Structures:
  - Trees: Hierarchical structure with nodes; includes binary trees, AVL trees, etc.
  - Graphs: A set of nodes connected by edges; can be directed or undirected.
Abstract Data Types (ADTs): Conceptual models of data types that define operations but not implementation, e.g., sets, maps, and lists.
Complexity:
- Time Complexity: Measures the time required for operations (e.g., O(n), O(log n)).
- Space Complexity: Measures the memory required by data structures.

Definition: A programming paradigm based on the concept of "objects," which can contain data and code.
Core Principles:
1. Encapsulation: Bundling data and methods operating on that data within an object; restricting access to some components.
2. Abstraction: Simplifying complex systems by modeling classes based on essential properties and behaviors.
3. Inheritance: Mechanism to create new classes from existing ones; promotes code reuse (e.g., base class and derived class).
4. Polymorphism: Ability to present the same interface for different data types; includes method overriding and overloading.
Key Concepts:
- Classes and Objects:
  - Class: Blueprint for creating objects (e.g., attributes and methods).
  - Object: Instance of a class.
- Constructor: Special method invoked when an object is created; initializes object attributes.
- Destructor: Method invoked when an object is destroyed; used for cleanup.
Common OOP Languages: Java, C++, Python, C#, Ruby.

Definition: Organize and store data for efficient access and modification.
Types of Data Structures:
- Linear Data Structures:
  - Arrays: Elements stored at contiguous memory locations.
  - Linked Lists: Sequence of nodes with data and a reference to the next node.
  - Stacks: Last-In-First-Out (LIFO) structure; supports push (adding) and pop (removing) operations.
  - Queues: First-In-First-Out (FIFO) structure; supports enqueue (adding) and dequeue (removing) operations.
- Non-linear Data Structures:
  - Trees: Hierarchical structure with nodes; includes variations such as binary trees and AVL trees.
  - Graphs: Set of nodes connected by edges; can be directed (one-way connections) or undirected (two-way connections).
Abstract Data Types (ADTs): Conceptual models defining operations without specifying implementation, such as sets, maps, and lists.
Complexity:
- Time Complexity: Measures operational time, expressed using Big O notation (e.g., O(n), O(log n)).
- Space Complexity: Measures the memory usage of data structures.

Definition: Programming paradigm based on objects that encapsulate data and code.
Core Principles:
- Encapsulation: Bundles data and methods within an object, limiting outside access to internal components.
- Abstraction: Simplifies complex systems by creating classes that model essential properties and behaviors.
- Inheritance: Allows creation of new classes from existing ones to promote code reuse (e.g., base class can be extended by derived classes).
- Polymorphism: Enables the same interface to be used for different data types, incorporates method overriding and overloading.
Key Concepts:
- Classes and Objects:
  - Class: Blueprint for object creation, defining attributes and methods.
  - Object: An instance of a class.
- Constructor: Special method that initializes object attributes upon creation.
- Destructor: Method invoked when an object is destroyed, used for cleanup purposes.
Common OOP Languages: Java, C++, Python, C#, Ruby.