Lecture 3 data structures & algorithms - sorting techniques - http://techieme.in
0 likes2,085 views
This document provides a 90-minute discussion on algorithms including quicksort, order statistics, searching, and substring searching. It begins with an overview of the topics and then provides details on quicksort, including the divide and conquer approach and partitioning elements around a pivot. It also describes algorithms for order statistics to find the kth smallest element, binary search, and a basic substring searching approach. Special cases and better solutions like Boyer-Moore are also mentioned.
1 of 13
Downloaded 48 times
![Partition(A, p, q) //A[p , q]
X ← A[p]
i ← p
for j ← p+1 to q
do if A[j] <= x
then i ← i+1
exchange A[i] ↔ A[j]
exchange A[p] ↔ A[i];
return i
4
A
p qi j](https://image.slidesharecdn.com/lecture3-datastructuresalgorithms-sortingtechniques-130521015559-phpapp01/85/Lecture-3-data-structures-algorithms-sorting-techniques-http-techieme-in-4-320.jpg)
![Algorithm:
OrderStat(A,p,q,k) // means kth smallest number in A between
index p and q
if p==q
return A[p]
r <- Partition(A,p,q)
i <- r – p + 1;
if k == i
return A[r]
if k < i
return OrderStat(A,p,r-1,k)
else
return OrderStat(A,r+1,q,k-i)
8](https://image.slidesharecdn.com/lecture3-datastructuresalgorithms-sortingtechniques-130521015559-phpapp01/85/Lecture-3-data-structures-algorithms-sorting-techniques-http-techieme-in-8-320.jpg)
![Searching:
Basic Idea: In an array A[a1,a2,a3,a4,…,an] find the index k
such that p = A[k]
Naïve Solution: Traverse through the array in a loop and
compare each element with the given number. If the number
matches, return the index of the number else return null.
Algorithm:
Search (A[1.. n], p)
for i<- 1 to n
do if A[i] == p
return i
return null
9](https://image.slidesharecdn.com/lecture3-datastructuresalgorithms-sortingtechniques-130521015559-phpapp01/85/Lecture-3-data-structures-algorithms-sorting-techniques-http-techieme-in-9-320.jpg)
![Searching:
Basic Idea: In an array A[a1,a2,a3,a4,…,an] find the index k such
that p = A[k]
Binary Search Solution: Only if the array is sorted. Divide it into two
halves, check the element at the center, if it is less than what we
are searching, look into the upper half else look into the lower
half. Repeat till you find the number or the array exhausts.
Algorithm:
BinarySearch (A, p, low,high)
middle = (low+high)/2
if A[middle] == p
return middle;
else if A[middle] > p
return BinarySearch(A, p, low, middle-1)
else
return BinarySearch(A,p,middle+1,high)
10](https://image.slidesharecdn.com/lecture3-datastructuresalgorithms-sortingtechniques-130521015559-phpapp01/85/Lecture-3-data-structures-algorithms-sorting-techniques-http-techieme-in-10-320.jpg)
![Special Case Substring Searching:
Basic Idea: In a character string search a substring and return the index of first occurrence.
Naive Solution: Start from the first index of both the strings, compare the characters, if
character matches, compare the next character and so on till the substring exhausts.
Return the start index of the substring in the main string.
Algorithm:
SubStringSearch (S, sb)
j=0;
match = false;
while i < S.length or j < sb.length
if S[i] == sb[j]
match = true
i++, j++
else
match = false
j=0, i++
if match == true and j = sb.length
return i-sb.length
else
return -1
11](https://image.slidesharecdn.com/lecture3-datastructuresalgorithms-sortingtechniques-130521015559-phpapp01/85/Lecture-3-data-structures-algorithms-sorting-techniques-http-techieme-in-11-320.jpg)
Ad
Recommended
sorting algorithm graphical method 
sorting algorithm graphical method Shantanu Mishra This document describes and compares several common sorting algorithms, including bubble sort, selection sort, and insertion sort. It provides pseudocode examples to illustrate how each algorithm works and analyzes their time complexities. Specifically, it shows the steps to sort sample data using each algorithm through multiple iterations and compares their performance, with bubble, selection, and insertion sorts having O(n2) time and others like merge and quicksort having O(n log n) time.
Hub 102 - Lesson 5 - Algorithm: Sorting & Searching
Hub 102 - Lesson 5 - Algorithm: Sorting & SearchingTiểu Hổ This document discusses algorithms for sorting and searching. It introduces algorithm analysis and why it is important to analyze algorithms to compare different solutions, predict performance, and set parameter values. It discusses analyzing running time by counting primitive operations as a function of input size. Common growth rates like linear, quadratic, and cubic functions are introduced. Big-O notation is explained as a way to classify algorithms by their worst-case running time. Several specific sorting algorithms are described, including bubble sort, insertion sort, merge sort, and quicksort. Their pseudocode and running times are analyzed. Graph traversal algorithms like depth-first search and breadth-first search are also introduced.
Sorting Algorithms
Sorting Algorithmsmultimedia9 The document discusses several sorting algorithms and their time complexities:
- Bubble sort, insertion sort, and selection sort have O(n^2) time complexity.
- Quicksort uses a divide-and-conquer approach and has O(n log n) time complexity on average but can be O(n^2) in the worst case.
- Heapsort uses a heap data structure and has O(n log n) time complexity.
Sorting Seminar Presentation by Ashin Guha Majumder
Sorting Seminar Presentation by Ashin Guha MajumderAshin Guha Majumder This is a seminar presentation on "SORTING" for Semester 2 exam at St. Xavier's College.The power point presenation deals with the requirement of sorting in our life,types of sorting techniques,code for implementing them,the time and space complexity of different sorting algorithms,the applications of sorting,its use in the industry and its future scope.The slide show contains .gif files which can't be seen here.For more details or any queries send me a mail at [email protected]
Sorting algorithms
Sorting algorithmsEleonora Ciceri Sorting algorithms in C++
An introduction to sorting algorithm, with details on bubble sort and merge sort algorithms
Computer science principles course
Data Structures - Searching & sorting
Data Structures - Searching & sortingKaushal Shah It is a presentation on some Searching and Sorting Techniques for Computer Science.
It consists of the following techniques:
Sequential Search
Binary Search
Selection Sort
Bubble Sort
Insertion Sort
Sorting
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.
Sorting algorithms
Sorting algorithmsTrupti Agrawal The document discusses various sorting algorithms. It describes how sorting algorithms arrange elements of a list in a certain order. Efficient sorting is important as a subroutine for algorithms that require sorted input, such as search and merge algorithms. Common sorting algorithms covered include insertion sort, selection sort, bubble sort, merge sort, and quicksort. Quicksort is highlighted as an efficient divide and conquer algorithm that recursively partitions elements around a pivot point.
Sorting
SortingGhaffar Khan The document discusses various sorting algorithms including selection sort, insertion sort, merge sort, quick sort, heap sort, and external sort. It provides descriptions of each algorithm, examples of how they work, and discusses implementation in languages like C++. Key steps and properties of each algorithm are outlined. Implementation details like pseudocode and functions are also described.
Chapter 14 Searching and Sorting
Chapter 14 Searching and SortingMuhammadBakri13 This document discusses various sorting algorithms including merge sort. It begins with an introduction to sorting and searching. It then provides pseudocode for the merge sort algorithm which works by dividing the array into halves, recursively sorting the halves, and then merging the sorted halves back together. An example is provided to illustrate the merge sort process. Key steps include dividing, conquering by recursively sorting subarrays, and combining through merging. The overall time complexity of merge sort is O(n log n).
Sorting ppt
Sorting pptHassan Mustafa This Presentation includes different types of sorting and there introduction as well as their algorithm in data structure
Insertion sort
Insertion sortDorina Isaj Insertion sort is an algorithm that iterates through an array, comparing each element to its predecessor and swapping the two if out of order, until the entire array is sorted from lowest to highest value. It is more efficient than bubble sort because it requires fewer element comparisons. While slower than quick sort, heap sort, or merge sort for large arrays, insertion sort performs well for small or nearly-sorted data sets due to its simple implementation requiring only O(n) time at best case. Pseudocode and Java code are provided as examples.
Searching & Sorting Algorithms
Searching & Sorting AlgorithmsRahul Jamwal The document discusses several sorting algorithms: selection sort, bubble sort, quicksort, and merge sort. Selection sort has linear time complexity for swaps but quadratic time for comparisons. Bubble sort is quadratic time for both swaps and comparisons, making it the least efficient. Quicksort and merge sort are the fastest algorithms, both with logarithmic time complexity of O(n log n) for swaps and comparisons. Quicksort risks quadratic behavior in the worst case if pivots are chosen poorly, while merge sort requires more data copying between temporary and full lists.
Sorting Algorithms
Sorting AlgorithmsMohammed Hussein This document discusses different sorting algorithms including bubble sort, insertion sort, and selection sort. It provides details on each algorithm, including time complexity, code examples, and graphical examples. Bubble sort is an O(n2) algorithm that works by repeatedly comparing and swapping adjacent elements. Insertion sort also has O(n2) time complexity but is more efficient than bubble sort for small or partially sorted lists. Selection sort finds the minimum value and swaps it into place at each step.
Best,worst,average case .17581556 045
Best,worst,average case .17581556 045university of Gujrat, pakistan 1. Several sorting algorithms are compared including quicksort, heapsort, mergesort, insertion sort, selection sort, and bubble sort.
2. For most algorithms, the best, average, and worst case time complexities are listed as O(n log(n)), O(n log(n)), and O(n^2) respectively except for some cases like selection sort and bubble sort that have average and worst case complexities of O(n^2).
3. For space complexity, many algorithms have worst case complexities of O(n) except for mergesort which uses additional space and has a worst case complexity of O(n).
Divide and conquer 1
Divide and conquer 1Kumar Binary search is an algorithm for finding an element in a sorted array. It works by recursively checking the middle element, dividing the array in half, and searching only one subarray. The time complexity is O(log n) as the array is divided in half in each step.
Binary Search - Design & Analysis of Algorithms
Binary Search - Design & Analysis of AlgorithmsDrishti Bhalla Binary search is an efficient algorithm for finding a target value within a sorted array. It works by repeatedly dividing the search range in half and checking the value at the midpoint. This eliminates about half of the remaining candidates in each step. The maximum number of comparisons needed is log n, where n is the number of elements. This makes binary search faster than linear search, which requires checking every element. The algorithm works by first finding the middle element, then checking if it matches the target. If not, it recursively searches either the lower or upper half depending on if the target is less than or greater than the middle element.
(Data Structure) Chapter11 searching & sorting
(Data Structure) Chapter11 searching & sortingFadhil Ismail The document summarizes sorting and searching algorithms. It describes linear and binary search algorithms and analyzes their performance. It also describes selection sort, bubble sort, and heapsort algorithms. Selection sort has O(n^2) performance while bubble sort and heapsort have comparable performance to selection sort. Heapsort improves on these and has O(nlogn) performance by using a heap data structure implemented as an array.
Counting sort(Non Comparison Sort)
Counting sort(Non Comparison Sort)Hossain Md Shakhawat Comparison sorting algorithms work by making pairwise comparisons between elements to determine the order in a sorted list. They have a lower bound of Ω(n log n) time complexity due to needing to traverse a decision tree with a minimum of n log n comparisons. Counting sort is a non-comparison sorting algorithm that takes advantage of key assumptions about the data to count and place elements directly into the output array in linear time O(n+k), where n is the number of elements and k is the range of possible key values.
Lect11 Sorting
Lect11 Sortingryokollll This document provides a summary of a lecture on sorting algorithms:
1) It introduces sorting concepts and sorting problems. Common sorting algorithms discussed include selection sort, insertion sort, merge sort, and quick sort.
2) Selection sort and insertion sort algorithms are explained in detail with examples. Selection sort has a running time of O(n^2) in all cases.
3) Insertion sort's running time depends on how sorted the input array is - it is O(n) for a presorted array but O(n^2) for a reverse sorted array.
4) The time complexity of both algorithms is analyzed mathematically. Selection sort is always O(n^2) while
Searching algorithms
Searching algorithmsTrupti Agrawal The document discusses different types of searching algorithms. It describes sequential search which searches an unsorted list sequentially until the target item is found or the entire list is searched. The average runtime is O(n) as the item could be anywhere in the list. Binary search is described as more efficient for sorted lists, repeatedly dividing the search space in half and comparing the target to the middle element. Indexes are also summarized, including clustered vs unclustered indexes and different approaches to storing data entries.
Chapter 11 - Sorting and Searching
Chapter 11 - Sorting and SearchingEduardo Bergavera The document discusses various searching and sorting algorithms. It describes linear search, binary search, selection sort, bubble sort, and heapsort. For each algorithm, it provides pseudocode examples and analyzes their performance in terms of number of comparisons required in the worst case. Linear search requires N comparisons in the worst case, while binary search requires log N comparisons. Selection sort and bubble sort both require approximately N^2 comparisons, while heapsort requires 1.5NlogN comparisons.
Sorting Algorithms
Sorting AlgorithmsPranay Neema This document discusses various sorting algorithms and their complexities. It begins by defining an algorithm and complexity measures like time and space complexity. It then defines sorting and common sorting algorithms like bubble sort, selection sort, insertion sort, quicksort, and mergesort. For each algorithm, it provides a high-level overview of the approach and time complexity. It also covers sorting algorithm concepts like stable and unstable sorting. The document concludes by discussing future directions for sorting algorithms and their applications.
Insertion sort
Insertion sortLovely Professional University Insertion sort is a simple sorting algorithm that builds the final sorted array (or list) one item at a time. It is much less efficient on large lists than more advanced algorithms such as quicksort, heapsort, or merge sort. However, insertion sort provides several advantages:
Data Structures- Part4 basic sorting algorithms
Data Structures- Part4 basic sorting algorithmsAbdullah Al-hazmy The document discusses various sorting algorithms. It begins by explaining the motivation for sorting and providing examples. It then lists some common sorting algorithms like bubble sort, selection sort, and insertion sort. For each algorithm, it provides an informal description, works through examples to show how it sorts a list, and includes Java code implementations. It compares the time complexity of these algorithms, which is O(n2) for bubble sort, selection sort, and insertion sort, and explains why. The document aims to introduce fundamental sorting algorithms and their workings.
Algorithm & data structures lec4&5
Algorithm & data structures lec4&5Abdul Khan The document summarizes different searching and sorting algorithms. It discusses linear search and binary search for searching algorithms. It explains that linear search has O(n) time complexity while binary search has O(log n) time complexity. For sorting algorithms, it describes bubble sort, selection sort, and insertion sort. It provides pseudocode to illustrate how each algorithm works to sort a list or array.
Binary search 
Binary search Raghu nath The document describes the binary search algorithm for searching a sorted array. It has a time complexity of O(Logn) compared to linear search which is O(n). Binary search works by comparing the target value to the middle element of the array and recursively searching either the left or right half depending on if the target is less than or greater than the middle element. Implementations of both recursive and iterative binary search in C are provided.
Quicksort
QuicksortGayathri Gaayu The document discusses various sorting algorithms and their analysis. It begins by explaining insertion sort and analyzing its best, worst, and average cases. It then discusses the concept of inversions and how they relate to sorting complexity. Other algorithms covered include bubble sort, merge sort, quicksort, quickselect, bucket sort, radix sort, and external sorting. A key takeaway is that quicksort and mergesort run in O(n log n) time on average, which is optimal for comparisons-based sorting. External sorting can sort data that does not fit in memory.
Lecture 2c stacks
Lecture 2c stacksVictor Palmar A stack is a linear data structure that follows the last-in, first-out (LIFO) principle. Elements can only be inserted or removed from one end, called the top. Common stack operations include push, which adds an element to the top, and pop, which removes the top element. Stacks have many applications, such as evaluating mathematical expressions, interrupt handling in computing, and temporary storage in stack machines. They can be implemented using either arrays or linked lists.
Lecture 2 data structures & algorithms - sorting techniques
Lecture 2 data structures & algorithms - sorting techniquesDharmendra Prasad This 90-minute discussion covers algorithms, sorting algorithms, and analyzing algorithm performance. It discusses measuring algorithm effectiveness, common sorting algorithms like insertion sort and merge sort, and running time analysis. Insertion sort runs in O(n^2) time in the worst case, while merge sort runs faster in O(n log n) time by dividing the problem into smaller subproblems. Real-world examples of sorting include cable provider personalized services and alphabetical item lists.
More Related Content
What's hot (20)
Sorting
SortingGhaffar Khan The document discusses various sorting algorithms including selection sort, insertion sort, merge sort, quick sort, heap sort, and external sort. It provides descriptions of each algorithm, examples of how they work, and discusses implementation in languages like C++. Key steps and properties of each algorithm are outlined. Implementation details like pseudocode and functions are also described.
Chapter 14 Searching and Sorting
Chapter 14 Searching and SortingMuhammadBakri13 This document discusses various sorting algorithms including merge sort. It begins with an introduction to sorting and searching. It then provides pseudocode for the merge sort algorithm which works by dividing the array into halves, recursively sorting the halves, and then merging the sorted halves back together. An example is provided to illustrate the merge sort process. Key steps include dividing, conquering by recursively sorting subarrays, and combining through merging. The overall time complexity of merge sort is O(n log n).
Sorting ppt
Sorting pptHassan Mustafa This Presentation includes different types of sorting and there introduction as well as their algorithm in data structure
Insertion sort
Insertion sortDorina Isaj Insertion sort is an algorithm that iterates through an array, comparing each element to its predecessor and swapping the two if out of order, until the entire array is sorted from lowest to highest value. It is more efficient than bubble sort because it requires fewer element comparisons. While slower than quick sort, heap sort, or merge sort for large arrays, insertion sort performs well for small or nearly-sorted data sets due to its simple implementation requiring only O(n) time at best case. Pseudocode and Java code are provided as examples.
Searching & Sorting Algorithms
Searching & Sorting AlgorithmsRahul Jamwal The document discusses several sorting algorithms: selection sort, bubble sort, quicksort, and merge sort. Selection sort has linear time complexity for swaps but quadratic time for comparisons. Bubble sort is quadratic time for both swaps and comparisons, making it the least efficient. Quicksort and merge sort are the fastest algorithms, both with logarithmic time complexity of O(n log n) for swaps and comparisons. Quicksort risks quadratic behavior in the worst case if pivots are chosen poorly, while merge sort requires more data copying between temporary and full lists.
Sorting Algorithms
Sorting AlgorithmsMohammed Hussein This document discusses different sorting algorithms including bubble sort, insertion sort, and selection sort. It provides details on each algorithm, including time complexity, code examples, and graphical examples. Bubble sort is an O(n2) algorithm that works by repeatedly comparing and swapping adjacent elements. Insertion sort also has O(n2) time complexity but is more efficient than bubble sort for small or partially sorted lists. Selection sort finds the minimum value and swaps it into place at each step.
Best,worst,average case .17581556 045
Best,worst,average case .17581556 045university of Gujrat, pakistan 1. Several sorting algorithms are compared including quicksort, heapsort, mergesort, insertion sort, selection sort, and bubble sort.
2. For most algorithms, the best, average, and worst case time complexities are listed as O(n log(n)), O(n log(n)), and O(n^2) respectively except for some cases like selection sort and bubble sort that have average and worst case complexities of O(n^2).
3. For space complexity, many algorithms have worst case complexities of O(n) except for mergesort which uses additional space and has a worst case complexity of O(n).
Divide and conquer 1
Divide and conquer 1Kumar Binary search is an algorithm for finding an element in a sorted array. It works by recursively checking the middle element, dividing the array in half, and searching only one subarray. The time complexity is O(log n) as the array is divided in half in each step.
Binary Search - Design & Analysis of Algorithms
Binary Search - Design & Analysis of AlgorithmsDrishti Bhalla Binary search is an efficient algorithm for finding a target value within a sorted array. It works by repeatedly dividing the search range in half and checking the value at the midpoint. This eliminates about half of the remaining candidates in each step. The maximum number of comparisons needed is log n, where n is the number of elements. This makes binary search faster than linear search, which requires checking every element. The algorithm works by first finding the middle element, then checking if it matches the target. If not, it recursively searches either the lower or upper half depending on if the target is less than or greater than the middle element.
(Data Structure) Chapter11 searching & sorting
(Data Structure) Chapter11 searching & sortingFadhil Ismail The document summarizes sorting and searching algorithms. It describes linear and binary search algorithms and analyzes their performance. It also describes selection sort, bubble sort, and heapsort algorithms. Selection sort has O(n^2) performance while bubble sort and heapsort have comparable performance to selection sort. Heapsort improves on these and has O(nlogn) performance by using a heap data structure implemented as an array.
Counting sort(Non Comparison Sort)
Counting sort(Non Comparison Sort)Hossain Md Shakhawat Comparison sorting algorithms work by making pairwise comparisons between elements to determine the order in a sorted list. They have a lower bound of Ω(n log n) time complexity due to needing to traverse a decision tree with a minimum of n log n comparisons. Counting sort is a non-comparison sorting algorithm that takes advantage of key assumptions about the data to count and place elements directly into the output array in linear time O(n+k), where n is the number of elements and k is the range of possible key values.
Lect11 Sorting
Lect11 Sortingryokollll This document provides a summary of a lecture on sorting algorithms:
1) It introduces sorting concepts and sorting problems. Common sorting algorithms discussed include selection sort, insertion sort, merge sort, and quick sort.
2) Selection sort and insertion sort algorithms are explained in detail with examples. Selection sort has a running time of O(n^2) in all cases.
3) Insertion sort's running time depends on how sorted the input array is - it is O(n) for a presorted array but O(n^2) for a reverse sorted array.
4) The time complexity of both algorithms is analyzed mathematically. Selection sort is always O(n^2) while
Searching algorithms
Searching algorithmsTrupti Agrawal The document discusses different types of searching algorithms. It describes sequential search which searches an unsorted list sequentially until the target item is found or the entire list is searched. The average runtime is O(n) as the item could be anywhere in the list. Binary search is described as more efficient for sorted lists, repeatedly dividing the search space in half and comparing the target to the middle element. Indexes are also summarized, including clustered vs unclustered indexes and different approaches to storing data entries.
Chapter 11 - Sorting and Searching
Chapter 11 - Sorting and SearchingEduardo Bergavera The document discusses various searching and sorting algorithms. It describes linear search, binary search, selection sort, bubble sort, and heapsort. For each algorithm, it provides pseudocode examples and analyzes their performance in terms of number of comparisons required in the worst case. Linear search requires N comparisons in the worst case, while binary search requires log N comparisons. Selection sort and bubble sort both require approximately N^2 comparisons, while heapsort requires 1.5NlogN comparisons.
Sorting Algorithms
Sorting AlgorithmsPranay Neema This document discusses various sorting algorithms and their complexities. It begins by defining an algorithm and complexity measures like time and space complexity. It then defines sorting and common sorting algorithms like bubble sort, selection sort, insertion sort, quicksort, and mergesort. For each algorithm, it provides a high-level overview of the approach and time complexity. It also covers sorting algorithm concepts like stable and unstable sorting. The document concludes by discussing future directions for sorting algorithms and their applications.
Insertion sort
Insertion sortLovely Professional University Insertion sort is a simple sorting algorithm that builds the final sorted array (or list) one item at a time. It is much less efficient on large lists than more advanced algorithms such as quicksort, heapsort, or merge sort. However, insertion sort provides several advantages:
Data Structures- Part4 basic sorting algorithms
Data Structures- Part4 basic sorting algorithmsAbdullah Al-hazmy The document discusses various sorting algorithms. It begins by explaining the motivation for sorting and providing examples. It then lists some common sorting algorithms like bubble sort, selection sort, and insertion sort. For each algorithm, it provides an informal description, works through examples to show how it sorts a list, and includes Java code implementations. It compares the time complexity of these algorithms, which is O(n2) for bubble sort, selection sort, and insertion sort, and explains why. The document aims to introduce fundamental sorting algorithms and their workings.
Algorithm & data structures lec4&5
Algorithm & data structures lec4&5Abdul Khan The document summarizes different searching and sorting algorithms. It discusses linear search and binary search for searching algorithms. It explains that linear search has O(n) time complexity while binary search has O(log n) time complexity. For sorting algorithms, it describes bubble sort, selection sort, and insertion sort. It provides pseudocode to illustrate how each algorithm works to sort a list or array.
Binary search
Binary search Raghu nath The document describes the binary search algorithm for searching a sorted array. It has a time complexity of O(Logn) compared to linear search which is O(n). Binary search works by comparing the target value to the middle element of the array and recursively searching either the left or right half depending on if the target is less than or greater than the middle element. Implementations of both recursive and iterative binary search in C are provided.
Quicksort
QuicksortGayathri Gaayu The document discusses various sorting algorithms and their analysis. It begins by explaining insertion sort and analyzing its best, worst, and average cases. It then discusses the concept of inversions and how they relate to sorting complexity. Other algorithms covered include bubble sort, merge sort, quicksort, quickselect, bucket sort, radix sort, and external sorting. A key takeaway is that quicksort and mergesort run in O(n log n) time on average, which is optimal for comparisons-based sorting. External sorting can sort data that does not fit in memory.
Viewers also liked (10)
Lecture 2c stacks
Lecture 2c stacksVictor Palmar A stack is a linear data structure that follows the last-in, first-out (LIFO) principle. Elements can only be inserted or removed from one end, called the top. Common stack operations include push, which adds an element to the top, and pop, which removes the top element. Stacks have many applications, such as evaluating mathematical expressions, interrupt handling in computing, and temporary storage in stack machines. They can be implemented using either arrays or linked lists.
Lecture 2 data structures & algorithms - sorting techniques
Lecture 2 data structures & algorithms - sorting techniquesDharmendra Prasad This 90-minute discussion covers algorithms, sorting algorithms, and analyzing algorithm performance. It discusses measuring algorithm effectiveness, common sorting algorithms like insertion sort and merge sort, and running time analysis. Insertion sort runs in O(n^2) time in the worst case, while merge sort runs faster in O(n log n) time by dividing the problem into smaller subproblems. Real-world examples of sorting include cable provider personalized services and alphabetical item lists.
Arrays
ArraysTrupti Agrawal Arrays are a commonly used data structure that store multiple elements of the same type. Elements in an array are accessed using subscripts or indexes, with the first element having an index of 0. Multidimensional arrays can store elements in rows and columns, accessed using two indexes. Arrays are stored linearly in memory in either row-major or column-major order, which affects how elements are accessed.
C# Arrays
C# ArraysHock Leng PUAH The document discusses arrays in C# and .NET. It covers declaring and initializing arrays, setting array size at runtime, looping through arrays using for and foreach loops, and using arrays of different data types like integers, floats, and strings. Key points include declaring arrays, assigning values, getting the length of an array, looping from index 0 to length-1, and the differences between for and foreach loops when iterating over an array.
Arrays C#
Arrays C#Raghuveer Guthikonda This document discusses different types of arrays in C#, including simple arrays, multidimensional arrays, jagged arrays, and tuples. Simple arrays store elements of the same type and can be initialized with syntax like "datatype[] myArray = new datatype[size]". Multidimensional arrays are indexed by two or more integers. Jagged arrays allow each row to have a different size. Tuples were introduced in .NET 4.0 and act as a way to group multiple data types together.
Lecture 2a arrays
Lecture 2a arraysVictor Palmar The document discusses arrays, which are a fundamental data structure that store a collection of elements of the same type in contiguous memory locations that can be individually accessed via an index. It describes one-dimensional arrays as lists and two-dimensional arrays as matrices. Key aspects covered include the components of an array like elements, data type, subscript, and brackets. Operations on and applications of arrays are also summarized.
queue & its applications
queue & its applicationssomendra kumar The document discusses different types of queues including their representations, operations, and applications. It describes queues as linear data structures that follow a first-in, first-out principle. Common queue operations are insertion at the rear and deletion at the front. Queues can be represented using arrays or linked lists. Circular queues and priority queues are also described as variants that address limitations of standard queues. Real-world and technical applications of queues include CPU scheduling, cashier lines, and data transfer between processes.
Lecture17 arrays.ppt
Lecture17 arrays.ppteShikshak This document discusses arrays in three sentences:
Arrays are collections of homogeneous data that can be one-dimensional, two-dimensional, or multi-dimensional. One-dimensional arrays store data in a single subscript, while two-dimensional arrays arrange data into rows and columns. Array elements are accessed via an index and each dimension of a multi-dimensional array is identified by a subscript.
Arrays
Arraysarchikabhatia The document discusses various concepts related to arrays in C/C++ including:
- What an array is and its key properties like contiguous memory locations and common data type
- Different types of arrays like single dimensional and multi dimensional
- How to declare, initialize and access array elements
- Passing arrays to functions
- Searching and sorting arrays
- Common array operations like insertion and deletion
Array in c language
Array in c languagehome The document discusses arrays in C language. It defines an array as a data structure that stores a collection of similar data types. An array is declared by specifying the data type, array name, and size/number of elements. Once declared, an array's size cannot be changed. Elements can be accessed via their index. Multidimensional arrays store elements in multiple dimensions and are accessed using two or more indices.
Ad
Similar to Lecture 3 data structures & algorithms - sorting techniques - http://techieme.in (20)
DAA-Divide and Conquer methodology, DAA 2024
DAA-Divide and Conquer methodology, DAA 2024RUHULAMINHAZARIKA The document discusses divide and conquer algorithms. It explains that divide and conquer algorithms follow three steps: 1) divide the problem into subproblems, 2) conquer the subproblems by solving them recursively, and 3) combine the results to solve the original problem. Binary search, merge sort, and quicksort are provided as examples of divide and conquer algorithms. Binary search divides a sorted array in half at each step to search for a target value. Merge sort divides the array in half, recursively sorts the halves, and then merges the sorted halves. Quicksort chooses a pivot to partition the array into left and right halves, recursively sorts the halves, and returns the fully sorted array.
lecture 10
lecture 10sajinsc The document discusses various sorting algorithms and their time complexities:
1. Comparison sorts like merge sort and quicksort have a best case time complexity of O(n log n).
2. Counting sort runs in O(n+k) time where k is the range of input values, and is not a comparison sort.
3. Radix sort treats input as d-digit numbers in some base k and uses counting sort to sort on each digit, achieving O(dn+dk) time which is O(n) when d and k are constants.
4. A randomized selection algorithm finds the ith order statistic in expected O(n) time using randomized partition.
algorithm Unit 2 
algorithm Unit 2 Monika Choudhery 1) The document describes the divide-and-conquer algorithm design paradigm. It splits problems into smaller subproblems, solves the subproblems recursively, and then combines the solutions to solve the original problem.
2) Binary search is provided as an example algorithm that uses divide-and-conquer. It divides the search space in half at each step to quickly determine if an element is present.
3) Finding the maximum and minimum elements in an array is another problem solved using divide-and-conquer. It recursively finds the max and min of halves of the array and combines the results.
Unit 2 in daa
Unit 2 in daaNv Thejaswini 1) The document describes the divide-and-conquer algorithm design paradigm. It can be applied to problems where the input can be divided into smaller subproblems, the subproblems can be solved independently, and the solutions combined to solve the original problem.
2) Binary search is provided as an example divide-and-conquer algorithm. It works by recursively dividing the search space in half and only searching the subspace containing the target value.
3) Finding the maximum and minimum elements in an array is also solved using divide-and-conquer. The array is divided into two halves, the max/min found for each subarray, and the overall max/min determined by comparing the subsolutions.
Daa chapter5
Daa chapter5B.Kirron Reddi The document introduces algorithms for sorting and searching tasks. It discusses sequential search, binary search, selection sort, bubble sort, merge sort, and quick sort algorithms. For each algorithm, it provides pseudocode to describe the steps, an example, and analysis of time complexity in the best, worst and average cases. The time complexities identified are Θ(n) for sequential search average case, Θ(log n) for binary search, Θ(n2) for selection, bubble and quick sort worst cases, and Θ(n log n) for merge and quick sort average cases.
module2_dIVIDEncONQUER_2022.pdf
module2_dIVIDEncONQUER_2022.pdfShiwani Gupta The document describes various divide and conquer algorithms including binary search, merge sort, quicksort, and finding maximum and minimum elements. It begins by explaining the general divide and conquer approach of dividing a problem into smaller subproblems, solving the subproblems independently, and combining the solutions. Several examples are then provided with pseudocode and analysis of their divide and conquer implementations. Key algorithms covered in the document include binary search (log n time), merge sort (n log n time), and quicksort (n log n time on average).
Divide and conquer
Divide and conquerramya marichamy Divide and conquer is a general algorithm design paradigm where a problem is divided into subproblems, the subproblems are solved independently, and the results are combined to solve the original problem. Binary search is a divide and conquer algorithm that searches for a target value in a sorted array by repeatedly dividing the search interval in half. It compares the target to the middle element of the array, and then searches either the upper or lower half depending on whether the target is greater or less than the middle element. Finding the maximum and minimum elements in an array can also be solved using divide and conquer by recursively finding the max and min of halves of the array and combining the results.
Sorting pnk
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
data structures and algorithms Unit 3
data structures and algorithms Unit 3infanciaj The document discusses various algorithms like priority queues, heaps, heap sort, merge sort, quick sort, binary search, and algorithms for finding the maximum and minimum elements in an array. It provides definitions and explanations of these algorithms along with code snippets and examples. Key steps of algorithms like heap sort, merge sort, and quick sort are outlined. Methods for implementing priority queues, binary search and finding max/min in optimal comparisons are also presented.
21-algorithms (1).ppt
21-algorithms (1).pptDaniloMislosAlbay For data structures and intro to programming using c++ and other IT and Computer science related topis.
21-algorithms.ppt
21-algorithms.pptashwinraiyani1 1. An algorithm is a precise set of instructions to perform a computation or solve a problem. Some algorithms are easier than others, such as finding the maximum value in a list, while others are harder like finding the shortest path between two locations.
2. The document describes several common algorithms including ones for finding the maximum value, doing linear and binary searches of a list, and sorting lists with bubble sort and insertion sort.
3. The running time of algorithms, measured by the number of steps needed in the worst case, varies from linear time (n steps) for linear search to logarithmic time (log n steps) for binary search to quadratic time (n^2 steps) for bubble and insertion sorts.
Algorithm, Pseudocode and Flowcharting in C++
Algorithm, Pseudocode and Flowcharting in C++Johnny Jean Tigas 1. The document discusses several algorithms including those for finding the maximum element in a list, linear search, binary search, bubble sort, and insertion sort.
2. It provides pseudocode to describe each algorithm and analyzes their running times, finding that linear search takes n steps, binary search takes log2n steps, and bubble sort and insertion sort each take about n2 steps.
3. Faster sorting algorithms like heap sort, quick sort, and merge sort have running times of nlogn steps.
Data structures arrays
Data structures arraysmaamir farooq 1. The document discusses various data structures concepts including arrays, dynamic arrays, operations on arrays like traversing, insertion, deletion, sorting, and searching.
2. It provides examples of declaring and initializing arrays, as well as dynamic array allocation using pointers and new/delete operators.
3. Searching techniques like linear search and binary search are explained, with linear search comparing each element sequentially while binary search eliminates half the elements at each step for sorted arrays.
Counting Sort Lowerbound
Counting Sort Lowerbounddespicable me 1. The document discusses lower bounds for sorting algorithms and proves that all comparison sorts require at least Ω(n lg n) time.
2. It then introduces counting sort, which runs in linear O(n) time by counting elements rather than comparing them, but requires the elements to be drawn from a small known range.
3. Radix sort is then described, which sorts integers digit-by-digit using counting sort, achieving linear time for integers by treating them as d-digit numbers in a base k system. This allows sorting large integers faster than comparison-based sorts.
21-algorithms.ppt
21-algorithms.pptMadurai Kamaraj University Madurai Tamil Nadu India This document provides an overview of algorithms, including definitions and examples. It discusses different types of algorithms like searching and sorting algorithms. For searching, it describes linear search and binary search algorithms. It also analyzes the running time of these algorithms. For sorting, it introduces bubble sort and insertion sort algorithms and analyzes their running times, which are both about O(n^2) time. Faster sorting algorithms like heap sort, quick sort, and merge sort have running times of O(nlogn).
Lect-2.pptx
Lect-2.pptxmrizwan38 This document discusses algorithms and their properties. It begins by defining an algorithm as a finite set of precise instructions to perform a computation or solve a problem. It provides examples of algorithms like directions to a location or a recipe. The document then discusses how some algorithms are easier than others and provides examples. It also outlines key properties of algorithms like inputs, outputs, definiteness, and effectiveness. Later sections summarize various algorithms for tasks like searching, sorting, and finding maximum/minimum elements with analysis of their running times.
CSE680-07QuickSort.pptx
CSE680-07QuickSort.pptxDeepakM509554 Quicksort is a divide and conquer sorting algorithm that works by partitioning an array around a pivot value and recursively sorting the subarrays. In the best case when the array is partitioned evenly, quicksort runs in O(n log n) time as the array is cut in half at each recursive call. However, in the worst case when the array is already sorted, each partition only cuts off one element, resulting in O(n^2) time as the recursion reaches a depth of n. Choosing a better pivot value can improve quicksort's performance on poorly sorted arrays.
lecture 11
lecture 11sajinsc This document discusses binary search trees (BSTs) and their use for dynamic sets and sorting. It covers BST operations like search, insert, find minimum/maximum, and delete. It explains that BST sorting runs in O(n log n) time like quicksort. Maintaining a height of O(log n) can lead to efficient implementations of priority queues and other dynamic set applications using BSTs.
Unit6 C 
Unit6 C arnold 7490 The document discusses various searching and sorting techniques. It describes linear and binary searching algorithms. It also explains different sorting algorithms like bubble sort, insertion sort, selection sort, and quick sort. Their time complexities and applications are discussed.
Sorting2
Sorting2Saurabh Mishra The document discusses various sorting algorithms and their time complexities, including:
1) Quicksort, which has an average case time complexity of O(n log n) but a worst case of O(n^2). It works by recursively partitioning an array around a pivot element.
2) Heapsort, which also has a time complexity of O(n log n). It uses a binary heap to extract elements in sorted order.
3) Counting sort and radix sort, which can sort in linear time O(n) when the input has certain properties like a limited range of values or being represented by a small number of digits.
Ad
Recently uploaded (20)
LDMMIA Reiki Yoga Next Week Grad Updates
LDMMIA Reiki Yoga Next Week Grad UpdatesLDM & Mia eStudios A short update and next week. I am writing both Session 9 and Orientation S1.
As a Guest Student,
You are now upgraded to Grad Level.
See Uploads for “Student Checkin” & “S8”. Thx.
Thank you for attending our workshops.
If you are new, do welcome.
Grad Students: I am planning a Reiki-Yoga Master Course (As a package). I’m Fusing both together.
This will include the foundation of each practice. Our Free Workshops can be used with any Reiki Yoga training package. Traditional Reiki does host rules and ethics. Its silent and within the JP Culture/Area/Training/Word of Mouth. It allows remote healing but there’s limits As practitioners and masters. We are not allowed to share certain secrets/tools. Some content is designed only for “Masters”. Some yoga are similar like the Kriya Yoga-Church (Vowed Lessons). We will review both Reiki and Yoga (Master tools) in the Course upcoming.
Session Practice, For Reference:
Before starting a session, Make sure to check your environment. Nothing stressful. Later, You can decorate a space as well.
Check the comfort level, any needed resources (Yoga/Reiki/Spa Props), or Meditation Asst?
Props can be oils, sage, incense, candles, crystals, pillows, blankets, yoga mat, any theme applies.
Select your comfort Pose. This can be standing, sitting, laying down, or a combination.
Monitor your breath. You can add exercises.
Add any mantras or affirmations. This does aid mind and spirit. It helps you to focus.
Also you can set intentions using a candle.
The Yoga-key is balancing mind, body, and spirit.
Finally, The Duration can be long or short.
Its a good session base for any style.
Next Week’s Focus:
A continuation of Intuition Development. We will review the Chakra System - Our temple. A misguided, misused situation lol. This will also serve Attunement later.
For Sponsor,
General updates,
& Donations:
Please visit:
https://ldmchapels.weebly.com
Hemiptera & Neuroptera: Insect Diversity.pptx
Hemiptera & Neuroptera: Insect Diversity.pptxArshad Shaikh *Order Hemiptera:*
Hemiptera, commonly known as true bugs, is a large and diverse order of insects that includes cicadas, aphids, leafhoppers, and shield bugs. Characterized by their piercing-sucking mouthparts, Hemiptera feed on plant sap, other insects, or small animals. Many species are significant pests, while others are beneficial predators.
*Order Neuroptera:*
Neuroptera, also known as net-winged insects, is an order of insects that includes lacewings, antlions, and owlflies. Characterized by their delicate, net-like wing venation and large, often prominent eyes, Neuroptera are predators that feed on other insects, playing an important role in biological control. Many species have aquatic larvae, adding to their ecological diversity.
Trends Spotting Strategic foresight for tomorrow’s education systems - Debora...
Trends Spotting Strategic foresight for tomorrow’s education systems - Debora...EduSkills OECD Deborah Nusche, Senior Analyst, OECD presents at the OECD webinar 'Trends Spotting: Strategic foresight for tomorrow’s education systems' on 5 June 2025. You can check out the webinar on the website https://oecdedutoday.com/webinars/ Other speakers included: Deborah Nusche, Senior Analyst, OECD
Sophie Howe, Future Governance Adviser at the School of International Futures, first Future Generations Commissioner for Wales (2016-2023)
Davina Marie, Interdisciplinary Lead, Queens College London
Thomas Jørgensen, Director for Policy Coordination and Foresight at European University Association
Strengthened Senior High School - Landas Tool Kit.pptx
Strengthened Senior High School - Landas Tool Kit.pptxSteffMusniQuiballo Landas Tool Kit is a very helpful guide in guiding the Senior High School students on their SHS academic journey. It will pave the way on what curriculum exits will they choose and fit in.
THERAPEUTIC COMMUNICATION included definition, characteristics, nurse patient...
THERAPEUTIC COMMUNICATION included definition, characteristics, nurse patient...parmarjuli1412 The document provides an overview of therapeutic communication, emphasizing its importance in nursing to address patient needs and establish effective relationships. THERAPEUTIC COMMUNICATION included some topics like introduction of COMMUNICATION, definition, types, process of communication, definition therapeutic communication, goal, techniques of therapeutic communication, non-therapeutic communication, few ways to improved therapeutic communication, characteristics of therapeutic communication, barrier of THERAPEUTIC RELATIONSHIP, introduction of interpersonal relationship, types of IPR, elements/ dynamics of IPR, introduction of therapeutic nurse patient relationship, definition, purpose, elements/characteristics , and phases of therapeutic communication, definition of Johari window, uses, what actually model represent and its areas, THERAPEUTIC IMPASSES and its management in 5th semester Bsc. nursing and 2nd GNM students
Optimization technique in pharmaceutical product development.pptx
Optimization technique in pharmaceutical product development.pptxUrmiPrajapati3 Optimization techniques in pharmaceutical product development
IDSP(INTEGRATED DISEASE SURVEILLANCE PROGRAMME...
IDSP(INTEGRATED DISEASE SURVEILLANCE PROGRAMME...SweetytamannaMohapat IDSP is a disease surveillance program in India that aims to strengthen/maintain decentralized laboratory-based IT enabled disease surveillance systems for epidemic prone diseases to monitor disease trends, and to detect and respond to outbreaks in the early phases swiftly.....
How to Manage Allocations in Odoo 18 Time Off
How to Manage Allocations in Odoo 18 Time OffCeline George Allocations in Odoo 18 Time Off allow you to assign a specific amount of time off (leave) to an employee. These allocations can be used to track and manage leave entitlements for employees, such as vacation days, sick leave, etc.
"Hymenoptera: A Diverse and Fascinating Order".pptx
"Hymenoptera: A Diverse and Fascinating Order".pptxArshad Shaikh Hymenoptera is a diverse order of insects that includes bees, wasps, ants, and sawflies. Characterized by their narrow waists and often social behavior, Hymenoptera play crucial roles in ecosystems as pollinators, predators, and decomposers, with many species exhibiting complex social structures and communication systems.
Webcrawler_Mule_AIChain_MuleSoft_Meetup_Hyderabad
Webcrawler_Mule_AIChain_MuleSoft_Meetup_HyderabadVeera Pallapu 1. MuleSoft AI Chain Concept Introduction
2. Demo on Mule AI Chain Connector
3. Q/A
4. Wrap up
SEXUALITY , UNWANTED PREGANCY AND SEXUAL ASSAULT .pptx
SEXUALITY , UNWANTED PREGANCY AND SEXUAL ASSAULT .pptxPoojaSen20 SEXUALITY AND ITS TYPES , UNWANTED PREGANCY AND SEXUAL ASSAULT
Diptera: The Two-Winged Wonders, The Fly Squad: Order Diptera.pptx
Diptera: The Two-Winged Wonders, The Fly Squad: Order Diptera.pptxArshad Shaikh Diptera, commonly known as flies, is a large and diverse order of insects that includes mosquitoes, midges, gnats, and horseflies. Characterized by a single pair of wings (hindwings are modified into balancing organs called halteres), Diptera are found in almost every environment and play important roles in ecosystems as pollinators, decomposers, and food sources. Some species, however, are significant pests and disease vectors, transmitting diseases like malaria, dengue, and Zika virus.
Analysis of Quantitative Data Parametric and non-parametric tests.pptx
Analysis of Quantitative Data Parametric and non-parametric tests.pptxShrutidhara2 This presentation covers the following points--
Parametric Tests
• Testing the Significance of the Difference between Means
• Analysis of Variance (ANOVA) - One way and Two way
• Analysis of Co-variance (One-way)
Non-Parametric Tests:
• Chi-Square test
• Sign test
• Median test
• Sum of Rank test
• Mann-Whitney U-test
Moreover, it includes a comparison of parametric and non-parametric tests, a comparison of one-way ANOVA, two-way ANOVA, and one-way ANCOVA.
Pests of Rice: Damage, Identification, Life history, and Management.pptx
Pests of Rice: Damage, Identification, Life history, and Management.pptxArshad Shaikh Rice pests can significantly impact crop yield and quality. Major pests include the brown plant hopper (Nilaparvata lugens), which transmits viruses like rice ragged stunt and grassy stunt; the yellow stem borer (Scirpophaga incertulas), whose larvae bore into stems causing deadhearts and whiteheads; and leaf folders (Cnaphalocrocis medinalis), which feed on leaves reducing photosynthetic area. Other pests include rice weevils (Sitophilus oryzae) and gall midges (Orseolia oryzae). Effective management strategies are crucial to minimize losses.
EUPHORIA GENERAL QUIZ FINALS | QUIZ CLUB OF PSGCAS | 21 MARCH 2025
EUPHORIA GENERAL QUIZ FINALS | QUIZ CLUB OF PSGCAS | 21 MARCH 2025Quiz Club of PSG College of Arts & Science RE-LIVE THE EUPHORIA!!!!
The Quiz club of PSGCAS brings to you a fun-filled breezy general quiz set from numismatics to sports to pop culture.
Re-live the Euphoria!!!
QM: Eiraiezhil R K,
BA Economics (2022-25),
The Quiz club of PSGCAS
Final Sketch Designs for poster production.pptx
Final Sketch Designs for poster production.pptxbobby205207 Final Sketch Designs for poster production.
EUPHORIA GENERAL QUIZ FINALS | QUIZ CLUB OF PSGCAS | 21 MARCH 2025
EUPHORIA GENERAL QUIZ FINALS | QUIZ CLUB OF PSGCAS | 21 MARCH 2025Quiz Club of PSG College of Arts & Science
Lecture 3 data structures & algorithms - sorting techniques - http://techieme.in
- 1. Description: A detailed discussion about algorithms and their measures, and understanding sorting. Duration: 90 minutes Starts at: Saturday 12th May 2013, 11:00AM -by Dharmendra Prasad 1
- 2. Table of Contents 1. Continuing the Sorting Algorithms. 1. Quick Sort (in place sorting algorithm) 2. Searching Algorithms 1. Binary search 3. Some real world problem scenarios. 1. Substring search 2
- 3. Algorithm: It’s a divide and conquer algorithm. Step1(Divide): Partition a given array into 2 sub arrays around a pivot ‘x’ such that the elements in lower sub array <= x <= elements in upper sub array. Step2(Conquer):Recursively sort 2 sub arrays. Step3(Combine):Do nothing as it is in place sorting. 3
- 4. Partition(A, p, q) //A[p , q] X ← A[p] i ← p for j ← p+1 to q do if A[j] <= x then i ← i+1 exchange A[i] ↔ A[j] exchange A[p] ↔ A[i]; return i 4 A p qi j
- 5. 5 Example: 6 10 13 5 8 3 2 11 X = 6, i = 0, j = 1 6 5 13 10 8 3 2 11 6 5 3 10 8 13 2 11 6 5 3 2 8 13 10 11 Swap pivot with i 2 5 3 6 8 13 10 11
- 6. Algorithm: QuickSort(A, p, q) if p < q then r <- Partition(A, p, q) QuickSort( A, p, r-1) QuickSort( A, r+1, q) Initial Call : QuickSort( A, 1, n) 6
- 7. Order Statistics: Problem Statement: Given an array of numbers, find the kth smallest number. Naïve Solution: Sort the array and return the element at index k. Case1: if k = 1, we are referring to the minimum number in the array. Case2: if k = length of the array, we are referring to the maximum number in the array. Case3: when k lies between 1 and n where n is the length of the array 7
- 8. Algorithm: OrderStat(A,p,q,k) // means kth smallest number in A between index p and q if p==q return A[p] r <- Partition(A,p,q) i <- r – p + 1; if k == i return A[r] if k < i return OrderStat(A,p,r-1,k) else return OrderStat(A,r+1,q,k-i) 8
- 9. Searching: Basic Idea: In an array A[a1,a2,a3,a4,…,an] find the index k such that p = A[k] Naïve Solution: Traverse through the array in a loop and compare each element with the given number. If the number matches, return the index of the number else return null. Algorithm: Search (A[1.. n], p) for i<- 1 to n do if A[i] == p return i return null 9
- 10. Searching: Basic Idea: In an array A[a1,a2,a3,a4,…,an] find the index k such that p = A[k] Binary Search Solution: Only if the array is sorted. Divide it into two halves, check the element at the center, if it is less than what we are searching, look into the upper half else look into the lower half. Repeat till you find the number or the array exhausts. Algorithm: BinarySearch (A, p, low,high) middle = (low+high)/2 if A[middle] == p return middle; else if A[middle] > p return BinarySearch(A, p, low, middle-1) else return BinarySearch(A,p,middle+1,high) 10
- 11. Special Case Substring Searching: Basic Idea: In a character string search a substring and return the index of first occurrence. Naive Solution: Start from the first index of both the strings, compare the characters, if character matches, compare the next character and so on till the substring exhausts. Return the start index of the substring in the main string. Algorithm: SubStringSearch (S, sb) j=0; match = false; while i < S.length or j < sb.length if S[i] == sb[j] match = true i++, j++ else match = false j=0, i++ if match == true and j = sb.length return i-sb.length else return -1 11
- 12. Special Case Substring Searching: Basic Idea: In a character string search a substring and return the index of first occurrence. Better Solution: Boyre Moore algorithm is used to effectively search substring in a given string. 12