Data Structure and Algorithms Sorting

Aug 27, 2018Download as ppt, pdf

1 like177 views

The document describes three sorting algorithms: bubble sort, insertion sort, and selection sort. Bubble sort works by traversing a list from the beginning to end and swapping adjacent elements to bubble the largest values to the end over multiple passes until the list is fully sorted. Insertion sort iterates through a list and inserts each element into its sorted position by shifting other elements over. Selection sort finds the minimum element on each pass and swaps it into the front of the partially sorted list. All three algorithms have a worst-case quadratic runtime of O(n^2).

Bubble sort
Insertion sort
Selection sort

Sorting Algorithm
Sorting takes an unordered collection and
makes it an ordered one.
2
512354277 101
5 12 35 42 77 101
1 2 3 4 5 6
1 2 3 4 5 6

"Bubbling Up" the Largest Element
Traverse a collection of elements
Move from the front to the end
“Bubble” the largest value to the end using pair-
wise comparisons and swapping
3
512354277 101
1 2 3 4 5 6

Repeat “Bubble Up” How Many
Times?
If we have N elements…
And if each time we bubble an element, we
place it in its correct location…
Then we repeat the “bubble up” process N
– 1 times.
This guarantees we’ll correctly
place all N elements.
10

“Bubbling” All the Elements
11
77123542 5 101
5421235 77 101
4253512 77 101
4235512 77 101
4235125 77 101
N-1
1 2 3 4 5 6

Bubble Sort
Algorithm
for i  1 to n-1 do
for j  1 to n-i do
if (A[j+1] < A[j]) swap A[j] and A[j+1] ;
}
}
Analysis:
In general, if the list has n elements, we will have to do
(n-1) + (n-2) …. + 2 +1 = (n-1) n / 2 comparisons.
=O(n^2)
12

Insertion Sort
INSERTION_SORT (A, N)
1.Set A[0] = -∞.
2.Repeat Step 3 to 5 for K = 2, 3, …, N:
3. Set TEMP = A[K] and PTR = K – 1.
4. Repeat while TEMP < A[PTR]:
(a) Set A[PTR+1] = A[PTR]
(b) Set PTR = PTR – 1.
[End of Loop.]
5. Set A[PTR+1] = TEMP.
[End of Loop 2.]
6.Return.

Insertion Sort Example
Sort: 34 8 64 51 32 21
34 8 64 51 32 21
The algorithm sees that 8 is smaller than 34 so it swaps.
8 34 64 51 32 21
51 is smaller than 64, so they swap.
8 34 51 64 32 21
8 34 51 64 32 21 (from previous slide)
The algorithm sees 32 as another smaller number and moves
it to its appropriate location between 8 and 34.
8 32 34 51 64 21
The algorithm sees 21 as another smaller number and moves
into between 8 and 32.
Final sorted numbers:
8 21 32 34 51 64

Insertion Sort Complexity
This Sorting algorithm is frequently used when n is very small.
Worst case occurs when array is in reverse order. The inner loop
must use K – 1 comparisons.
f(n) = 1 + 2 + 3 + ….+ (n – 1)
= n(n – 1)/2
= O(n2
)
In average case, there will be approximately (K – 1)/2 comparisons
in the inner loop.
f(n) = (1 + 2 + 3 + ….+ (n – 1))/2
= n(n – 1)/4
= O(n2
)

Selection Sort
This algorithm sorts an array A with N elements.
SELECTION(A, N)
1.Repeat steps 2 and 3 for k=1 to N-1:
2. Call MIN(A, K, N, LOC).
3. [Interchange A[k] and A[LOC]]
Set Temp:= A[k], A[k]:= A[LOC] and A[LOC]:=Temp.
[End of step 1 Loop.]
1.Exit.
MIN(A, K, N, LOC).
1.Set MIN := A[K] and LOC:= K.
2.Repeat for j=k+1 to N:
If Min>A[j], then: Set Min:= A[j] and LOC:=J.
[End of if structure]
3.Return.

Selection Sort Example
1329648
8329641
8349621
8649321
8964321
8694321
9864321
9864321

Selection Sort Complexity
The number f(n) of comparisons in selection sort
algorithm is independent of original order of elements.
There are n-1 comparisons during pass 1 to find the
smallest element, n-2 comparisons during pass 2 to find
the second smallest element, and so on.
Accordingly,
f (n) = (n-1)+(n-2)+-----+2+1
= n(n-1)/2
= O(n2
)
The f (n) holds the same value O(n2
) both for worst case
and average case.

Comparing the Algorithms
Best Average Worst
Case Case Case
Bubble Sort O(n) O(n2
) O(n2
)
Insertion Sort O(n) O(n2
) O(n2
)
Selection Sort O(n2
) O(n2
) O(n2
)

Merge sort is a divide and conquer algorithm that works as follows: 1) Divide the array to be sorted into two halves recursively until single element subarrays are reached. 2) Merge the subarrays in a way that combines them in a sorted order. 3) The merging process involves taking the first element of each subarray and comparing them to place the smaller element in the final array until all elements are merged. Merge sort runs in O(n log n) time in all cases making it one of the most efficient sorting algorithms.

Algorithm - Mergesort & Quicksort Varendra University Rajshahi-bangladesh

Merge sort and quick sortShakila Mahjabin

The document discusses different sorting algorithms including merge sort and quicksort. Merge sort has a divide and conquer approach where an array is divided into halves and the halves are merged back together in sorted order. This results in a runtime of O(n log n). Quicksort uses a partitioning approach, choosing a pivot element and partitioning the array into subarrays of elements less than or greater than the pivot. In the best case, this partitions the array in half at each step, resulting in a runtime of O(n log n). In the average case, the runtime is also O(n log n). In the worst case, the array is already sorted, resulting in unbalanced partitions and a quadratic runtime of O(n^2

Merge sortSindhoo Oad

Merge sort is a sorting algorithm that uses a divide and conquer approach. It divides an array into halves, recursively sorts the halves, and then merges the sorted halves into a single sorted array. The key steps are dividing, conquering by recursively sorting subarrays, and combining the sorted subarrays through a merging process. It has advantages of being a stable sort and having no worst-case scenario, though it requires more memory than other sorts.

Mergesortluzenith_g

The document discusses the merge sort algorithm. It works by recursively dividing an array into two halves, sorting each half, and then merging the sorted halves back together. The key steps are: 1) Divide the array into equal halves recursively until arrays contain a single element. 2) Sort the halves by recursively applying the merge sort algorithm. 3) Merge the sorted halves back into a single sorted array by comparing elements and copying the smaller value into the output array.

Merge sortKumar

Merge sort is a sorting algorithm that works by dividing an array into halves, recursively sorting the halves, and then merging the sorted halves into one sorted array. It has the following properties: 1) It uses a divide and conquer approach - it divides the array into halves, recursively sorts the halves, and then merges the sorted halves. 2) It has a time complexity of O(n log n) as most of the work is done in the merging step. 3) It uses O(n) additional space to store temporary arrays during the merging step, requiring more space than other sorting algorithms.

Merge sort algorithm power point presentationUniversity of Science and Technology Chitttagong

Presentation on binary search, quick sort, merge sort and problemsSumita Das

The document discusses four sorting algorithms: binary search, quicksort, merge sort, and their working principles. It provides: 1) Binary search works by repeatedly dividing a sorted list in half and evaluating the target value against the midpoint. 2) Quicksort uses a pivot element to partition an array into subarrays of smaller size, sorting them recursively. 3) Merge sort divides an array into halves, recursively sorts them, and then merges the sorted halves back together. 4) Examples are given of how each algorithm would sort sample arrays through their divide and conquer approaches.

8th pre alg -l41jdurst65

The document contains notes from a math lesson on November 12, 2013. It includes the following: 1) An assignment is due on Thursday November 14th and asks if a test was signed. 2) Warm-up problems include finding the area and circumference of a circle with diameter 6m, writing a number in scientific notation, and simplifying expressions. 3) The lesson defines functions, linear functions, and what makes a graph proportional. Linear functions that pass through (0,0) and rise to the right are proportional. 4) Examples are given to make function tables and graph linear equations to determine if they are proportional, including the functions y=3x, y=2x-

Merge sort-algorithm for computer science engineering studentsUniversity of Science and Technology Chitttagong

Algorithm: Quick-SortTareq Hasan

The document describes the quicksort algorithm. Quicksort works by: 1) Partitioning the array around a pivot element into two sub-arrays of less than or equal and greater than elements. 2) Recursively sorting the two sub-arrays. 3) Combining the now sorted sub-arrays. In the average case, quicksort runs in O(n log n) time due to balanced partitions at each recursion level. However, in the worst case of an already sorted input, it runs in O(n^2) time due to highly unbalanced partitions. A randomized version of quicksort chooses pivots randomly to avoid worst case behavior.

Algorithm designing using divide and conquer algorithmsSiddhantShelake

The document discusses divide and conquer algorithms. It explains that divide and conquer algorithms break problems down into smaller subproblems, solve those, and then combine the solutions. Examples given include merge sort, quick sort, binary search, and the Tower of Hanoi problem. Merge sort works by breaking a list into single elements and then merging the sorted sublists. Quick sort selects a pivot value and partitions the array into elements less than and greater than the pivot. Binary search works on a sorted array by comparing the search value to the middle element. The Tower of Hanoi involves moving disks between rods according to rules of only moving one disk at a time and not placing a larger disk on a smaller one.

10 merge sortirdginfo

The Merge Sort algorithm works by recursively dividing an array into halves and then merging the sorted halves together. It has three main steps: 1) Divide the array into single elements 2) Recursively sort the left and right halves 3) Merge the sorted halves back together It uses the principle of recursion to break down a problem into sub-problems until reaching a base case, which is merging arrays of single elements. This approach guarantees an overall sort that takes N log N time in the worst case.

Daa finalGagan019

Merge sort is a sorting algorithm that uses the divide and conquer technique. It divides the unsorted list into halves, recursively sorts the sub-lists, and then merges the sorted sub-lists into a single sorted list. The key steps are dividing, conquering by recursively sorting the sub-problems, and merging the sorted sub-lists. Merge sort has a time complexity of O(n log n) in all cases (best, average, worst) and requires additional storage space.

Merge sort algorithmShubham Dwivedi

Divide and conquerDr Shashikant Athawale

The document discusses divide and conquer algorithms. It describes divide and conquer as a design strategy that involves dividing a problem into smaller subproblems, solving the subproblems recursively, and combining the solutions. It provides examples of divide and conquer algorithms like merge sort, quicksort, and binary search. Merge sort works by recursively sorting halves of an array until it is fully sorted. Quicksort selects a pivot element and partitions the array into subarrays of smaller and larger elements, recursively sorting the subarrays. Binary search recursively searches half-intervals of a sorted array to find a target value.

03 dcHira Gul

This document discusses the merge sort algorithm for sorting a sequence of numbers. It begins by introducing the divide and conquer approach and defining the sorting problem. It then describes the three steps of merge sort as divide, conquer, and combine. It provides pseudocode for the merge sort and merge algorithms. Finally, it analyzes the running time of merge sort, showing that it runs in O(n log n) time using the recursion tree method.

Advance heat transfer 2JudeOliverMaquiran1

The document discusses heat transfer equations in rectangular, cylindrical, and spherical coordinate systems. It begins by deriving the one-dimensional heat conduction equation in rectangular coordinates, assuming temperature depends only on position and time. It then presents the equation in dimensionless form using Fourier number and heat generation number. The conduction terms are replaced with the Laplacian operator to remove dependence on coordinate system. Finally, the Laplacian forms of the heat equation are presented for cylindrical and spherical systems.

Sorting and searchingkalyanineve

The document discusses various sorting algorithms. It describes insertion sort, selection sort, bubble sort, and merge sort. Insertion sort works by inserting each element into the sorted position in a subarray. Selection sort finds the smallest element and swaps it into the first position in each pass. Bubble sort compares and swaps adjacent elements to bubble large elements to the end. Merge sort divides the array into halves, recursively sorts them, and then merges the sorted halves.

4 ESO Academics - UNIT 02 - POWERS, ROOTS AND LOGARITHMSGogely The Great

1. The document discusses exponent notation and integer exponent powers. Exponent notation (such as 25) represents multiplying a base number (2) a certain number of times (5). 2. It defines terms like square and cube powers, and describes properties of exponents such as when multiplying or dividing powers with the same base. 3. Roots and radicals are also covered, including how to write radicals as fractional exponents and simplify radicals. Operations like adding, subtracting, multiplying and dividing radicals are described.

Linear Systems Gauss SeidelEric Davishahl

The document discusses several iterative methods for solving systems of equations, including Jacobi iteration, Gauss-Seidel method, and relaxation methods. The Gauss-Seidel method is commonly used and improves guesses for unknowns using values from the current iteration. Convergence is determined by calculating the relative percent change between iterations. Relaxation methods can enhance convergence by taking a weighted average of old and new values at each iteration.

Dinive conquer algorithmMohd Arif

The document discusses the divide and conquer algorithm design technique. It begins by explaining the basic approach of divide and conquer which is to (1) divide the problem into subproblems, (2) conquer the subproblems by solving them recursively, and (3) combine the solutions to the subproblems into a solution for the original problem. It then provides merge sort as a specific example of a divide and conquer algorithm for sorting a sequence. It explains that merge sort divides the sequence in half recursively until individual elements remain, then combines the sorted halves back together to produce the fully sorted sequence.

FunctionsMaurice Verreck

Quick sort Algorithm Discussion And AnalysisSNJ Chaudhary

Quicksort is a divide-and-conquer algorithm that works by partitioning an array around a pivot element and recursively sorting the subarrays. In the average case, it has an efficiency of Θ(n log n) time as the partitioning typically divides the array into balanced subproblems. However, in the worst case of an already sorted array, it can be Θ(n^2) time due to highly unbalanced partitioning. Randomizing the choice of pivot helps avoid worst-case scenarios and achieve average-case efficiency in practice, making quicksort very efficient and commonly used.

Divide and conquer - Quick sortMadhu Bala

Divide and conquerEmmanuel college

This document discusses the divide-and-conquer algorithm design strategy. It begins by defining divide-and-conquer as dividing a problem into smaller subproblems, solving those subproblems recursively, and combining the solutions. Examples covered include sorting algorithms like mergesort and quicksort, tree traversals, binary search, integer multiplication, matrix multiplication using Strassen's algorithm, and closest pair problems. Analysis techniques like recursion trees and the master theorem are introduced.

Split and list technique for solving hard problemsRohit Kumar Singh

State feedback examplecairo university

The document finds the state feedback gain matrix K to place the closed loop poles at specific locations for a controllable system. It first transforms the system into controllable canonical form, then calculates K using the characteristic equation. The closed loop transfer function is determined to be a 3rd order function divided by a 3rd order polynomial with coefficients matching the desired closed loop poles.

ds 3Sorting.pptAlliVinay1

This document describes three sorting algorithms: bubble sort, insertion sort, and selection sort. Bubble sort works by repeatedly "bubbling up" the largest value to the end of the array through pairwise comparisons and swaps. Insertion sort inserts elements into the sorted portion of the array by comparing elements and swapping as needed. Selection sort finds the minimum element and swaps it into the front repeatedly. All three algorithms have a worst-case complexity of O(n2) due to the potential for many swaps or comparisons.

Unit vii sorting Tribhuvan University

The document summarizes various sorting algorithms: - Bubble sort works by repeatedly swapping adjacent elements that are in the wrong order until the list is fully sorted. It requires O(n^2) time. - Insertion sort iterates through the list and inserts each element into its sorted position. It is an adaptive algorithm with O(n) time for nearly sorted inputs. - Quicksort uses a divide and conquer approach, recursively partitioning the list around a pivot element and sorting the sublists. It has average case performance of O(nlogn) time.

More Related Content

What's hot (20)

8th pre alg -l41jdurst65

Merge sort-algorithm for computer science engineering studentsUniversity of Science and Technology Chitttagong

Algorithm: Quick-SortTareq Hasan

Algorithm designing using divide and conquer algorithmsSiddhantShelake

10 merge sortirdginfo

Daa finalGagan019

Merge sort algorithmShubham Dwivedi

Divide and conquerDr Shashikant Athawale

03 dcHira Gul

Advance heat transfer 2JudeOliverMaquiran1

Sorting and searchingkalyanineve

4 ESO Academics - UNIT 02 - POWERS, ROOTS AND LOGARITHMSGogely The Great

Linear Systems Gauss SeidelEric Davishahl

Dinive conquer algorithmMohd Arif

FunctionsMaurice Verreck

Quick sort Algorithm Discussion And AnalysisSNJ Chaudhary

Divide and conquer - Quick sortMadhu Bala

Divide and conquerEmmanuel college

Split and list technique for solving hard problemsRohit Kumar Singh

State feedback examplecairo university

8th pre alg -l41jdurst65

Merge sort-algorithm for computer science engineering studentsUniversity of Science and Technology Chitttagong

Algorithm: Quick-SortTareq Hasan

Algorithm designing using divide and conquer algorithmsSiddhantShelake

10 merge sortirdginfo

Daa finalGagan019

Merge sort algorithmShubham Dwivedi

Divide and conquerDr Shashikant Athawale

03 dcHira Gul

Advance heat transfer 2JudeOliverMaquiran1

Sorting and searchingkalyanineve

4 ESO Academics - UNIT 02 - POWERS, ROOTS AND LOGARITHMSGogely The Great

Linear Systems Gauss SeidelEric Davishahl

Dinive conquer algorithmMohd Arif

FunctionsMaurice Verreck

Quick sort Algorithm Discussion And AnalysisSNJ Chaudhary

Divide and conquer - Quick sortMadhu Bala

Divide and conquerEmmanuel college

Split and list technique for solving hard problemsRohit Kumar Singh

State feedback examplecairo university

Similar to Data Structure and Algorithms Sorting (20)

ds 3Sorting.pptAlliVinay1

Unit vii sorting Tribhuvan University

Unit 7 sortingDabbal Singh Mahara

The document discusses various sorting algorithms. It provides an overview of bubble sort, selection sort, and insertion sort. For bubble sort, it explains the process of "bubbling up" the largest element to the end of the array through successive passes. For selection sort, it illustrates the process of finding the largest element and swapping it into the correct position in each pass to sort the array. For insertion sort, it notes that elements are inserted into the sorted portion of the array in the proper position.

L 14-ct1120Zia Ush Shamszaman

The document provides an overview of different sorting algorithms, including selection sort, insertion sort, bubble sort, and others. It discusses the basic approach for each algorithm through examples and pseudocode. Selection sort finds the minimum value and swaps it into the first position on each pass. Insertion sort inserts each element into the sorted portion of the array. Bubble sort compares adjacent elements and swaps them if out of order, bubbling the largest value to the end.

SortingZaid Shabbir

The document provides information on various sorting and searching algorithms, including bubble sort, insertion sort, selection sort, quick sort, sequential search, and binary search. It includes pseudocode to demonstrate the algorithms and example implementations with sample input data. Key points covered include the time complexity of each algorithm (O(n^2) for bubble/insertion/selection sort, O(n log n) for quick sort, O(n) for sequential search, and O(log n) for binary search) and how they work at a high level.

SortingZaid Shabbir

Data structure.pptxSajalFayyaz

Data Structure (MC501)Kamal Singh Lodhi

The document provides an overview of several sorting algorithms, including insertion sort, bubble sort, selection sort, and radix sort. It describes the basic approach for each algorithm through examples and pseudocode. Analysis of the time complexity is also provided, with insertion sort, bubble sort, and selection sort having worst-case performance of O(n^2) and radix sort having performance of O(nk) where k is the number of passes.

Lecture 13 data structures and algorithmsAakash deep Singhal

The document discusses various sorting algorithms and their complexity. It begins by defining sorting as arranging data in increasing or decreasing order. It then discusses the complexity of sorting algorithms in terms of comparisons, swaps, and assignments needed. Sorting algorithms are divided into internal sorts, which use only main memory, and external sorts, which use external storage like disks. Popular internal sorting algorithms discussed in detail include bubble sort, selection sort, insertion sort, and merge sort. Bubble sort has a time complexity of O(n2) while merge sort and quicksort have better time complexities of O(nlogn).

Different Searching and Sorting Methods.pptxMinakshee Patil

Linear Search, Binary Search Bubble Sort, Merge Sort Quick Sort, Selection Sort Insertion Sort, Radix Sort, Bucket Sort Complexity Issues of algorithms Linear Search is defined as a sequential search algorithm that starts at one end and goes through each element of a list until the desired element is found, otherwise the search continues till the end of the data set. It is the easiest searching algorithm. In Binary search, best case occurs when the element to search is found in first comparison, i.e., when the first middle element itself is the element to be searched. The best-case time complexity of Binary search is O(1). Average Case : The average case time complexity of Binary search is O(logn) Worst Case: In Binary search, the worst case occurs, when we have to keep reducing the search space till it has only one element. The worst-case time complexity of Binary search is O(logn). Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pair-wise comparisons and swapping Algorithm Bubble_Sort(a, n) { for i := 1 to n – 1 do { // to keep track of the number of iterations for j := 0 to n –i-1 { // to compare the elements inside the particular iteration if (a[j] > a[j + 1]) then swap(a[j], a[j + 1]); // swap if any element is greater than its adjacent element } } } Best Case: The best case occurs when the array is already sorted. So the number of comparisons required is N-1 and the number of swaps required = 0. Hence the best case complexity is O(N). Worst Case: The worst-case condition for bubble sort occurs when elements of the array are arranged in decreasing order.In the worst case, the total number of iterations or passes required to sort a given array is (N-1). where ‘N’ is the number of elements present in the array. In each iteration Total number of swaps = Total number of comparison Total number of comparison (Worst case) = N(N-1)/2Total number of swaps (Worst case) = N(N-1)/2 So worst case and average case time complexity is O(N2) as N2 is the highest order term. Partitioning a[1:n] into two subarrays in such a way that sorted subarrays do not need to be merged later. This is accomplished by rearranging the elements in a[1:n] such that a[i] <= a[j] for all i between 1 to m, and for all j between m+1 to n where 1<=m<=n. Thus, the elements in a[1:m] and a[m+1:n] can be sorted independently No need for merging The rearrangement of the elements is accomplished by picking some element of a[],say t = a[s],and then reordering the other elements so that all elements appearing before t in a[1:n] are less than or equal to t and all elements appearing after t are greater than or equal to t. This rearranging is referred to as partitioning. In selection sort, the smallest value among the unsorted elements of the array is selected in every pass and inserted to its appropriate position into the array. In this algorithm, the array is divided into two parts, first is sorted part, and ano

BUBBLESORT Ashish Sadavarti

The document describes the bubble sort algorithm. Bubble sort works by comparing adjacent elements and swapping them into ascending order. This process is repeated, with each iteration bubbling the largest remaining element to its correct position. The algorithm has an outer loop that repeats the bubbling process N-1 times to fully sort an array of N elements. Each iteration reduces the number of comparisons needed by bubbling one element into place. Though simple, bubble sort is not very efficient for large arrays due to its quadratic time complexity.

358 33 powerpoint-slides_14-sorting_chapter-14sumitbardhan

The document describes several sorting algorithms: 1) Bubble sort repeatedly compares and swaps adjacent elements, moving the largest values to the end over multiple passes. It has a complexity of O(n^2). 2) Insertion sort inserts elements one by one into the sorted portion of the array by shifting elements and comparing. It is O(n^2) in worst case but O(n) if nearly sorted. 3) Selection sort finds the minimum element and swaps it into the first position in each pass to build the sorted array. It has complexity O(n^2). 4) Merge sort divides the array into halves recursively, then merges the sorted halves to produce the fully sorted array.

Sorting algorithums > Data Structures & AlgorithumsAin-ul-Moiz Khawaja

The document discusses sorting algorithms including bubble sort, selection sort, insertion sort, and merge sort. It provides pseudocode and explanations of how each algorithm works. Bubble sort, selection sort, and insertion sort have O(n2) runtime and are best for small datasets, while merge sort uses a divide-and-conquer approach to sort arrays with O(n log n) runtime, making it more efficient for large datasets. Radix sort is also discussed as an alternative sorting method that is optimized for certain data types.

DSA_chapter and chapter 3 _03_Sorting Algorithms.pptxtahliildhoore54

Data Structure and algorithms for softwareManishShukla712917

DSA-sortijejjejjdjjdjdjjsjsjsjsjsjsjng.pptxsuryatom5775

Sorting algorithmsCHANDAN KUMAR

This document provides an overview of sorting algorithms. It defines sorting as arranging data in a particular order like ascending or descending. Common sorting algorithms discussed include bubble sort, selection sort, insertion sort, merge sort, and quick sort. For each algorithm, the working method, implementation in C, time and space complexity is explained. The document also covers sorting terminology like stable vs unstable sorting and adaptive vs non-adaptive algorithms. Overall, the document serves as a comprehensive introduction to sorting and different sorting techniques.

Sorting method data structuresunilchute1

This document discusses bubble sort, selection sort, and insertion sort algorithms. It provides descriptions of how each algorithm works, including pseudocode examples. Bubble sort compares adjacent element pairs and swaps them if out of order, taking Ο(n2) time. Selection sort finds the minimum element and swaps it into the sorted portion of the array in each pass. Insertion sort maintains a sorted sub-list, inserting new elements in the appropriate place to build the full sorted list.

Sorting algorithmMuhammad Farhan

The document discusses four sorting algorithms: selection sort, bubble sort, insertion sort, and merge sort. It provides pseudocode for the selection sort algorithm and describes how it works by making successive passes through an array and swapping elements until the array is fully sorted. Bubble sort and insertion sort are also described as making multiple passes through an array, comparing and swapping adjacent elements until the array is in order. Pseudocode is provided for the bubble sort and insertion sort algorithms.

Sorting pnkpinakspatel

The document discusses and compares several sorting algorithms: bubble sort, selection sort, insertion sort, merge sort, and quick sort. For each algorithm, it provides an explanation of how the algorithm works, pseudocode for the algorithm, and an analysis of the time complexity. The time complexities discussed are: Bubble sort: O(N^2) in worst case, O(N) in best case Selection sort: O(N^2) Insertion sort: O(N^2) in worst case, O(N) in best case Merge sort: O(N log N) Quick sort: O(N log N) on average

ds 3Sorting.pptAlliVinay1

Unit vii sorting Tribhuvan University

Unit 7 sortingDabbal Singh Mahara

L 14-ct1120Zia Ush Shamszaman

SortingZaid Shabbir

Data structure.pptxSajalFayyaz

Data Structure (MC501)Kamal Singh Lodhi

Lecture 13 data structures and algorithmsAakash deep Singhal

Different Searching and Sorting Methods.pptxMinakshee Patil

BUBBLESORT Ashish Sadavarti

358 33 powerpoint-slides_14-sorting_chapter-14sumitbardhan

Sorting algorithums > Data Structures & AlgorithumsAin-ul-Moiz Khawaja

DSA_chapter and chapter 3 _03_Sorting Algorithms.pptxtahliildhoore54

Data Structure and algorithms for softwareManishShukla712917

DSA-sortijejjejjdjjdjdjjsjsjsjsjsjsjng.pptxsuryatom5775

Sorting algorithmsCHANDAN KUMAR

Sorting method data structuresunilchute1

Sorting algorithmMuhammad Farhan

Sorting pnkpinakspatel

More from ManishPrajapati78 (14)

Data Structure and Algorithms Binary Search TreeManishPrajapati78

Binary search trees (BSTs) are data structures that allow for efficient searching, insertion, and deletion. Nodes in a BST are organized so that all left descendants of a node are less than the node's value and all right descendants are greater. This property allows values to be found, inserted, or deleted in O(log n) time on average. Searching involves recursively checking if the target value is less than or greater than the current node's value. Insertion follows the search process and adds the new node in the appropriate place. Deletion handles three cases: removing a leaf, node with one child, or node with two children.

Data Structure and Algorithms Binary TreeManishPrajapati78

This document discusses binary trees and their traversal. It defines binary trees, their properties such as levels and degrees of nodes. It describes different types of binary trees like complete, skewed, etc. It also explains different traversal techniques like preorder, inorder and postorder traversals and provides algorithms to implement these traversals recursively as well as using stacks. Memory representations of binary trees like sequential and linked are also summarized.

Data Structure and Algorithms QueuesManishPrajapati78

This document discusses queues and related data structures. It defines a queue as a first-in, first-out collection where items can be inserted at the rear and deleted from the front. Algorithms for array and linked list implementations of queues are presented for insertion and deletion operations. Priority queues are described as ordered queues where the highest or lowest priority item is always at the front. Deques allow insertion and deletion from both ends and are more versatile than regular queues or stacks.

Data Structure and Algorithms The Tower of HanoiManishPrajapati78

The document describes the Tower of Hanoi puzzle, which involves moving disks of different sizes between three pegs according to rules of only moving one disk at a time and never placing a larger disk on top of a smaller one. It provides an algorithm and recursive solution for solving the puzzle by moving disks from the source peg to the auxiliary peg and then to the destination peg. The number of minimum moves needed to solve the puzzle for n disks is 2^n - 1. For example, 4 disks requires 15 moves.

Data Structure and Algorithms StacksManishPrajapati78

The document introduces stacks and their operations. It defines a stack as a last-in, first-out data structure that can only be accessed at one end. The key stack operations are push, which adds an item to the top, and pop, which removes an item from the top. It provides examples of stack representations using arrays and linked lists, and algorithms for implementing push and pop. The document also discusses postfix notation for arithmetic expressions and algorithms for evaluating expressions in postfix notation using a stack.

Data Structure and Algorithms Linked ListManishPrajapati78

The document discusses different types of linked lists including: - Singly linked lists that can only be traversed in one direction. - Doubly linked lists that allow traversal in both directions using forward and backward pointers. - Circular linked lists where the last node points back to the first node allowing continuous traversal. - Header linked lists that include a header node at the beginning for simplified insertion and deletion. Header lists can be grounded where the last node contains a null pointer or circular where the last node points to the header. - Two-way or doubly linked lists where each node contains a forward and backward pointer allowing bidirectional traversal through the list.

Data Structure and Algorithms ArraysManishPrajapati78

Data Structure and Algorithms ManishPrajapati78

Data Structure and Algorithms HashingManishPrajapati78

The document discusses hashing techniques for storing and retrieving data from memory. It covers hash functions, hash tables, open addressing techniques like linear probing and quadratic probing, and closed hashing using separate chaining. Hashing maps keys to memory addresses using a hash function to store and find data independently of the number of items. Collisions may occur and different collision resolution methods are used like open addressing that resolves collisions by probing in the table or closed hashing that uses separate chaining with linked lists. The efficiency of hashing depends on factors like load factor and average number of probes.

Data Structure and Algorithms Graph TraversalManishPrajapati78

The document describes depth-first search (DFS) and breadth-first search (BFS) graph traversal algorithms. DFS uses a stack and processes each node by first exploring all of its neighbor nodes before backtracking, while BFS uses a queue and processes nodes level-by-level from the starting node outwards. Both algorithms initialize all nodes as ready, process nodes by changing their status, and add neighboring ready nodes to the stack/queue to change their status to waiting.

Data Structure and Algorithms GraphsManishPrajapati78

Data Structure and Algorithms Huffman Coding AlgorithmManishPrajapati78

Huffman coding is a statistical compression technique that assigns variable-length codes to characters based on their frequency of occurrence. It builds a Huffman tree by prioritizing characters from most to least frequent, then assigns codes by traversing the tree left for 0 and right for 1. This results in shorter codes for more common characters, compressing text files into fewer bits than standard ASCII encoding. The receiver reconstructs the same Huffman tree to decode the bitstream back into the original text.

Data Structure and Algorithms Heaps and TreesManishPrajapati78

The document discusses heaps and heapsort. It defines max heaps and min heaps as complete binary trees where each node's key is greater than or less than its children's keys. It describes operations on heaps like insertion, deletion of the max/min element, and creation of an empty heap. Algorithms for insertion and deletion into max heaps are provided. Heapsort is described as building a max heap of the input array and then repeatedly extracting the max element to sort the array.

Data Structure and Algorithms AVL TreesManishPrajapati78

The document discusses balanced binary search trees, specifically AVL trees. It explains that AVL trees ensure the height of the tree remains O(log N) during insertions and deletions by enforcing that the heights of all nodes' left and right subtrees differ by at most 1. The document outlines the process for inserting and deleting nodes from an AVL tree, which may require rotations to restore balance. Rotations are classified based on the position of inserted/deleted nodes and include left-left, left-right, right-right, and right-left varieties.

Data Structure and Algorithms Binary Search TreeManishPrajapati78

Data Structure and Algorithms Binary TreeManishPrajapati78

Data Structure and Algorithms QueuesManishPrajapati78

Data Structure and Algorithms The Tower of HanoiManishPrajapati78

Data Structure and Algorithms StacksManishPrajapati78

Data Structure and Algorithms Linked ListManishPrajapati78

Data Structure and Algorithms ArraysManishPrajapati78

Data Structure and Algorithms ManishPrajapati78

Data Structure and Algorithms HashingManishPrajapati78

Data Structure and Algorithms Graph TraversalManishPrajapati78

Data Structure and Algorithms GraphsManishPrajapati78

Data Structure and Algorithms Huffman Coding AlgorithmManishPrajapati78

Data Structure and Algorithms Heaps and TreesManishPrajapati78

Data Structure and Algorithms AVL TreesManishPrajapati78

Recently uploaded (20)

SAP PM Module Level-IV Training Complete.pptMuhammadShaheryar36

Wondershare PDFelement Pro 11.4.20.3548 Crack Free DownloadPuppy jhon

Software Engineering Process, Notation & Tools Introduction - Part 3Gaurav Sharma

Shell Skill Tree - LabEx Certification (LabEx)VICTOR MAESTRE RAMIREZ

Neuralink Templateeeeeeeeeeeeeeeeeeeeeeeeeealexandernoetzold

Smart Financial Solutions: Money Lender Software, Daily Pigmy & Personal Loan...Intelli grow

How to Choose the Right Web Development Agency.pdfCreative Fosters

Choosing the right web development agency is key to building a powerful online presence. This detailed guide from Creative Fosters helps you evaluate agencies based on experience, portfolio, technical skills, communication, and post-launch support. Whether you're launching a new site or revamping an old one, these expert tips will ensure you find a reliable team that understands your vision and delivers results. Avoid common mistakes and partner with an agency that aligns with your goals and budget.

Smadav Pro 2025 Rev 15.4 Crack Full Version With Registration Keyjoybepari360

Application Modernization with Choreo - The AI-Native Internal Developer Plat...WSO2

Artificial Intelligence Applications Across IndustriesSandeepKS52

Artificial Intelligence is a rapidly growing field that influences many aspects of modern life, including transportation, healthcare, and finance. Understanding the basics of AI provides insight into how machines can learn and make decisions, which is essential for grasping its applications in various industries. In the automotive sector, AI enhances vehicle safety and efficiency through advanced technologies like self-driving systems and predictive maintenance. Similarly, in healthcare, AI plays a crucial role in diagnosing diseases and personalizing treatment plans, while in financial services, it helps in fraud detection and risk management. By exploring these themes, a clearer picture of AI's transformative impact on society emerges, highlighting both its potential benefits and challenges.

Women in Tech: Marketo Engage User Group - June 2025 - AJO with AWSBradBedford3

Creating meaningful, real-time engagement across channels is essential to building lasting business relationships. Discover how AWS, in collaboration with Deloitte, set up one of Adobe's first instances of Journey Optimizer B2B Edition to revolutionize customer journeys for B2B audiences. This session will share the use cases the AWS team has the implemented leveraging Adobe's Journey Optimizer B2B alongside Marketo Engage and Real-Time CDP B2B to deliver unified, personalized experiences and drive impactful engagement. They will discuss how they are positioning AJO B2B in their marketing strategy and how AWS is imagining AJO B2B and Marketo will continue to work together in the future. Whether you’re looking to enhance customer journeys or scale your B2B marketing efforts, you’ll leave with a clear view of what can be achieved to help transform your own approach. Speakers: Britney Young Senior Technical Product Manager, AWS Erine de Leeuw Technical Product Manager, AWS

OpenTelemetry 101 Cloud Native BarcelonaImma Valls Bernaus

Automated Migration of ESRI Geodatabases Using XML Control Files and FMESafe Software

Efficient data migration is a critical challenge in geospatial data management, especially when working with complex data structures. This presentation explores an automated approach to migrating ESRI Geodatabases using FME and XML-based control files. A key advantage of this method is its adaptability: changes to the data model are seamlessly incorporated into the migration process without requiring modifications to the underlying FME workflow. By separating data model definitions from migration logic, this approach ensures flexibility, reduces maintenance effort, and enhances scalability.

dp-700 exam questions sample docume .pdfpravkumarbiz

Meet You in the Middle: 1000x Performance for Parquet Queries on PB-Scale Dat...Alluxio, Inc.

Alluxio Webinar June 10, 2025 For more Alluxio Events: https://www.alluxio.io/events/ Speaker: David Zhu (Engineering Manager @ Alluxio) Storing data as Parquet files on cloud object storage, such as AWS S3, has become prevalent not only for large-scale data lakes but also as lightweight feature stores for training and inference, or as document stores for Retrieval-Augmented Generation (RAG). However, querying petabyte-to-exabyte-scale data lakes directly from S3 remains notoriously slow, with latencies typically ranging from hundreds of milliseconds to several seconds. In this webinar, David Zhu, Software Engineering Manager at Alluxio, will present the results of a joint collaboration between Alluxio and a leading SaaS and data infrastructure enterprise that explored leveraging Alluxio as a high-performance caching and acceleration layer atop AWS S3 for ultra-fast querying of Parquet files at PB scale. David will share: - How Alluxio delivers sub-millisecond Time-to-First-Byte (TTFB) for Parquet queries, comparable to S3 Express One Zone, without requiring specialized hardware, data format changes, or data migration from your existing data lake. - The architecture that enables Alluxio’s throughput to scale linearly with cluster size, achieving one million queries per second on a modest 50-node deployment, surpassing S3 Express single-account throughput by 50x without latency degradation. - Specifics on how Alluxio offloads partial Parquet read operations and reduces overhead, enabling direct, ultra-low-latency point queries in hundreds of microseconds and achieving a 1,000x performance gain over traditional S3 querying methods.

AI-Powered Compliance Solutions for Global Regulations | Certivocertivoai

Certivo offers AI-powered compliance solutions designed to help businesses in the USA, EU, and UK simplify complex regulatory demands. From environmental and product compliance to safety, quality, and sustainability, our platform automates supplier documentation, manages certifications, and integrates with ERP/PLM systems. Ensure seamless RoHS, REACH, PFAS, and Prop 65 compliance through predictive insights and multilingual support. Turn compliance into a competitive edge with Certivo’s intelligent, scalable, and audit-ready platform.

DevOps for AI: running LLMs in production with Kubernetes and KubeFlowAarno Aukia

Software Testing & it’s types (DevOps)S Pranav (Deepu)

NTRODUCTION TO SOFTWARE TESTING • Definition: • Software testing is the process of evaluating and verifying that a software application or system meets specified requirements and functions correctly. • Purpose: • Identify defects and bugs in the software. • Ensure the software meets quality standards. • Validate that the software performs as intended in various scenarios. • Importance: • Reduces risks associated with software failures. • Improves user satisfaction and trust in the product. • Enhances the overall reliability and performance of the software

Making significant Software Architecture decisionsBert Jan Schrijver

Who will create the languages of the future?Jordi Cabot

Will future languages be created by language engineers? Can you "vibe" a DSL? In this talk, we will explore the changing landscape of language engineering and discuss how Artificial Intelligence and low-code/no-code techniques can play a role in this future by helping in the definition, use, execution, and testing of new languages. Even empowering non-tech users to create their own language infrastructure. Maybe without them even realizing.

SAP PM Module Level-IV Training Complete.pptMuhammadShaheryar36

Wondershare PDFelement Pro 11.4.20.3548 Crack Free DownloadPuppy jhon

Software Engineering Process, Notation & Tools Introduction - Part 3Gaurav Sharma

Shell Skill Tree - LabEx Certification (LabEx)VICTOR MAESTRE RAMIREZ

Neuralink Templateeeeeeeeeeeeeeeeeeeeeeeeeealexandernoetzold

Smart Financial Solutions: Money Lender Software, Daily Pigmy & Personal Loan...Intelli grow

How to Choose the Right Web Development Agency.pdfCreative Fosters

Smadav Pro 2025 Rev 15.4 Crack Full Version With Registration Keyjoybepari360

Application Modernization with Choreo - The AI-Native Internal Developer Plat...WSO2

Artificial Intelligence Applications Across IndustriesSandeepKS52

Women in Tech: Marketo Engage User Group - June 2025 - AJO with AWSBradBedford3

OpenTelemetry 101 Cloud Native BarcelonaImma Valls Bernaus

Automated Migration of ESRI Geodatabases Using XML Control Files and FMESafe Software

dp-700 exam questions sample docume .pdfpravkumarbiz

Meet You in the Middle: 1000x Performance for Parquet Queries on PB-Scale Dat...Alluxio, Inc.

AI-Powered Compliance Solutions for Global Regulations | Certivocertivoai

DevOps for AI: running LLMs in production with Kubernetes and KubeFlowAarno Aukia

Software Testing & it’s types (DevOps)S Pranav (Deepu)

Making significant Software Architecture decisionsBert Jan Schrijver

Who will create the languages of the future?Jordi Cabot

Data Structure and Algorithms Sorting

1. Bubble sort Insertion sort Selection sort

2. Sorting Algorithm Sorting takes an unordered collection and makes it an ordered one. 2 512354277 101 5 12 35 42 77 101 1 2 3 4 5 6 1 2 3 4 5 6

3. "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pairwise comparisons and swapping 3 512354277 101 1 2 3 4 5 6

4. "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pairwise comparisons and swapping 4 512354277 101Swap42 77 1 2 3 4 5 6

5. "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pairwise comparisons and swapping 5 512357742 101Swap35 77 1 2 3 4 5 6

6. "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pairwise comparisons and swapping 6 512773542 101Swap12 77 1 2 3 4 5 6

7. "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pairwise comparisons and swapping 7 577123542 101 No need to swap 1 2 3 4 5 6

8. "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pairwise comparisons and swapping 8 577123542 101 Swap5 101 1 2 3 4 5 6

9. "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using pairwise comparisons and swapping 9 77123542 5 101 Largest value correctly placed 1 2 3 4 5 6

10. Repeat “Bubble Up” How Many Times? If we have N elements… And if each time we bubble an element, we place it in its correct location… Then we repeat the “bubble up” process N – 1 times. This guarantees we’ll correctly place all N elements. 10

11. “Bubbling” All the Elements 11 77123542 5 101 5421235 77 101 4253512 77 101 4235512 77 101 4235125 77 101 N-1 1 2 3 4 5 6

12. Bubble Sort Algorithm for i  1 to n-1 do for j  1 to n-i do if (A[j+1] < A[j]) swap A[j] and A[j+1] ; } } Analysis: In general, if the list has n elements, we will have to do (n-1) + (n-2) …. + 2 +1 = (n-1) n / 2 comparisons. =O(n^2) 12

13. Insertion Sort INSERTION_SORT (A, N) 1.Set A[0] = -∞. 2.Repeat Step 3 to 5 for K = 2, 3, …, N: 3. Set TEMP = A[K] and PTR = K – 1. 4. Repeat while TEMP < A[PTR]: (a) Set A[PTR+1] = A[PTR] (b) Set PTR = PTR – 1. [End of Loop.] 5. Set A[PTR+1] = TEMP. [End of Loop 2.] 6.Return.

14. Insertion Sort Example Sort: 34 8 64 51 32 21 34 8 64 51 32 21 The algorithm sees that 8 is smaller than 34 so it swaps. 8 34 64 51 32 21 51 is smaller than 64, so they swap. 8 34 51 64 32 21 8 34 51 64 32 21 (from previous slide) The algorithm sees 32 as another smaller number and moves it to its appropriate location between 8 and 34. 8 32 34 51 64 21 The algorithm sees 21 as another smaller number and moves into between 8 and 32. Final sorted numbers: 8 21 32 34 51 64

15. Insertion Sort Complexity This Sorting algorithm is frequently used when n is very small. Worst case occurs when array is in reverse order. The inner loop must use K – 1 comparisons. f(n) = 1 + 2 + 3 + ….+ (n – 1) = n(n – 1)/2 = O(n2 ) In average case, there will be approximately (K – 1)/2 comparisons in the inner loop. f(n) = (1 + 2 + 3 + ….+ (n – 1))/2 = n(n – 1)/4 = O(n2 )

16. Selection Sort This algorithm sorts an array A with N elements. SELECTION(A, N) 1.Repeat steps 2 and 3 for k=1 to N-1: 2. Call MIN(A, K, N, LOC). 3. [Interchange A[k] and A[LOC]] Set Temp:= A[k], A[k]:= A[LOC] and A[LOC]:=Temp. [End of step 1 Loop.] 1.Exit. MIN(A, K, N, LOC). 1.Set MIN := A[K] and LOC:= K. 2.Repeat for j=k+1 to N: If Min>A[j], then: Set Min:= A[j] and LOC:=J. [End of if structure] 3.Return.

17. Selection Sort Example 1329648 8329641 8349621 8649321 8964321 8694321 9864321 9864321

18. Selection Sort Complexity The number f(n) of comparisons in selection sort algorithm is independent of original order of elements. There are n-1 comparisons during pass 1 to find the smallest element, n-2 comparisons during pass 2 to find the second smallest element, and so on. Accordingly, f (n) = (n-1)+(n-2)+-----+2+1 = n(n-1)/2 = O(n2 ) The f (n) holds the same value O(n2 ) both for worst case and average case.

19. Comparing the Algorithms Best Average Worst Case Case Case Bubble Sort O(n) O(n2 ) O(n2 ) Insertion Sort O(n) O(n2 ) O(n2 ) Selection Sort O(n2 ) O(n2 ) O(n2 )

20. Thank You

Data Structure and Algorithms Sorting

Recommended

More Related Content

What's hot (20)

Similar to Data Structure and Algorithms Sorting (20)

More from ManishPrajapati78 (14)

Recently uploaded (20)

Data Structure and Algorithms Sorting