Depth First Search (DFS) is the traversal algorithm that uses a stack data structure to explore vertices in a graph. It is a recursive algorithm that starts at a given vertex and explores as far as possible along each branch before backtracking.

DFS Algorithm Steps:
1. Create a stack and push the starting vertex onto the stack.
2. Mark the starting vertex as visited.
3. While the stack is not empty, do the following steps:
- Pop a vertex from the stack.
- Visit the popped vertex.
- Push all the adjacent vertices of the popped vertex onto the stack if they are not visited and mark them as visited.
- Repeat until the stack is empty.

Explanation:

Depth First Search (DFS) is an algorithm for traversing or searching tree or graph data structures. The main idea behind DFS is to explore as far as possible along each branch before backtracking. It uses a stack data structure to keep track of the vertices to be explored.

The DFS algorithm starts at a given vertex and explores its adjacent vertices by following a path until it reaches a dead end. It then backtracks to the previous vertex and continues exploring other adjacent vertices. This process continues until all vertices have been visited.

The stack data structure is used to keep track of the vertices that need to be explored. When a vertex is visited, it is marked as visited and pushed onto the stack. The algorithm then pops a vertex from the stack, visits it, and pushes its unvisited adjacent vertices onto the stack. This process is repeated until the stack is empty, indicating that all vertices have been visited.

DFS is often used to solve problems like finding connected components in a graph, checking if a graph is cyclic, or finding a path between two vertices.

In conclusion, the Depth First Search (DFS) algorithm uses a stack data structure to explore vertices in a graph. It starts at a given vertex, explores as far as possible along each branch, and backtracks when necessary.