Lecture 3 data structures & algorithms - sorting techniques - http://techieme.in
Download as ppsx, pdf0 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)
Types of Actions in Odoo 18 - Odoo Slides
Types of Actions in Odoo 18 - Odoo SlidesCeline George In Odoo, actions define the system's response to user interactions, like logging in or clicking buttons. They can be stored in the database or returned as dictionaries in methods. Odoo offers various action types for different purposes.
LDMMIA Free Reiki Yoga S7 Weekly Workshops
LDMMIA Free Reiki Yoga S7 Weekly WorkshopsLDM & Mia eStudios ♥☽✷♥
Make sure to catch our weekly updates. Updates are done Thursday to Fridays or its a holiday/event weekend.
Thanks again, Readers, Guest Students, and Loyalz/teams.
This profile is older. I started at the beginning of my HQ journey online. It was recommended by AI. AI was very selective but fits my ecourse style. I am media flexible depending on the course platform. More information below.
AI Overview:
“LDMMIA Reiki Yoga refers to a specific program of free online workshops focused on integrating Reiki energy healing techniques with yoga practices. These workshops are led by Leslie M. Moore, also known as LDMMIA, and are designed for all levels, from beginners to those seeking to review their practice. The sessions explore various themes like "Matrix," "Alice in Wonderland," and "Goddess," focusing on self-discovery, inner healing, and shifting personal realities.”
♥☽✷♥
“So Life Happens-Right? We travel on. Discovering, Exploring, and Learning...”
These Reiki Sessions are timeless and about Energy Healing / Energy Balancing.
A Shorter Summary below.
A 7th FREE WORKSHOP
REiki - Yoga
“Life Happens”
Intro Reflections
Thank you for attending our workshops. If you are new, do welcome. We have been building a base for advanced topics. Also, this info can be fused with any Japanese (JP) Healing, Wellness Plans / Other Reiki /and Yoga practices.
Power Awareness,
Our Defense.
Situations like Destiny Swapping even Evil Eyes are “stealing realities”. It’s causing your hard earned luck to switch out. Either way, it’s cancelling your reality all together. This maybe common recently over the last decade? I noticed it’s a sly easy move to make. Then, we are left wounded, suffering, accepting endless bad luck. It’s time to Power Up. This can be (very) private and quiet. However; building resources/EDU/self care for empowering is your business/your right. It’s a new found power we all can use for healing.
Stressin out-II
“Baby, Calm down, Calm Down.” - Song by Rema, Selena Gomez (Video Premiered Sep 7, 2022)
Within Virtual Work and VR Sims (Secondlife Metaverse) I love catching “Calm Down” On the radio streams. I love Selena first. Second, It’s such a catchy song with an island feel. This blends with both VR and working remotely.
Its also, a good affirmation or mantra to *Calm down* lol.
Something we reviewed in earlier Workshops.
I rarely mention love and relations but theres one caution.
When we date, almost marry an energy drainer/vampire partner; We enter doorways of no return. That person can psychic drain U during/after the relationship. They can also unleash their demons. Their dark energies (chi) can attach itself to you. It’s SYFI but common. Also, involving again, energy awareness. We are suppose to keep our love life sacred. But, Trust accidents do happen. The Energies can linger on. Also, Reiki can heal any breakup damage...
(See Pres for more info. Thx)
Pragya Champion's Chalice 2025 Set , General Quiz
Pragya Champion's Chalice 2025 Set , General QuizPragya - UEM Kolkata Quiz Club Pragya Champion's Chalice is the annual Intra Pragya General Quiz hosted by the club's outgoing President and Vice President. The prelims and finals are both given in the singular set.
SEM II 3202 STRUCTURAL MECHANICS, B ARCH, REGULATION 2021, ANNA UNIVERSITY, R...
SEM II 3202 STRUCTURAL MECHANICS, B ARCH, REGULATION 2021, ANNA UNIVERSITY, R...RVSPSOA Principles of statics. Forces and their effects. Types of force systems. Resultant of concurrent and
parallel forces. Lami’s theorem. Principle of moments. Varignon’s theorem. Principle of equilibrium.
Types of supports and reactions-Bending moment and Shear forces-Determination of reactions for
simply supported beams. Relation between bending moment and shear force.
Properties of section – Centre of gravity, Moment of Inertia, Section modulus, Radius of gyration
for various structural shapes. Theorem of perpendicular axis. Theorem of parallel axis.
Elastic properties of solids. Concept of stress and strain. Deformation of axially loaded simple bars.
Types of stresses. Concept of axial and volumetric stresses and strains. Elastic constants. Elastic
Modulus. Shear Modulus. Bulk Modulus. Poisson’s ratio. Relation between elastic constants.
Principal stresses and strain. Numerical and Graphical method. Mohr’s diagram.
R.K. Bansal, ‘A Text book on Engineering Mechanics’, Lakshmi Publications, Delhi,2008.
R.K. Bansal, ‘A textbook on Strength of Materials’, Lakshmi Publications, Delhi 2010.
Paul W. McMullin, 'Jonathan S. Price, ‘Introduction to Structures’, Routledge, 2016.
P.C. Punmia, ‘Strength of Materials and Theory of Structures; Vol. I’, Lakshmi
Publications, Delhi 2018.
2. S. Ramamrutham, ‘Strength of Materials’, Dhanpatrai and Sons, Delhi, 2014.
3. W.A. Nash, ‘Strength of Materials’, Schaums Series, McGraw Hill Book Company,1989.
4. R.K. Rajput, ‘Strength of Materials’, S.K. Kataria and Sons, New Delhi , 2017.
"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.
THE CHURCH AND ITS IMPACT: FOSTERING CHRISTIAN EDUCATION
THE CHURCH AND ITS IMPACT: FOSTERING CHRISTIAN EDUCATIONPROF. PAUL ALLIEU KAMARA Christian education is an important element in forming moral values, ethical Behaviour and
promoting social unity, especially in diverse nations like in the Caribbean. This study examined
the impact of Christian education on the moral growth in the Caribbean, characterized by
significant Christian denomination, like the Orthodox, Catholic, Methodist, Lutheran and
Pentecostal. Acknowledging the historical and social intricacies in the Caribbean, this study
tends to understand the way in which Christian education mold ethical decision making, influence interpersonal relationships and promote communal values. These studies’ uses, qualitative and quantitative research method to conduct semi-structured interviews for twenty
(25) Church respondents which cut across different age groups and genders in the Caribbean. A
thematic analysis was utilized to identify recurring themes related to ethical Behaviour, communal values and moral development. The study analyses the three objectives of the study:
how Christian education Mold’s ethical Behaviour and enhance communal values, the role of
Christian educating in promoting ecumenism and the effect of Christian education on moral
development. Moreover, the findings show that Christian education serves as a fundamental role
for personal moral evaluation, instilling a well-structured moral value, promoting good
Behaviour and communal responsibility such as integrity, compassion, love and respect. However, the study also highlighted challenges including biases in Christian teachings, exclusivity and misconceptions about certain practices, which impede the actualization of
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.....
Exploring Identity Through Colombian Companies
Exploring Identity Through Colombian CompaniesOlgaLeonorTorresSnch Students will research and orally present a Colombian company using a visual tool, in order to develop their communication skills and intercultural understanding through the exploration of identity, innovation, and local culture, in connection with the IB global themes.
YSPH VMOC Special Report - Measles Outbreak Southwest US 5-30-2025.pptx
YSPH VMOC Special Report - Measles Outbreak Southwest US 5-30-2025.pptxYale School of Public Health - The Virtual Medical Operations Center (VMOC) Here is the current update:
CURRENT CASE COUNT: 897
- Texas: 742 (+14) (55% of cases are in Gaines County). Includes additional numbers from El Paso.
- New Mexico: 79 (+1) (83% of cases are from Lea County)
- Oklahoma: 17
- Kansas: 59 (+3) (38.89% of the cases are from Gray County)
HOSPITALIZATIONS: 103
- Texas: 94 – This accounts for 13% of all cases in Texas.
- New Mexico: 7 – This accounts for 9.47% of all cases in New Mexico.
- Kansas: 3 – This accounts for 5.08% of all cases in Kansas.
DEATHS: 3
- Texas: 2 – This is 0.28% of all cases in Texas.
- New Mexico: 1 – This is 1.35% of all cases in New Mexico.
US NATIONAL CASE COUNT: 1,132 (confirmed and suspected)
INTERNATIONAL SPREAD
Mexico: 1,856(+103), 4 fatalities
- Chihuahua, Mexico: 1,740 (+83) cases, 3 fatalities, 4 currently hospitalized.
Canada: 2,791 (+273)
- Ontario, Canada: 1,938 (+143) cases. 158 (+29) hospitalizations
- Alberta, Canada: 679 (+119) cases. 4 currently hospitalized
"Dictyoptera: The Order of Cockroaches and Mantises" Or, more specifically: ...
"Dictyoptera: The Order of Cockroaches and Mantises" Or, more specifically: ...Arshad Shaikh Dictyoptera is an order of insects that includes cockroaches and praying mantises. These insects are characterized by their flat, oval-shaped bodies and unique features such as modified forelegs in mantises for predation. They inhabit diverse environments worldwide.
TechSoup Microsoft Copilot Nonprofit Use Cases and Live Demo - 2025.05.28.pdf
TechSoup Microsoft Copilot Nonprofit Use Cases and Live Demo - 2025.05.28.pdfTechSoup In this webinar we will dive into the essentials of generative AI, address key AI concerns, and demonstrate how nonprofits can benefit from using Microsoft’s AI assistant, Copilot, to achieve their goals.
This event series to help nonprofits obtain Copilot skills is made possible by generous support from Microsoft.
Coleoptera: The Largest Insect Order.pptx
Coleoptera: The Largest Insect Order.pptxArshad Shaikh Coleoptera, commonly known as beetles, is the largest order of insects, comprising approximately 400,000 described species. Beetles can be found in almost every habitat on Earth, exhibiting a wide range of morphological, behavioral, and ecological diversity. They have a hardened exoskeleton, with the forewings modified into elytra that protect the hind wings. Beetles play important roles in ecosystems as decomposers, pollinators, and food sources for other animals, while some species are considered pests in agriculture and forestry.
How to Create Time Off Request in Odoo 18 Time Off
How to Create Time Off Request in Odoo 18 Time OffCeline George Odoo 18 provides an efficient way to manage employee leave through the Time Off module. Employees can easily submit requests, and managers can approve or reject them based on company policies.
Swachata Quiz - Prelims - 01.10.24 - Quiz Club IIT Patna
Swachata Quiz - Prelims - 01.10.24 - Quiz Club IIT PatnaQuiz Club, Indian Institute of Technology, Patna The Swachata Quiz was conducted by Quiz Club IIT Patna on 1st October 2024. It had questions froma wide array of topics.
Multicultural approach in education - B.Ed
Multicultural approach in education - B.Edprathimagowda443 A PPT Presentation on multicultural education
POS Reporting in Odoo 18 - Odoo 18 Slides
POS Reporting in Odoo 18 - Odoo 18 SlidesCeline George To view all the available reports in Point of Sale, navigate to Point of Sale > Reporting. In this section, you will find detailed reports such as the Orders Report, Sales Details Report, and Session Report, as shown below.
CBSE - Grade 11 - Mathematics - Ch 2 - Relations And Functions - Notes (PDF F...
CBSE - Grade 11 - Mathematics - Ch 2 - Relations And Functions - Notes (PDF F...Sritoma Majumder RELATIONS AND FUNCTIONS
1. Cartesian Product of Sets:
If A and B are two non-empty sets, then their Cartesian product is:
A × B = {(a, b) | a ∈ A, b ∈ B}
Number of elements: |A × B| = |A| × |B|
2. Relation:
A relation R from set A to B is a subset of A × B.
Domain: Set of all first elements.
Range: Set of all second elements.
Codomain: Set B.
3. Types of Relations:
Empty Relation: No element in R.
Universal Relation: R = A × A.
Identity Relation: R = {(a, a) | a ∈ A}
Reflexive: (a, a) ∈ R ∀ a ∈ A
Symmetric: (a, b) ∈ R ⇒ (b, a) ∈ R
Transitive: (a, b), (b, c) ∈ R ⇒ (a, c) ∈ R
Equivalence Relation: Reflexive, symmetric, and transitive
4. Function (Mapping):
A relation f: A → B is a function if every element of A has exactly one image in B.
Domain: A, Codomain: B, Range ⊆ B
5. Types of Functions:
One-one (Injective): Different inputs give different outputs.
Onto (Surjective): Every element of codomain is mapped.
One-one Onto (Bijective): Both injective and surjective.
Constant Function: f(x) = c ∀ x ∈ A
Identity Function: f(x) = x
Polynomial Function: e.g., f(x) = x² + 1
Modulus Function: f(x) = |x|
Greatest Integer Function: f(x) = [x]
Signum Function: f(x) =
-1 if x < 0,
0 if x = 0,
1 if x > 0
6. Graphs of Functions:
Learn shapes of basic graphs: modulus, identity, step function, etc.
YSPH VMOC Special Report - Measles Outbreak Southwest US 5-30-2025.pptx
YSPH VMOC Special Report - Measles Outbreak Southwest US 5-30-2025.pptxYale School of Public Health - The Virtual Medical Operations Center (VMOC)
Swachata Quiz - Prelims - 01.10.24 - Quiz Club IIT Patna
Swachata Quiz - Prelims - 01.10.24 - Quiz Club IIT PatnaQuiz Club, Indian Institute of Technology, Patna
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