Scribd
Upload
22 views

Design and Analysis of Algorithms

This document contains code for implementing quicksort and mergesort algorithms in C++. For quicksort, it includes functions for swapping elements, printing the array, finding the partition point using the pivot element, and recursively sorting elements. For mergesort, it includes functions for displaying the array, merging two sorted subarrays, and recursively sorting and merging subarrays. The main function provides sample code to test each algorithm on sample input arrays and output the sorted results.

Uploaded by

Mahnoor Mustafa
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
22 views

Design and Analysis of Algorithms

This document contains code for implementing quicksort and mergesort algorithms in C++. For quicksort, it includes functions for swapping elements, printing the array, finding the partition point using the pivot element, and recursively sorting elements. For mergesort, it includes functions for displaying the array, merging two sorted subarrays, and recursively sorting and merging subarrays. The main function provides sample code to test each algorithm on sample input arrays and output the sorted results.

Uploaded by

Mahnoor Mustafa
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

Design and Analysis of Algorithms

Final Project

Submitted To:

Dr. Malik Aamir Arsalan


Submitted By:
Amna Zaheer (2020-BSE-038)
Mahnoor Mustafa (2020-BSE-051)
Tehreem Naz (2020-BSE-066)

Class:
BSE IV-B

Quick Sort & Merge Sort


QUICK SORT

// Quick sort in C++


#include <iostream>
using namespace std;
// function for swapping
void swap(int* a, int* b)
{
int t = *a;
*a = *b;
*b = t;
}
// function for printing the array
void printArray(int array[], int size)
{
int i;
for (i = 0; i < size; i++)
cout << array[i] << " ";
cout << endl;
}
// function to rearrange the array (find the partition point)
int partition(int array[], int low, int high)
{
// selecting the rightmost element as the pivot
int pivot = array[high];
// pointer "i" for greater element
int i = (low - 1);
// traverse each element of the array
// compare them with the pivot
for (int j = low; j < high; j++)
{
if (array[j] <= pivot) {

// if element smaller than pivot is found


// swap it with the greater element pointed by i
i++;
// swap element at i with element at j
swap(&array[i], &array[j]);
}
}
// swap pivot with the greater element at i
swap(&array[i + 1], &array[high]);
// return the partition point
return (i + 1);
}
void quickSort(int array[], int low, int high) {
if (low < high)
{
// find the pivot element such that
// elements smaller than pivot are on left of pivot
// elements greater than pivot are on righ of pivot
int pi = partition(array, low, high);
// recursive call on the left of pivot
quickSort(array, low, pi - 1);
// recursive call on the right of pivot
quickSort(array, pi + 1, high);
}
}
// Main Code
int main() {
int data[] = { 8, 7, 6, 1, 0, 9, 2 };
int n = sizeof(data) / sizeof(data[0]);
cout << "Unsorted Array: \n";
printArray(data, n);
// perform quicksort on data
quickSort(data, 0, n - 1);
cout << "Sorted array in ascending order: \n";
printArray(data, n);
}
MERGE SORT

#include<iostream>
using namespace std;

void display(int* array, int size)


{
for (int i = 0; i < size; i++)
cout << array[i] << " ";
cout << endl;
}
void merge(int* array, int l, int m, int r)
{
int i, j, k, nl, nr;
nl = m - l + 1; //size of the left sub-array
nr = r - m; //size of the right sub-array
int leftarr[nl], rightarr[nr];
//fill left and right sub-arrays
for (i = 0; i < nl; i++)
leftarr[i] = array[l + i];
for (j = 0; j < nr; j++)
rightarr[j] = array[m + 1 + j];
i = 0; j = 0; ;k = l;
//marge temp arrays to real array
while (i < nl && j < nr) {
if (leftarr[i] <= rightarr[j])
{
array[k] = leftarr[i];
i++;
}
else {
array[k] = rightarr[j];
j++;
}
k++;
}
while (i < nl) { //extra element in left array
array[k] = leftarr[i];
i++; k++;
}
while (j < nr) { //extra element in right array
array[k] = rightarr[j];
j++; k++;
}
}
void mergeSort(int* array, int l, int r) {
int m;
if (l < r) //checks if it is single element array
{
int m = l + (r - l) / 2; //finding the middle element
// Recursive function call to Sort first and second arrays
mergeSort(array, l, m); //first half
mergeSort(array, m + 1, r); //second half
merge(array, l, m, r); //merge back
}
}
int main() {
int n;
cout << "Enter the number of elements: ";
cin >> n;
int arr[n]; //create an array with given number of elements
cout << "Enter elements:" << endl;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
cout << "Array before Sorting: ";
display(arr, n);
mergeSort(arr, 0, n - 1); //(n-1) for last index
cout << "Array after Sorting: ";
display(arr, n);
}

You might also like