Razvrščanje algoritmov

Algorithms are step-by-step procedures for solving problems
Data structures are particular ways of organizing data in a computer
Sorting algorithms arrange elements in a specific order
Search algorithms locate specific elements within a data structure
Data organization involves structuring data for efficient access and modification
Complexity analysis evaluates algorithm performance in terms of time and space

Sorting algorithms arrange elements of a list in a specific order
Common sorting orders are numerical or lexicographical
Bubble Sort repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order
Bubble sort is simple but inefficient for large lists, with average and worst-case time complexity of O(n^2)
Insertion Sort builds the final sorted array one item at a time
Insertion sort is efficient for small data sets, relatively efficient for nearly sorted lists, and has an average and worst-case time complexity of O(n^2)
Selection Sort divides the input list into two parts: the sorted sublist and the sublist of remaining unsorted elements
Selection sort is simple to implement, but inefficient for large lists, with average and worst-case time complexity of O(n^2)
Merge Sort divides the list into equal halves, sorts each half, and then merges the sorted halves
Merge sort is efficient, with a time complexity of O(n log n), but requires additional space for the merging process
Quick Sort selects a 'pivot' element and partitions the other elements into two sub-lists, according to whether they are less than or greater than the pivot
Quick sort is efficient, with an average time complexity of O(n log n), but its worst-case time complexity is O(n^2)
Heap Sort uses a binary heap data structure to sort elements
Heap sort is efficient, with a time complexity of O(n log n), and sorts in place

Search algorithms find a specific element in a data structure
Linear Search sequentially checks each element of the list until a match is found or the entire list has been searched
Linear search is simple but inefficient for large lists, with a time complexity of O(n)
Binary Search repeatedly divides the search interval in half
Binary search is efficient for sorted lists, with a time complexity of O(log n)
Hash Table Search uses a hash function to compute an index into an array of buckets or slots
Hash table search can be very efficient, with an average time complexity of O(1) for search, insertion, and deletion, but performance depends on the hash function and collision resolution strategy

Data organization involves structuring data for efficient access and modification
Arrays are a collection of elements of the same type, stored in contiguous memory locations
Arrays offer fast access to elements via index, but have a fixed size
Linked Lists are a collection of nodes, where each node contains data and a pointer to the next node
Linked lists offer dynamic size and easy insertion/deletion of elements, but slower access compared to arrays
Stacks follow the Last-In-First-Out (LIFO) principle
Stacks are useful for managing function calls and evaluating expressions
Queues follow the First-In-First-Out (FIFO) principle
Queues are useful for managing tasks in a system
Trees are hierarchical data structures where each node has a parent and zero or more children
Trees facilitate efficient searching, insertion, and deletion operations
Hash Tables use a hash function to map keys to values
Hash tables provide fast average-case lookup, insertion, and deletion operations

Complexity analysis evaluates the performance of algorithms in terms of time and space
Time complexity refers to the amount of time taken by an algorithm to run as a function of the input size
Space complexity refers to the amount of memory space required by an algorithm as a function of the input size
Big O notation describes the upper bound of an algorithm's time or space complexity
O(1) denotes constant complexity
O(log n) denotes logarithmic complexity
O(n) denotes linear complexity
O(n log n) denotes linearithmic complexity
O(n^2) denotes quadratic complexity
O(2^n) denotes exponential complexity
Understanding complexity is crucial for selecting the most efficient algorithm for a particular task

Graph structures consist of nodes (vertices) connected by edges
Graphs are used to model relationships between objects
A graph is represented as G = (V, E), where V is the set of vertices and E is the set of edges
Graphs can be directed or undirected
In a directed graph, edges have a direction
In an undirected graph, edges have no direction
Graphs can be weighted or unweighted
In a weighted graph, each edge has a weight or cost associated with it
In an unweighted graph, edges have no weight
Adjacency Matrix represents a graph as a 2D array, where element [i][j] indicates whether there is an edge from vertex i to vertex j
Adjacency List represents a graph as an array of lists, where each list represents the neighbors of a vertex
Breadth-First Search (BFS) explores the graph level by level, starting from a source vertex
Depth-First Search (DFS) explores the graph by going as deep as possible along each branch before backtracking
Shortest Path Algorithms find the path with the minimum cost between two vertices in a graph
Dijkstra's Algorithm finds the shortest paths from a source vertex to all other vertices in a weighted graph with non-negative edge weights
Bellman-Ford Algorithm finds the shortest paths from a source vertex to all other vertices in a weighted graph, even with negative edge weights