Quick Sort algorithm for sorting an array of elements
Download as pptx, pdf0 likes16 views
Quick sort is an efficient internal sorting technique based on the divide and conquer method, utilizing a pivot element to partition an array. By rearranging elements such that those less than the pivot are on one side and those greater on the other, quick sort recursively sorts subarrays. An example illustrates the process with an unsorted array and the steps involved in determining the correct position of the pivot and partitioning the array.
1 of 11
Download to read offline
![Quick Sort
Quick sort is the most efficient internal sorting technique.
It is also called partitioning sort which uses divide and conquer
techniques.
The quick sort works by partitioning the array A[1],A[2],……A[n]
by picking some key value in the array as a pivot element.
Pivot element is used to rearrange the elements in the array.
Pivot can be the first element of an array and the rest of the
elements are moved so that the elements on left side of the pivot are
lesser than the pivot, whereas those on the right side are greater
than the pivot.
Now the pivot element is placed in its correct position.
Then quick sort procedure is applied for left array and right array in
a recursive manner.](https://image.slidesharecdn.com/quicksort-240919223659-5032c418/85/Quick-Sort-algorithm-for-sorting-an-array-of-elements-1-320.jpg)
![Example 1
• Consider an unsorted array as follows
40 20 70 14 60 61 97 30
• Here PIVOT=40, i=20, j=30
The value of i is incremented till a[i]<=Pivot and the value of j is
decremented till a[j]>Pivot, this process is repeated until i<j.
If a[i]>Pivot and a[j]<Pivot and also if i<j then swap a[i] and a[j]
If i>j then swap a[j] and a[Pivot]
• Once the correct location for PIVOT is found then partition array
into left sub array and right sub array, where left sub array
contains all the elements less than the PIVOT and right sub array
contains all the elements greater than the PIVOT](https://image.slidesharecdn.com/quicksort-240919223659-5032c418/85/Quick-Sort-algorithm-for-sorting-an-array-of-elements-4-320.jpg)
![Example 1
Passes of Quick Sort
40 20 70 14 60 61 97 30
pivot i j
40 20 70 14 60 61 97 30
pivot i j
Swap(a[i],a[j], i.e As i<j
swap (70,30)
40 20 30 14 60 61 97 70
pivot i j
40 20 30 14 60 61 97 70
pivot i j
40
40
40
40](https://image.slidesharecdn.com/quicksort-240919223659-5032c418/85/Quick-Sort-algorithm-for-sorting-an-array-of-elements-5-320.jpg)
![Example 1
Passes of Quick Sort
40 20 30 14 60 61 97 70
pivot j i
As i>j swap (a[j],a[pivot]
i.e swap (60,40)
[[
14 20 30 40 60 61 97 70
• Now the pivot element has reached its correct position.
• The elements lesser than the pivot {14,20,30} is considered as left
sub array.
• The elements greater than the pivot {60,61,97,70} is considered
as right sub array.
• Then qsort procedure is applied recursively for both these arrays.
40](https://image.slidesharecdn.com/quicksort-240919223659-5032c418/85/Quick-Sort-algorithm-for-sorting-an-array-of-elements-7-320.jpg)
Ad
Recommended
Unit 2 - Quick Sort.pptx
Unit 2 - Quick Sort.pptxCO1IShwetaKidile Quicksort is a divide and conquer algorithm that picks an element as a pivot and partitions the array around that pivot. It recursively sorts the sub-arrays on each side of the pivot. The algorithm involves picking a pivot element, partitioning the array by the pivot value, and then recursively sorting the sub-arrays. Quicksort has average case performance of O(n log n) time but can perform poorly on worst-case inputs.
Divide-and-conquer
Divide-and-conquerMrunal Patil Quick sort is a widely used and efficient sorting algorithm that utilizes the divide and conquer strategy, partitioning an array into smaller arrays based on a specified pivot value. The algorithm sorts elements in place by recursively sorting sub-arrays and has a best and average time complexity of O(n log n), with a worst case of O(n^2). Space complexity can range from O(n) for the basic approach to O(log n) for the modified approach.
Module 2 Quick Sort algorithm in analysis of algorithm.pptx
Module 2 Quick Sort algorithm in analysis of algorithm.pptxSiddhantRaut20 Sorting algorithm used in analysis of algortihm in second year engineering
Quick sort
Quick sortA. S. M. Shafi Quicksort is a sorting algorithm that uses a divide and conquer approach. It works by selecting a pivot element and partitioning the array around the pivot so that elements less than the pivot are to its left and greater elements are to its right. It then recursively applies this process to the subarrays until each contains a single element, at which point the array is fully sorted. The example demonstrates quicksort sorting an array from 0 to 7.
Quick sort
Quick sortmaamir farooq Quicksort is an efficient sorting algorithm that works by partitioning an array around a pivot value and then recursively sorting the sub-arrays. It has average and worst-case time complexities of O(n log n). The algorithm chooses a pivot element and partitions the array by moving all elements less than the pivot to the left of it and greater elements to the right, creating two sub-arrays that are then recursively sorted.
Quick sort
Quick sortamar kakde Quicksort is a divide and conquer algorithm that works by partitioning an array around a pivot value and recursively sorting the sub-partitions. It first chooses a pivot element and partitions the array by placing all elements less than the pivot before it and all elements greater than it after it. It then recursively quicksorts the two partitions. This continues until the individual partitions only contain single elements at which point they are sorted. Quicksort has average case performance of O(n log n) time making it very efficient for large data sets.
Quick sort
Quick sortDrHimani Mittal Quicksort is a divide-and-conquer sorting algorithm that dynamically divides the array into subarrays rather than using static divisions like Mergesort. It has three steps - divide the array into subarrays separated by a pivot element, recursively sort the subarrays, and combine the sorted subarrays. The algorithm works by picking a pivot element and partitioning the array such that elements less than the pivot are moved before it and greater elements after it. It then recursively applies this process to the subarrays until the entire array is sorted. The performance depends on how evenly the array is divided during partitioning, with best case being a split in the middle and worst case being a skewed division.
DS - Quick Sort
DS - Quick SortMythiliMurugan3 Quick sort is an internal sorting technique that uses the divide and conquer approach. It works by picking a pivot element and partitioning the array so that elements less than the pivot are moved left and greater elements right. The pivot is placed in its correct position, then quick sort is recursively applied to the left and right subarrays. It has a best case of O(n log n) and average case of O(n log n), but worst case of O(n^2).
CS8391-Data Structures Unit 5
CS8391-Data Structures Unit 5SIMONTHOMAS S Quick sort is an internal sorting technique that uses the divide and conquer approach. It works by picking a pivot element and partitioning the array so that elements less than the pivot are moved left and greater elements right. The pivot is placed in its correct position, then quick sort is recursively applied to the left and right subarrays. It has a best case of O(n log n) and average case of O(n log n), but worst case of O(n^2).
Class13_Quicksort_Algorithm.pdf
Class13_Quicksort_Algorithm.pdfAkashSingh625550 Quick Sort is a sorting algorithm that partitions an array around a pivot element, recursively sorting the subarrays. It has a best case time complexity of O(n log n) when partitions are evenly divided, and worst case of O(n^2) when partitions are highly imbalanced. While fast, it is unstable and dependent on pivot selection. It is widely used due to its efficiency, simplicity, and ability to be parallelized.
Quicksort algorithm and implantation process
Quicksort algorithm and implantation processsamiulhasan0186 Quick sort is a sorting algorithm that uses divide-and-conquer to partition an array into two sub-arrays based on a pivot element, and then recursively sorts the sub-arrays. It works by picking a pivot element, partitioning the array into elements less than or equal to the pivot and elements greater than the pivot, and then applying quicksort recursively on the two sub-arrays. Quick sort has an average time complexity of O(nlogn) and is often faster in practice than other popular sorting algorithms like merge sort and heap sort.
Quick sort
Quick sortAfaq Mansoor Khan Quicksort is a divide and conquer algorithm that works by partitioning an array around a pivot value and recursively sorting the subarrays. It first selects a pivot element and partitions the array by moving all elements less than the pivot before it and greater elements after it. The subarrays are then recursively sorted through this process. When implemented efficiently with an in-place partition, quicksort is one of the fastest sorting algorithms in practice, with average case performance of O(n log n) time but worst case of O(n^2) time.
quicksort (1).ppt
quicksort (1).pptBalasubramanian699229 Quicksort is a divide-and-conquer sorting algorithm that has average case performance of O(N log N). It works by recursively dividing the array into two partitions based on a pivot value and sorting them independently. While quicksort's average case is efficient, its worst case is O(N^2) if the pivot choices are poor, though this seldom occurs in practice with randomization techniques. Quicksort is generally faster than mergesort due to its simpler in-place partitioning avoiding extra data movement.
Quick sort by Sania Nisar
Quick sort by Sania NisarSania Nisar The document provides an overview of the quicksort sorting algorithm, detailing its method of arranging elements in ascending or descending order. It outlines the choice of pivot for partitioning the array and includes pseudocode and a C++ implementation of the algorithm. Quicksort's complexities indicate that it averages O(n log n) efficiency, with a worst-case scenario of O(n²), though the latter can typically be avoided.
quick sort by deepak.pptx
quick sort by deepak.pptxDeepakM509554 Quicksort is an efficient sorting algorithm that uses a divide-and-conquer approach. It works by partitioning an array around a pivot value, and then recursively sorting the subarrays. In the best case when the array is partitioned evenly, quicksort runs in O(n log n) time. In the worst case of a sorted or reverse sorted array, it runs in O(n^2) time. Using a median-of-three approach for pivot selection helps avoid worst case behavior in typical cases.
Lecture 3.3.4 Quick sort.pptxIIIIIIIIIII
Lecture 3.3.4 Quick sort.pptxIIIIIIIIIIIanshsaini1603 The document covers the quick sort algorithm, a widely used and efficient sorting method that operates on the divide and conquer principle, making n log n comparisons in average cases. It explains the process of selecting a pivot and partitioning the array into subarrays, followed by recursive sorting and combining the results. Additionally, the document discusses various strategies for choosing an optimal pivot to enhance the algorithm's performance.
jyothi(22D21A0547)DAA.pptx in DAA computer
jyothi(22D21A0547)DAA.pptx in DAA computerMadhurimaKomanduru Quick sort is a divide-and-conquer sorting algorithm that efficiently rearranges elements based on a pivot, invented by Tony Hoare in 1960. Its advantages include speed, minimal memory usage, and adaptability for various data structures, while key features involve partitioning and recursion. Effective pivot selection is crucial for optimizing performance, with specific techniques available to improve sorting efficiency.
Data Structure Sorting
Data Structure SortingMuhazzab Chouhadry The document details the divide-and-conquer approach applied to sorting algorithms such as merge sort and quick sort, explaining how problems are recursively divided into subproblems. It outlines the steps of merging sorted lists in merge sort and the partitioning method in quick sort to efficiently sort elements without additional merging steps. Additionally, it briefly covers selection sort, emphasizing its procedure for finding and swapping minimum elements in an array.
Unit 5 internal sorting & files
Unit 5 internal sorting & filesDrkhanchanaR Quicksort has average time complexity of O(n log n), but worst case of O(n^2). It has O(log n) space complexity for the recursion stack. It works by picking a pivot element, partitioning the array into sub-arrays of smaller size based on element values relative to the pivot, and recursively
Quick sort
Quick sortDhruv Sabalpara Quicksort is a sorting algorithm that works by partitioning an array around a pivot value, and then recursively sorting the sub-partitions. It chooses a pivot element and partitions the array based on whether elements are less than or greater than the pivot. Elements are swapped so that those less than the pivot are moved left and those greater are moved right. The process recursively partitions the sub-arrays until the entire array is sorted.
09 QUICK SORT Design and Analysis of algorithms
09 QUICK SORT Design and Analysis of algorithmssyamalamaganti The document discusses the design and analysis of the Quick Sort algorithm, a divide and conquer method that partitions an array around a chosen pivot, leading to recursive sorting of subarrays. Different pivot selection methods are outlined, including picking the first, last, random, or median values, and time complexities for best, average, and worst cases are analyzed. Example problems and comparisons with Merge Sort are also included to enhance understanding of the algorithm's efficiency and application.
Quick_sort1.pptx
Quick_sort1.pptxsandeep54552 Quick sort is a divide and conquer sorting algorithm that works by partitioning an array around a pivot value. It then recursively sorts the sub-arrays on each side of the pivot. The key steps are: 1) Choose a pivot element to divide the array; 2) Partition the array by swapping elements such that all elements less than the pivot come before it and all greater elements come after; 3) Recursively apply the same process to the sub-arrays on each side of the pivot until the entire array is sorted.
Algorithms - "quicksort"
Algorithms - "quicksort"Ra'Fat Al-Msie'deen Quicksort is a divide-and-conquer algorithm that works by partitioning an array around a pivot element and recursively sorting the subarrays. It has average-case performance of O(n log n) but worst-case performance of O(n^2) if the partitioning is badly unbalanced. Choosing the pivot randomly helps ensure close to average-case behavior. The key steps are partitioning the array around a pivot into elements less than or greater than the pivot, and then recursively sorting the two partitions.
Sorting
SortingFahadSaeed39 This document discusses two sorting algorithms: insertion sort and quicksort. Insertion sort builds a sorted array one item at a time by inserting each item into the correct position in a sorted prefix. Quicksort uses divide and conquer by partitioning the array around a pivot value and recursively sorting the subarrays. The quicksort algorithm is generally faster than insertion sort for large arrays but risks stack overflow errors.
Quick sort.pptx
Quick sort.pptxAnbarasan Radhakrishnan R Quicksort is a divide-and-conquer sorting algorithm that works as follows:
1. Pick a pivot element and partition the array around it so that all elements less than the pivot come before elements greater than the pivot.
2. Recursively apply quicksort to the subarrays on each side of the pivot.
The average time complexity of quicksort is O(n log n) because on average the partitioning divides the array into equal halves at each step. However, the worst case is O(n^2) if the array is already sorted. Choosing the median element as the pivot helps avoid this worst case.
Quick sort-Data Structure
Quick sort-Data StructureJeanie Arnoco Quicksort is a divide and conquer sorting algorithm that works by partitioning an array around a pivot value. It then recursively sorts the sub-arrays on each side. The key steps are: 1) Choose a pivot element to split the array into left and right halves, with all elements on the left being less than the pivot and all on the right being greater; 2) Recursively quicksort the left and right halves; 3) Combine the now-sorted left and right halves into a fully sorted array. The example demonstrates quicksorting an array of 6 elements by repeatedly partitioning around a pivot until the entire array is sorted.
Tally.ERP 9 at a Glance.book - Tally Solutions .pdf
Tally.ERP 9 at a Glance.book - Tally Solutions .pdfShabista Imam Tally.ERP 9 at a Glance.book, a fully completed guidance to learn tally erp 9.0
Fundamentals of Digital Design_Class_21st May - Copy.pptx
Fundamentals of Digital Design_Class_21st May - Copy.pptxdrdebarshi1993 Basics of Number Systems and Logic Gates
More Related Content
Similar to Quick Sort algorithm for sorting an array of elements (20)
CS8391-Data Structures Unit 5
CS8391-Data Structures Unit 5SIMONTHOMAS S Quick sort is an internal sorting technique that uses the divide and conquer approach. It works by picking a pivot element and partitioning the array so that elements less than the pivot are moved left and greater elements right. The pivot is placed in its correct position, then quick sort is recursively applied to the left and right subarrays. It has a best case of O(n log n) and average case of O(n log n), but worst case of O(n^2).
Class13_Quicksort_Algorithm.pdf
Class13_Quicksort_Algorithm.pdfAkashSingh625550 Quick Sort is a sorting algorithm that partitions an array around a pivot element, recursively sorting the subarrays. It has a best case time complexity of O(n log n) when partitions are evenly divided, and worst case of O(n^2) when partitions are highly imbalanced. While fast, it is unstable and dependent on pivot selection. It is widely used due to its efficiency, simplicity, and ability to be parallelized.
Quicksort algorithm and implantation process
Quicksort algorithm and implantation processsamiulhasan0186 Quick sort is a sorting algorithm that uses divide-and-conquer to partition an array into two sub-arrays based on a pivot element, and then recursively sorts the sub-arrays. It works by picking a pivot element, partitioning the array into elements less than or equal to the pivot and elements greater than the pivot, and then applying quicksort recursively on the two sub-arrays. Quick sort has an average time complexity of O(nlogn) and is often faster in practice than other popular sorting algorithms like merge sort and heap sort.
Quick sort
Quick sortAfaq Mansoor Khan Quicksort is a divide and conquer algorithm that works by partitioning an array around a pivot value and recursively sorting the subarrays. It first selects a pivot element and partitions the array by moving all elements less than the pivot before it and greater elements after it. The subarrays are then recursively sorted through this process. When implemented efficiently with an in-place partition, quicksort is one of the fastest sorting algorithms in practice, with average case performance of O(n log n) time but worst case of O(n^2) time.
quicksort (1).ppt
quicksort (1).pptBalasubramanian699229 Quicksort is a divide-and-conquer sorting algorithm that has average case performance of O(N log N). It works by recursively dividing the array into two partitions based on a pivot value and sorting them independently. While quicksort's average case is efficient, its worst case is O(N^2) if the pivot choices are poor, though this seldom occurs in practice with randomization techniques. Quicksort is generally faster than mergesort due to its simpler in-place partitioning avoiding extra data movement.
Quick sort by Sania Nisar
Quick sort by Sania NisarSania Nisar The document provides an overview of the quicksort sorting algorithm, detailing its method of arranging elements in ascending or descending order. It outlines the choice of pivot for partitioning the array and includes pseudocode and a C++ implementation of the algorithm. Quicksort's complexities indicate that it averages O(n log n) efficiency, with a worst-case scenario of O(n²), though the latter can typically be avoided.
quick sort by deepak.pptx
quick sort by deepak.pptxDeepakM509554 Quicksort is an efficient sorting algorithm that uses a divide-and-conquer approach. It works by partitioning an array around a pivot value, and then recursively sorting the subarrays. In the best case when the array is partitioned evenly, quicksort runs in O(n log n) time. In the worst case of a sorted or reverse sorted array, it runs in O(n^2) time. Using a median-of-three approach for pivot selection helps avoid worst case behavior in typical cases.
Lecture 3.3.4 Quick sort.pptxIIIIIIIIIII
Lecture 3.3.4 Quick sort.pptxIIIIIIIIIIIanshsaini1603 The document covers the quick sort algorithm, a widely used and efficient sorting method that operates on the divide and conquer principle, making n log n comparisons in average cases. It explains the process of selecting a pivot and partitioning the array into subarrays, followed by recursive sorting and combining the results. Additionally, the document discusses various strategies for choosing an optimal pivot to enhance the algorithm's performance.
jyothi(22D21A0547)DAA.pptx in DAA computer
jyothi(22D21A0547)DAA.pptx in DAA computerMadhurimaKomanduru Quick sort is a divide-and-conquer sorting algorithm that efficiently rearranges elements based on a pivot, invented by Tony Hoare in 1960. Its advantages include speed, minimal memory usage, and adaptability for various data structures, while key features involve partitioning and recursion. Effective pivot selection is crucial for optimizing performance, with specific techniques available to improve sorting efficiency.
Data Structure Sorting
Data Structure SortingMuhazzab Chouhadry The document details the divide-and-conquer approach applied to sorting algorithms such as merge sort and quick sort, explaining how problems are recursively divided into subproblems. It outlines the steps of merging sorted lists in merge sort and the partitioning method in quick sort to efficiently sort elements without additional merging steps. Additionally, it briefly covers selection sort, emphasizing its procedure for finding and swapping minimum elements in an array.
Unit 5 internal sorting & files
Unit 5 internal sorting & filesDrkhanchanaR Quicksort has average time complexity of O(n log n), but worst case of O(n^2). It has O(log n) space complexity for the recursion stack. It works by picking a pivot element, partitioning the array into sub-arrays of smaller size based on element values relative to the pivot, and recursively
Quick sort
Quick sortDhruv Sabalpara Quicksort is a sorting algorithm that works by partitioning an array around a pivot value, and then recursively sorting the sub-partitions. It chooses a pivot element and partitions the array based on whether elements are less than or greater than the pivot. Elements are swapped so that those less than the pivot are moved left and those greater are moved right. The process recursively partitions the sub-arrays until the entire array is sorted.
09 QUICK SORT Design and Analysis of algorithms
09 QUICK SORT Design and Analysis of algorithmssyamalamaganti The document discusses the design and analysis of the Quick Sort algorithm, a divide and conquer method that partitions an array around a chosen pivot, leading to recursive sorting of subarrays. Different pivot selection methods are outlined, including picking the first, last, random, or median values, and time complexities for best, average, and worst cases are analyzed. Example problems and comparisons with Merge Sort are also included to enhance understanding of the algorithm's efficiency and application.
Quick_sort1.pptx
Quick_sort1.pptxsandeep54552 Quick sort is a divide and conquer sorting algorithm that works by partitioning an array around a pivot value. It then recursively sorts the sub-arrays on each side of the pivot. The key steps are: 1) Choose a pivot element to divide the array; 2) Partition the array by swapping elements such that all elements less than the pivot come before it and all greater elements come after; 3) Recursively apply the same process to the sub-arrays on each side of the pivot until the entire array is sorted.
Algorithms - "quicksort"
Algorithms - "quicksort"Ra'Fat Al-Msie'deen Quicksort is a divide-and-conquer algorithm that works by partitioning an array around a pivot element and recursively sorting the subarrays. It has average-case performance of O(n log n) but worst-case performance of O(n^2) if the partitioning is badly unbalanced. Choosing the pivot randomly helps ensure close to average-case behavior. The key steps are partitioning the array around a pivot into elements less than or greater than the pivot, and then recursively sorting the two partitions.
Sorting
SortingFahadSaeed39 This document discusses two sorting algorithms: insertion sort and quicksort. Insertion sort builds a sorted array one item at a time by inserting each item into the correct position in a sorted prefix. Quicksort uses divide and conquer by partitioning the array around a pivot value and recursively sorting the subarrays. The quicksort algorithm is generally faster than insertion sort for large arrays but risks stack overflow errors.
Quick sort.pptx
Quick sort.pptxAnbarasan Radhakrishnan R Quicksort is a divide-and-conquer sorting algorithm that works as follows:
1. Pick a pivot element and partition the array around it so that all elements less than the pivot come before elements greater than the pivot.
2. Recursively apply quicksort to the subarrays on each side of the pivot.
The average time complexity of quicksort is O(n log n) because on average the partitioning divides the array into equal halves at each step. However, the worst case is O(n^2) if the array is already sorted. Choosing the median element as the pivot helps avoid this worst case.
Quick sort-Data Structure
Quick sort-Data StructureJeanie Arnoco Quicksort is a divide and conquer sorting algorithm that works by partitioning an array around a pivot value. It then recursively sorts the sub-arrays on each side. The key steps are: 1) Choose a pivot element to split the array into left and right halves, with all elements on the left being less than the pivot and all on the right being greater; 2) Recursively quicksort the left and right halves; 3) Combine the now-sorted left and right halves into a fully sorted array. The example demonstrates quicksorting an array of 6 elements by repeatedly partitioning around a pivot until the entire array is sorted.
Recently uploaded (20)
Tally.ERP 9 at a Glance.book - Tally Solutions .pdf
Tally.ERP 9 at a Glance.book - Tally Solutions .pdfShabista Imam Tally.ERP 9 at a Glance.book, a fully completed guidance to learn tally erp 9.0
Fundamentals of Digital Design_Class_21st May - Copy.pptx
Fundamentals of Digital Design_Class_21st May - Copy.pptxdrdebarshi1993 Basics of Number Systems and Logic Gates
Proposal for folders structure division in projects.pdf
Proposal for folders structure division in projects.pdfMohamed Ahmed Proposal for folders structure division in projects
Engineering Mechanics Introduction and its Application
Engineering Mechanics Introduction and its ApplicationSakthivel M Engineering Mechanics Introduction
Structured Programming with C++ :: Kjell Backman
Structured Programming with C++ :: Kjell BackmanShabista Imam Step into the world of high-performance programming with the Complete Guidance Book of C++ Programming—a definitive resource for mastering one of the most powerful and versatile languages in computer science.
Whether you're a beginner looking to learn the fundamentals or an intermediate developer aiming to sharpen your skills, this book walks you through C++ from the ground up. You'll start with basics like variables, control structures, and functions, then progress to object-oriented programming (OOP), memory management, file handling, templates, and the Standard Template Library (STL).
Microwatt: Open Tiny Core, Big Possibilities
Microwatt: Open Tiny Core, Big PossibilitiesIBM Microwatt is a lightweight, open-source core based on the OpenPOWER ISA.
It’s designed for FPGAs and easy experimentation in chip design.
Ideal for education, prototyping, and custom silicon development.
Fully open, it empowers developers to learn, modify, and innovate.
OCS Group SG - HPHT Well Design and Operation - SN.pdf
OCS Group SG - HPHT Well Design and Operation - SN.pdfMuanisa Waras This course is delivered as a scenario-based course to
provide knowledge of High Pressure and High-Temperature (HPHT) well design, drilling and completion operations. The course is specifically designed to provide an
understanding of the challenges associated with the design
and construction of HPHT wells. The course guides the
participants to work through the various well design
aspects starting from a geological well proposal with an
estimated formation pressure and temperature profile.
Working with real well data allows the participants to learn
not only theory, technicalities and practicalities of drilling
and completing HPHT wells but it also ensures that participants gain real experience in understanding the HPHT issues.
Learning – Types of Machine Learning – Supervised Learning – Unsupervised UNI...
Learning – Types of Machine Learning – Supervised Learning – Unsupervised UNI...23Q95A6706 Learning – Types of Machine Learning – Supervised Learning – Unsupervised Learning- semi supervised learning - The Brain and the Neuron – Design a Learning System – Perspectives and Issues in Machine Learning – Concept Learning Task – Concept Learning as Search – Finding a Maximally Specific Hypothesis – Version Spaces and the Candidate Elimination Algorithm
Week 6- PC HARDWARE AND MAINTENANCE-THEORY.pptx
Week 6- PC HARDWARE AND MAINTENANCE-THEORY.pptxdayananda54 Basics of computer hardware for beginners
VARICELLA VACCINATION: A POTENTIAL STRATEGY FOR PREVENTING MULTIPLE SCLEROSIS
VARICELLA VACCINATION: A POTENTIAL STRATEGY FOR PREVENTING MULTIPLE SCLEROSISijab2 Multiple sclerosis (MS) is a debilitating neurological condition affecting approximately 2.9 million people worldwide. Its cause remains unclear but environmental factors, such as post-childhood Epstein-Barr virus (EBV) infection, are thought to contribute to MS incidence.
Complete University of Calculus :: 2nd edition
Complete University of Calculus :: 2nd editionShabista Imam Master the language of change with the Complete Guidance Book of Calculus—your comprehensive resource for understanding the core concepts and applications of differential and integral calculus. Designed for high school, college, and self-study learners, this book takes a clear, intuitive approach to a subject often considered challenging.
Center Enamel can Provide Aluminum Dome Roofs for diesel tank.docx
Center Enamel can Provide Aluminum Dome Roofs for diesel tank.docxCenterEnamel Center Enamel can Provide Aluminum Dome Roofs for diesel tank.docx
Ad
Quick Sort algorithm for sorting an array of elements
- 1. Quick Sort Quick sort is the most efficient internal sorting technique. It is also called partitioning sort which uses divide and conquer techniques. The quick sort works by partitioning the array A[1],A[2],……A[n] by picking some key value in the array as a pivot element. Pivot element is used to rearrange the elements in the array. Pivot can be the first element of an array and the rest of the elements are moved so that the elements on left side of the pivot are lesser than the pivot, whereas those on the right side are greater than the pivot. Now the pivot element is placed in its correct position. Then quick sort procedure is applied for left array and right array in a recursive manner.
- 4. Example 1 • Consider an unsorted array as follows 40 20 70 14 60 61 97 30 • Here PIVOT=40, i=20, j=30 The value of i is incremented till a[i]<=Pivot and the value of j is decremented till a[j]>Pivot, this process is repeated until i<j. If a[i]>Pivot and a[j]<Pivot and also if i<j then swap a[i] and a[j] If i>j then swap a[j] and a[Pivot] • Once the correct location for PIVOT is found then partition array into left sub array and right sub array, where left sub array contains all the elements less than the PIVOT and right sub array contains all the elements greater than the PIVOT
- 5. Example 1 Passes of Quick Sort 40 20 70 14 60 61 97 30 pivot i j 40 20 70 14 60 61 97 30 pivot i j Swap(a[i],a[j], i.e As i<j swap (70,30) 40 20 30 14 60 61 97 70 pivot i j 40 20 30 14 60 61 97 70 pivot i j 40 40 40 40
- 6. Example 1 Passes of Quick Sort 40 20 30 14 60 61 97 70 pivot i j 40 20 30 14 60 61 97 70 pivot i j 40 20 30 14 60 61 97 70 pivot i j 40 20 30 14 60 61 97 70 pivot i,j 40 40 40 40
- 7. Example 1 Passes of Quick Sort 40 20 30 14 60 61 97 70 pivot j i As i>j swap (a[j],a[pivot] i.e swap (60,40) [[ 14 20 30 40 60 61 97 70 • Now the pivot element has reached its correct position. • The elements lesser than the pivot {14,20,30} is considered as left sub array. • The elements greater than the pivot {60,61,97,70} is considered as right sub array. • Then qsort procedure is applied recursively for both these arrays. 40
- 8. Example 2
- 9. Example 2
- 10. Example 2
- 11. Example 2