IT 201: Data Structures and Algorithms – Key Vocabulary

Vocabulary flashcards covering foundational terms from the introductory sections of IT 201: Data Structures and Algorithm.

Data Structure

An organized scheme for collecting and arranging data in memory so it can be processed efficiently.

Algorithm

A finite, ordered set of instructions designed to solve a specific problem.

Abstract Data Type (ADT)

A functional description of a data structure, independent of its implementation details.

Primitive Data Structure

A basic structure that cannot be decomposed further, e.g., integer, float, char, Boolean, pointer.

Non-Primitive Data Structure

A composite structure derived from primitives, e.g., strings, arrays, lists, records, files.

Linear Data Structure

Stores elements sequentially so they can be accessed in order; examples include stacks, queues, linked lists.

Non-Linear Data Structure

Stores elements in hierarchical or network form; examples include trees and graphs.

Time Complexity

The amount of processing time an algorithm needs to finish execution.

Space Complexity

The total memory an algorithm requires while running, including instruction, data, and environment space.

Instruction Space

Memory needed to store the executable code of a program.

Data Space

Memory allocated for constants and variable values used by a program.

Environment Space

Memory required to save the state necessary to resume a suspended function.

Traversing

Visiting each element of a data structure systematically.

Searching

Locating a specific element within a data structure.

Insertion

Adding a new element to a data structure.

Deletion

Removing an existing element from a data structure.

Sorting

Arranging data elements in a specified order (ascending or descending).

Merging

Combining two sorted data sets into one sorted set.

Linked List

A linear collection of nodes where each node stores data and a pointer to the next node.

Pointer

A variable that holds the memory address of another variable or node.

Node

A fundamental unit of a linked data structure containing data and links (pointers).

Stack

A linear structure that follows Last-In-First-Out (LIFO) access.

Queue

A linear structure that follows First-In-First-Out (FIFO) access.

Enqueue

The operation of inserting an element at the rear of a queue.

Dequeue

The operation of removing an element from the front of a queue.

Circular Queue

A queue where the last position is linked back to the first to utilize empty space efficiently.

Priority Queue

A queue where each element has a priority, and removal occurs in priority order.

Hash Table

A structure that stores key–value pairs using a hash function for fast access.

Hash Function

A calculation that maps a key to an index in a hash table.

Hash Collision

The event when two keys hash to the same table index.

Rehashing

The process of finding another index when a collision occurs in a hash table.

Binary Tree

A hierarchical structure in which each node has at most two children (left and right).

Linear Search

A search method that checks each element sequentially until the target is found.

Binary Search

A search method that repeatedly divides a sorted list in half to find a target value.

Interpolation Search

A search algorithm that estimates the position of the target based on key value distribution.

Bubble Sort

A simple sorting algorithm that repeatedly swaps adjacent elements if they are out of order.

Selection Sort

A sorting algorithm that repeatedly selects the minimum element and places it at the front.

Insertion Sort

A sorting algorithm that builds the final list one item at a time by inserting elements into their correct position.

Quick Sort

A divide-and-conquer sorting algorithm that partitions data around a pivot element.

Merge Sort

A stable, divide-and-conquer sorting algorithm that recursively merges sorted sublists.