Searching techniques involve finding a value with specified properties within a collection. Linear searching compares each item sequentially until a match is found, taking O(n) time. Binary searching requires a sorted list and compares the middle item first, reducing the search space by half with each comparison, taking O(log n) time on average. Sorting rearranges elements in ascending or descending order using techniques like bubble, insertion, and selection sort that have O(n^2) worst-case time and quicksort that has an average case of O(n log n) time.
ppt of class and methods in java,recursion in java,nested class,java,command line argument,method overloading,call by value,call by reference,constructor overloading core java ppt
A presentation about the ideas of recursion and recursive functions.
This is my lecture presentation during A. Paruj Ratanaworabhan’s basic preparatory programming course for freshmen: Introduction to Programming: A Tutorial for New Comers Using Python
ppt of class and methods in java,recursion in java,nested class,java,command line argument,method overloading,call by value,call by reference,constructor overloading core java ppt
A presentation about the ideas of recursion and recursive functions.
This is my lecture presentation during A. Paruj Ratanaworabhan’s basic preparatory programming course for freshmen: Introduction to Programming: A Tutorial for New Comers Using Python
In the binary search, if the array being searched has 32 elements in.pdfarpitaeron555
In the binary search, if the array being searched has 32 elements in it, how many elements of the
array must be examined to be certain that the array does not contain the key? What about 1024
elements? Note: the answer is the same regardless of whether the algorithm is recursive or
iterative.
Solution
Binary Search Algorithm- Fundamentals, Implementation and Analysis
Hitesh Garg | May 15, 2015 | algorithms | 5 Comments
Binary Search Algorithm and its Implementation
In our previous tutorial we discussed about Linear search algorithm which is the most basic
algorithm of searching which has some disadvantages in terms of time complexity,so to
overcome them to a level an algorithm based on dichotomic (i.e. selection between two distinct
alternatives) divide and conquer technique is used i.e. Binarysearch algorithm and it is used to
find an element in a sorted array (yes, it is a prerequisite for this algorithm and a limitation too).
In this algorithm we use the sorted array so as to reduce the time complexity to O(log n). In this,
size of the elements reduce to half after each iteration and this is achieved by comparing the
middle element with the key and if they are unequal then we choose the first or second half,
whichever is expected to hold the key (if available) based on the comparison i.e. if array is sorted
in an increasing manner and the key is smaller than middle element than definitely if key exists,
it will be in the first half, we chose it and repeat same operation again and again until key is
found or no more elements are left in the array.
Recursive Pseudocode:
1
2
3
4
5
6
7
8
9
10
11
12
// initially called with low = 0, high = N – 1
BinarySearch_Right(A[0..N-1], value, low, high) {
// invariants: value >= A[i] for all i < low
value < A[i] for all i > high
if (high < low)
return low
mid = low +((high – low) / 2) // THIS IS AN IMPORTANT STEP TO AVOID BUGS
if (A[mid] > value)
return BinarySearch_Right(A, value, low, mid-1)
else
return BinarySearch_Right(A, value, mid+1, high)
}
Iterative Pseudocode:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
BinarySearch_Right(A[0..N-1], value) {
low = 0
high = N - 1
while (low <= high) {
// invariants: value >= A[i] for all i < low
value < A[i] for all i > high
mid = low +((high – low) / 2) // THIS IS AN IMPORTANT STEP TO AVOID BUGS
if (A[mid] > value)
high = mid - 1
else
low = mid + 1
}
return low
}
Asymptotic Analysis
Since this algorithm halves the no of elements to be checked after every iteration it will take
logarithmic time to find any element i.e. O(log n) (where n is number of elements in the list) and
its expected cost is also proportional to log n provided that searching and comparing cost of all
the elements is same
Data structure used -> Array
Worst case performance -> O(log n)
Best case performance -> O(1)
Average case performance -> O(log n)
Worst case space complexity -> O(1)
So the idea is-
RECURSIVE Implementation of Binary search in C programming language
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
.
This is an archive of general information about a technical subject of computing. Information technology (IT) is a set of related fields that encompass computer systems, software, programming languages and data and information processing and storage.[1] IT forms part of information and communications technology (ICT).[2] An information technology system (IT system) is generally an information system, a communications system, or, more specifically speaking, a computer system — including all hardware, software, and peripheral equipment — operated by a limited group of IT users, and an IT project usually refers to the commissioning and implementation of an IT system.[3]
Although humans have been storing, retrieving, manipulating, and communicating information since the earliest writing systems were developed,[4] the term information technology in its modern sense first appeared in a 1958 article published in the Harvard Business Review; authors Harold J. Leavitt and Thomas L. Whisler commented that "the new technology does not yet have a single established name. We shall call it information technology (IT)."[5] Their definition consists of three categories: techniques for processing, the application of statistical and mathematical methods to decision-making, and the simulation of higher-order thinking through computer programs.[5]
Kubernetes & AI - Beauty and the Beast !?! @KCD Istanbul 2024Tobias Schneck
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
LF Energy Webinar: Electrical Grid Modelling and Simulation Through PowSyBl -...DanBrown980551
Do you want to learn how to model and simulate an electrical network from scratch in under an hour?
Then welcome to this PowSyBl workshop, hosted by Rte, the French Transmission System Operator (TSO)!
During the webinar, you will discover the PowSyBl ecosystem as well as handle and study an electrical network through an interactive Python notebook.
PowSyBl is an open source project hosted by LF Energy, which offers a comprehensive set of features for electrical grid modelling and simulation. Among other advanced features, PowSyBl provides:
- A fully editable and extendable library for grid component modelling;
- Visualization tools to display your network;
- Grid simulation tools, such as power flows, security analyses (with or without remedial actions) and sensitivity analyses;
The framework is mostly written in Java, with a Python binding so that Python developers can access PowSyBl functionalities as well.
What you will learn during the webinar:
- For beginners: discover PowSyBl's functionalities through a quick general presentation and the notebook, without needing any expert coding skills;
- For advanced developers: master the skills to efficiently apply PowSyBl functionalities to your real-world scenarios.
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
Slack (or Teams) Automation for Bonterra Impact Management (fka Social Soluti...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on the notifications, alerts, and approval requests using Slack for Bonterra Impact Management. The solutions covered in this webinar can also be deployed for Microsoft Teams.
Interested in deploying notification automations for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
DevOps and Testing slides at DASA ConnectKari Kakkonen
My and Rik Marselis slides at 30.5.2024 DASA Connect conference. We discuss about what is testing, then what is agile testing and finally what is Testing in DevOps. Finally we had lovely workshop with the participants trying to find out different ways to think about quality and testing in different parts of the DevOps infinity loop.
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
Essentials of Automations: Optimizing FME Workflows with ParametersSafe Software
Are you looking to streamline your workflows and boost your projects’ efficiency? Do you find yourself searching for ways to add flexibility and control over your FME workflows? If so, you’re in the right place.
Join us for an insightful dive into the world of FME parameters, a critical element in optimizing workflow efficiency. This webinar marks the beginning of our three-part “Essentials of Automation” series. This first webinar is designed to equip you with the knowledge and skills to utilize parameters effectively: enhancing the flexibility, maintainability, and user control of your FME projects.
Here’s what you’ll gain:
- Essentials of FME Parameters: Understand the pivotal role of parameters, including Reader/Writer, Transformer, User, and FME Flow categories. Discover how they are the key to unlocking automation and optimization within your workflows.
- Practical Applications in FME Form: Delve into key user parameter types including choice, connections, and file URLs. Allow users to control how a workflow runs, making your workflows more reusable. Learn to import values and deliver the best user experience for your workflows while enhancing accuracy.
- Optimization Strategies in FME Flow: Explore the creation and strategic deployment of parameters in FME Flow, including the use of deployment and geometry parameters, to maximize workflow efficiency.
- Pro Tips for Success: Gain insights on parameterizing connections and leveraging new features like Conditional Visibility for clarity and simplicity.
We’ll wrap up with a glimpse into future webinars, followed by a Q&A session to address your specific questions surrounding this topic.
Don’t miss this opportunity to elevate your FME expertise and drive your projects to new heights of efficiency.
Software Delivery At the Speed of AI: Inflectra Invests In AI-Powered QualityInflectra
In this insightful webinar, Inflectra explores how artificial intelligence (AI) is transforming software development and testing. Discover how AI-powered tools are revolutionizing every stage of the software development lifecycle (SDLC), from design and prototyping to testing, deployment, and monitoring.
Learn about:
• The Future of Testing: How AI is shifting testing towards verification, analysis, and higher-level skills, while reducing repetitive tasks.
• Test Automation: How AI-powered test case generation, optimization, and self-healing tests are making testing more efficient and effective.
• Visual Testing: Explore the emerging capabilities of AI in visual testing and how it's set to revolutionize UI verification.
• Inflectra's AI Solutions: See demonstrations of Inflectra's cutting-edge AI tools like the ChatGPT plugin and Azure Open AI platform, designed to streamline your testing process.
Whether you're a developer, tester, or QA professional, this webinar will give you valuable insights into how AI is shaping the future of software delivery.
Software Delivery At the Speed of AI: Inflectra Invests In AI-Powered Quality
Unit6 jwfiles
1. Searching techniques
Searching :
It is a process to find whether a particular value with specified properties is present or not
among a collection of items.
If the value is present in the collection, then searching is said to be successful, and it
returns the location of the value in the array.
Otherwise, if the value is not present in the array, the searching process displays the
appropriate message and in this case searching is said to be unsuccessful.
1) Linear or Sequential Searching 2) Binary Searching
int main( ) { Linear_Search (A[ ], N, val , pos )
int arr [ 50 ] , num , i , n , pos = -1; Step 1 : Set pos = -1 and k = 0
printf ("How many elements to sort : "); Step 2 : Repeat while k < N
scanf ("%d", &n); Begin
printf ("n Enter the elements : nn"); Step 3 : if A[ k ] = val
for( i = 0; i < n; i++ ) { Set pos = k
printf (“arr [%d ] : “ , i ); print pos
scanf( "%d", &arr[ i ] ); Goto step 5
} End while
printf(“nEnter the number to be searched : “); Step 4 : print “Value is not present”
scanf(“%d”,&num); Step 5 : Exit
for(i=0;i<n;i++)
if( arr [ i ] == num ) { Searches
pos = i ; break; -- for each item one by one in the list from
} the first, until the match is found.
if ( pos == -1 ) printf(“ %d does not exist ”,num); Efficiency of Linear search :
else -- Executes in O ( n ) times where n is the
printf(“ %d is found at location : %d”, num , pos); number of elements in the list.
2. Binary Searching
Algorithm:
• Before searching, the list of items should be sorted in ascending order.
• We first compare the key value with the item in the position of the array. If there is a match, we
can return immediately the position.
• if the value is less than the element in middle location of the array, the required value is lie in
the lower half of the array.
• if the value is greater than the element in middle location of the array, the required value is lie
in the upper half of the array.
• We repeat the above procedure on the lower half or upper half of the array.
Binary_Search (A [ ], U_bound, VAL)
Step 1 : set BEG = 0 , END = U_bound , POS = -1
Step 2 : Repeat while (BEG <= END ) void binary_serch ( int a [], int n, int val ) {
Step 3 : set MID = ( BEG + END ) / 2 int end = n - 1, beg = 0, pos = -1;
Step 4 : if A [ MID ] == VAL then while( beg <= end ) {
POS = MID mid = ( beg + end ) / 2;
print VAL “ is available at “, POS if ( val == a [ mid ] ) {
GoTo Step 6 pos = mid;
End if printf(“%d is available at %d”,val, pos );
if A [ MID ] > VAL then break;
set END = MID – 1 }
Else if ( a [ mid ] > val ) end = mid – 1;
set BEG = MID + 1 else beg = mid + 1;
End if }
End while if ( pos = - 1)
Step 5 : if POS = -1 then printf( “%d does not exist “, val );
print VAL “ is not present “ }
End if
Step 6 : EXIT
3. Sorting
Sorting is a technique to rearrange the elements of a list in ascending or
descending order, which can be numerical, lexicographical, or any user-defined order.
Ranking of students is the process of sorting in descending order.
EMCET Ranking is an example for sorting with user-defined order.
EMCET Ranking is done with the following priorities.
i) First priority is marks obtained in EMCET.
ii) If marks are same, the ranking will be done with comparing marks obtained in
the Mathematics subject.
iii) If marks in Mathematics subject are also same, then the date of births will be
compared.
Internal Sorting : Types of Internal Sortings
If all the data that is to be sorted can be accommodated
at a time in memory is called internal sorting. Bubble Sort
External Sorting :
Insertion Sort
It is applied to Huge amount of data that cannot be Selection Sort
accommodated in memory all at a time. So data in disk
or file is loaded into memory part by part. Each part that Quick Sort
is loaded is sorted separately, and stored in an
intermediate file and all parts are merged into one single Merge Sort
sorted list.
4. Bubble Sort
Bubbles up the highest
Unsorted Sorted
Bubble_Sort ( A [ ] , N )
Step 1 : Repeat For P = 1 to N – 1
10 54 54 54 54 54 Begin
Step 2 : Repeat For J = 1 to N – P
47 10 47 47 47 47 Begin
Step 3 : If ( A [ J ] < A [ J – 1 ] )
12 47 10 23 23 23 Swap ( A [ J ] , A [ J – 1 ] )
End For
54 12 23 10 19 19 End For
Step 4 : Exit
19 23 12 19 10 12
Complexity of Bubble_Sort
23 19 19 12 12 10 The complexity of sorting algorithm is
depends upon the number of comparisons
Original After After After After After that are made.
List Pass 1 Pass 2 Pass 3 Pass 4 Pass 5 Total comparisons in Bubble sort is
n ( n – 1) / 2 ≈ n 2 – n
Complexity = O ( n 2 )
5. void print_array (int a[ ], int n) {
int i;
for (i=0;I < n ; i++) printf("%5d",a[ i ]);
Bubble Sort
}
void bubble_sort ( int arr [ ], int n) {
int pass, current, temp;
For pass = 1 to N - 1
for ( pass=1;(pass < n) ;pass++) {
for ( current=1;current <= n – pass ; current++) {
if ( arr[ current - 1 ] > arr[ current ] ) {
temp = arr[ current - 1 ]; For J = 1 to N - pass
arr[ current - 1 ] = arr[ current ];
arr[ current ] = temp;
} T
A[J–1]>A[J]
}
}
} F
int main() { Temp = A [ J – 1 ]
int count,num[50],i ; A[J–1]=A[J]
printf ("How many elements to be sorted : "); A [ J ] = Temp
scanf ("%d", &count);
printf("n Enter the elements : nn");
for ( i = 0; i < count; i++) {
printf ("num [%d] : ", i ); scanf( "%d", &num[ i ] );
}
printf("n Array Before Sorting : nnn");
print_array ( num, count );
Return
bubble_sort ( num, count);
printf("nnn Array After Sorting : nnn");
print_array ( num, count );
}
6. TEMP Insertion Sort
Insertion_Sort ( A [ ] , N )
78 23 45 8 32 36 Step 1 : Repeat For K = 1 to N – 1
23 Begin
Step 2 : Set Temp = A [ K ]
Step 3 : Set J = K – 1
23 78 45 8 32 36 Step 4 : Repeat while Temp < A [ J ] AND J >= 0
45 Begin
Set A [ J + 1 ] = A [ J ]
Set J = J - 1
23 45 78 8 32 36 End While
Step 5 : Set A [ J + 1 ] = Temp
8
End For
Step 4 : Exit
8 23 45 78 32 36
32 insertion_sort ( int A[ ] , int n ) {
int k , j , temp ;
8 23 32 45 78 36 for ( k = 1 ; k < n ; k++ ) {
temp = A [ k ] ;
36 j = k - 1;
while ( ( temp < A [ j ] ) && ( j >= 0 ) ) {
8 23 32 36 45 78 A[j+1] =A[j];
j--;
Complexity of Insertion Sort }
Best Case : O ( n ) A [ j + 1 ] = temp ;
Average Case : O ( n2 ) }
Worst Case : O ( n2 ) }
7. Smallest Selection Sort ( Select the smallest and Exchange )
Selection_Sort ( A [ ] , N )
8 23 78 45 8 32 56 Step 1 : Repeat For K = 0 to N – 2
Begin
Step 2 : Set POS = K
Step 3 : Repeat for J = K + 1 to N – 1
23 8 78 45 23 32 56 Begin
If A[ J ] < A [ POS ]
Set POS = J
32 8 23 45 78 32 56 End For
Step 5 : Swap A [ K ] with A [ POS ]
End For
Step 6 : Exit
45 8 23 32 78 45 56
selection_sort ( int A[ ] , int n ) {
int k , j , pos , temp ;
for ( k = 0 ; k < n - 1 ; k++ ) {
56 8 23 32 45 78 56 pos = k ;
for ( j = k + 1 ; j <= n ; j ++ ) {
if ( A [ j ] < A [ pos ] )
8 23 32 45 56 78 pos = j ;
}
temp = A [ k ] ;
Complexity of Selection Sort A [ k ] = A [ pos ] ;
Best Case : O ( n2 )
A [ pos ] = temp ;
Average Case : O ( n2 ) }
Worst Case : O ( n2 ) }
8. Selection sort
Insertion sort
k = 0; k < n - 1 ; k++
k = 1; k < n ; k++
pos = k
temp = a [ k ]
j=k-1
j = k + 1 ; j < n ; j++
temp < a [ j ] && j >= 0
a[ j ] < a[ pos ]
a[j+1]=a[j] pos = j
j=j-1
a [ j + 1 ] = temp temp = a[ k ]
a [ k ] = a [ pos ]
a [ pos ] = temp
return
return
9. Bubble sort – Insertion sort – Selection sort
Bubble Sort :
-- very primitive algorithm like linear search, and least efficient .
-- No of swappings are more compare with other sorting techniques.
-- It is not capable of minimizing the travel through the array like insertion sort.
Insertion Sort :
-- sorted by considering one item at a time.
-- efficient to use on small sets of data.
-- twice as fast as the bubble sort.
-- 40% faster than the selection sort.
-- no swapping is required.
-- It is said to be online sorting because it continues the sorting a list as and when it receives
new elements.
-- it does not change the relative order of elements with equal keys.
-- reduces unnecessary travel through the array.
-- requires low and constant amount of extra memory space.
-- less efficient for larger lists.
Selection sort :
-- No of swappings will be minimized. i.e., one swap on one pass.
-- generally used for sorting files with large objects and small keys.
-- It is 60% more efficient than bubble sort and 40% less efficient than insertion sort.
-- It is preferred over bubble sort for jumbled array as it requires less items to be exchanged.
-- uses internal sorting that requires more memory space.
-- It cannot recognize sorted list and carryout the sorting from the beginning, when new elements
are added to the list.
10. Quick Sort – A recursive process of sorting
Original-list of 11 elements :
8 3 2 11 5 14 0 2 9 4 20 Algorithm for Quick_Sort :
Set list [ 0 ] as pivot : -- set the element A [ start_index ] as pivot.
-- rearrange the array so that :
pivot
-- all elements which are less than the pivot
come left ( before ) to the pivot.
8 3 2 11 5 14 0 2 9 4 20 -- all elements which are greater than the pivot
come right ( after ) to the pivot.
Rearrange ( partition ) the elements -- recursively apply quick-sort on the sub-list of
into two sub lists : lesser elements.
pivot -- recursively apply quick-sort on the sub-list of
greater elements.
4 3 2 2 5 0 8 11 9 14 20 -- the base case of the recursion is lists of size
zero or one, which are always sorted.
Sub-list of Sub-list of
lesser elements greater elements
Complexity of Quick Sort
Best Case : O ( n log n )
Apply Quick-sort Apply Quick-sort Average Case : O ( n log n )
recursively recursively Worst Case : O ( n2 )
on sub-list on sub-list
12. Quick Sort – Program
int partition ( int a [ ], int beg, int end ) { void quick_sort(int a[ ] , int beg , int end ) {
int left , right , loc , flag = 0, pivot ; int loc;
loc = left = beg; if ( beg < end ) {
right = end; loc = partition( a , beg , end );
pivot = a [ loc ] ; quick_sort ( a , beg , loc – 1 );
while ( flag == 0 ) quick_sort ( a , loc + 1 , end );
{ }
while( (pivot <= a [ right ] )&&( loc != right ) ) }
right - - ; void print_array (int a [ ],int n) {
if( loc == right ) flag = 1; int i;
else { for ( i = 0 ; I < n ; i++ ) printf( "%5d“ ,a [ i ] ) ;
a [ loc ] = a [ right ] ; }
left = loc + 1 ; int main () {
loc = right; int count , num[ 50 ] , i ;
} printf ("How many elements to sort : ");
while ( (pivot >= a [ left ] ) && ( loc != left ) ) scanf ("%d", &count );
left++; printf ("n Enter the elements : nn");
if( loc == left ) flag = 1; for( i = 0; i < count; i++ ) {
else { printf ("num [%d ] : “ , i );
a [ loc ] = a [ left ] ; scanf( "%d", &num[ i ] );
right = loc - 1; }
loc = left; printf (“ n Array Before Sorting : nnn“ );
} print_array ( num , count ) ;
} quick_sort ( num ,0 , count-1) ;
a [ loc ] = pivot; printf ( "nnn Array After Sorting : nnn“ );
return loc; print_array ( num , count );
} }
13. partition ( int a [ ], int beg, int end ) A B
loc = left = beg F T
loc == left
flag = 0, right = end
pivot = a [ loc ]
a [ loc ] = a [ left ] flag = 1
Flag == 0 right = loc - 1 ;
loc = left;
pivot <= a [ right ]
&& loc != right
a[ loc ] = pivot
right = right - 1
return loc
F T
loc == right quick_sort ( int a [ ], int beg, int end )
a [ loc ] = a [ right ] flag = 1 F T
left = loc + 1 ; loc == left
loc = right;
loc = partition( a , beg , end )
pivot >= a [ left ]
&&loc != left quick_sort ( a , beg , end )
left = left + 1 quick_sort ( a , beg , end )
return
A B
14. Merge Sort ( Divide and conquer )
Divide the array
-- Merge sort technique sorts a given set
39 9 81 45 90 27 72 18 of values by combining two sorted
arrays into one larger sorted arrays.
-- A small list will take fewer steps to sort
39 9 81 45 90 27 72 18 than a large list.
-- Fewer steps are required to construct
a sorted list from two sorted lists than
39 9 81 45 90 27 72 18
two unsorted lists.
-- You only have to traverse each list
39 9 81 45 90 27 72 18 once if they're already sorted .
Merge the elements to sorted array Merge_sort Algorithm
1. If the list is of length 0 or 1, then it is already
sorted.
39 9 81 45 90 27 72 18 Otherwise:
2. Divide the unsorted list into two sublists of
about half the size.
9 39 45 81 27 90 18 72 3. Sort each sublist recursively by re-applying
merge sort.
4. Merge the two sublists back into one
9 39 45 81 18 27 72 90 sorted list.
Time complexity
9 18 27 39 45 72 81 90 Worst case - O(n log n)
Best case - O(nlogn) typical, O(n) natural variant
Average case - O( n log n )
15. Merge Sort - Program
void merge(int a[ ],int low,int high,int mid){
int i, j, k, c[50];
i=low; j=mid+1; k=low;
while( ( i<=mid )&&( j <= high ) ) { void print_array (int a [ ],int n) {
int i;
if( a[ i ]<a[ j ] ){ for ( i = 0 ; I < n ; i++ ) printf( "%5d“ ,a [ i ] ) ;
c[ k ]=a[ i ]; k++; i++; }
}else { int main () {
c[ k ]=a[ j ]; k++; j++; int count , num[ 50 ] , i ;
} printf ("How many elements to sort : ");
} scanf ("%d", &count );
while( i<=mid ) { c[k]=a[ i ]; k++; i++; } printf ("n Enter the elements : nn");
for( i = 0; i < count; i++ ) {
while(j<=high) { c[k]=a[ j ]; k++; j++; } printf ("num [%d ] : “ , i );
for(i=low;i<k;i++) a[ i ]=c[ i ]; scanf( "%d", &num[ i ] );
} }
printf (“ n Array Before Sorting : nnn“ );
void merge_sort(int a[ ], int low, int high){
print_array ( num , count ) ;
int mid;
merge_sort ( num ,0 , count-1) ;
if( low < high) {
printf ( "nnn Array After Sorting : nnn“ );
mid=(low+high)/2; print_array ( num , count );
merge_sort (a, low, mid); }
merge_sort (a, mid+1 ,high);
merge (a, low, high, mid);
}
}
16. merge
i =low ; j = mid+1;k = low
Merge_Sort
i <= mid && j <= high
T F T
F low < high
a[ i ] < a[ j ]
c[ k ] =a [ i ] ; c[ k ] =a [ j ] ; mid = ( low + high ) / 2
k++ ; i++ k++ ; j++
merge_sort (a, low, mid)
i <= mid
merge_sort (a, mid, high )
c[ k ] =a [ i ] ; k++ ; i++
Merge (a, low,high , mid)
j <= high
c[ k ] =a [ j ] ; k++ ; j++
i = low ; i < k ; i ++
Return
a[ i ] = c [ i ]
return
17. www.jntuworld.com
• For More Materials, Text Books, Previous
Papers & Mobile updates of B.TECH,
B.PHARMACY, MBA, MCA of JNTU-HYD,JNTU-
KAKINADA & JNTU-ANANTAPUR visit
www.jntuworld.com