Basic Sorting Algorithms using Haskell

Pi19404
July 29, 2013

Contents

Contents
Basic Sorting Algorithms using Haskell
0.1 Introduction . . . . . . 0.2 Bubble Sort . . . . . . . 0.2.1 Implementation 0.3 Selection Sort . . . . . 0.3.1 Implementation 0.4 Insertion Sort . . . . . 0.4.1 Implementation 0.4.2 Implementation References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3
3 3 3 4 5 6 6 7 7

2|7

Basic Sorting Algorithms using Haskell

Basic Sorting Algorithms using Haskell

0.1 Introduction
In this article we will look at Some basic Sorting Algorithm Like Bubble sort,Selection Sort and Insertion Sort which provide a simple introduction to divide and Conquer algorithm

0.2 Bubble Sort

This is a crude sorting algorithm.it passes sequentially over the list comparing each value with immediately after it.if the first value is greater than second then the position are switched. This is performed at most N times. The algorithm exits when no changes occur in current run of the algorithm. The worst case performance of algorithm in
O (N

0.2.1 Implementation
The implementation of algorithm in Haskel is provided. The algorithm takes as input a list to be sorted. The first of list is element x,second element x2 and xs which denotes the rest of the list. The idea is to check if x is greater or x2 or not ,if yes a new list is created with x and x2 replaced. if original list x; x2; xs then new list is x2; x; xs. Now since x2 is already in minimum position the remaining elements of list x; xs are required to be sorted.The same method is called in recursive fashion the new list as x; xs.

3|7

Basic Sorting Algorithms using Haskell

This operations needs to be performed atleast N times for the sorting algorithm to terminate. Termination condition occurs before N iterations if sorted and input array are the same. In the code it is checked whether this condition is satisified. The output is a sorted list as well as number of iterations taken to sort the list.

-- bubble sort import Data.Char (digitToInt) -- running the loop till sorting in complete or N iterations : bubble_sort' :: Ord a => [a] ->Int->([a],Int) bubble_sort' s i = case (_bsort s) of t | i==(length(s)) || (t==s) ->(t,i) | otherwise ->((bubble_sort' (t) (i+1))) where -- x,x2 first 2 elements , xs remaining of the list -- compare x with x2 ,if x>x2 replace x with x2 in the list,can again perform -- comparision with remaining list -- if x<x2 then we proceed to compare the remaining elements from x2 to xs -- replace elements _bsort(x:x2:xs) | x>x2=x2:(_bsort (x:xs)) -- already sorted | otherwise =x:(_bsort(x2:xs)) _bsort s = s -- returns the sorted list and number of iterations take to perform -- sorting operation bubble_sort :: Ord a => [a] ->([a],Int) bubble_sort s = bubble_sort' s 0

0.3 Selection Sort

The ideal of selection sort is to find the next larget element in the list and place it in the final position of the list. We begin finding the maximum element in the array ,replacing it with final element in the list.

4|7

Basic Sorting Algorithms using Haskell In the next iteration ,we find maximum element in list excluding the final element and replacing it with element in second last position. This action is performed recursively till no other members of list remain to be processed. Thus we are required to find the maximum of N elements, to do this we perform N comparisons. We get a maximum and then sort a list of length N-1 recursively. Thus total number of comparisons N + which is approximately O(N 2 ) for large N .
(N

1) +

:::

1 =

n(n

1)

=2

0.3.1 Implementation
The input to the algorithm is a unordered list, sorted list is initially empty. As each step of algorithm,elements are added to sorted list and removed from unsorted list.

-- selection sort selection_sort' :: Ord a=>[a]->[a]->Int->([a],Int) -- required with no elements in unsorted list selection_sort' sorted [] i = (sorted,i) selection_sort' sorted unsorted i -- when no elements in unsorted list ,another way | length(unsorted)==0 =(sorted,i) | otherwise = selection_sort' (minx:sorted) ( delete minx unsorted ) (i+1) -- elements in unsorted list,find the maximum -- remove from unsorted list -- add to head of the sorted list where -- find the maximum in unsorted list minx=(maximum unsorted) selection_sort :: Ord a => [a]->([a],Int) selection_sort s = selection_sort' [] s 0

5|7

Basic Sorting Algorithms using Haskell

0.4 Insertion Sort

Consider a list with N elements.The list is divided into 2 parts sorted and unsorted section. At each iteration a element is taken from the unsorted list and placed in appriopriate position in the sorted list. intitially the sorted list is empty and unsorted list the input list. The first element is now placed in the sorted list. Now the 2nd element of unsorted list is compared with the element is sorted list and place in appropriate position in the sorted list. Like selection sort this will also require computation of the order of O(N 2 ).

0.4.1 Implementation
Input is unordered list and output is ordered list and number of iterations. A recursive function _isort to find the proper position in the array is required which performs comparison operation and places the element at right position in the array. A recurive insertion_sort function is called after each time we place the array in the proper place after calling _isort

-- function place element x is right position in list (y:ys) _isort :: Ord a=>a->[a]->[a] _isort x []= [x] --- if ordered position found _isort x (y:ys) | x<y = x:y:ys -- finding ordered position after y in ys | otherwise = y:(_isort x ys) --return sorted list and number of iterations insertion_sort' :: Ord a=>[a]->[a]->Int->([a],Int)

6|7

Basic Sorting Algorithms using Haskell

-- no elements in unsorted list insertion_sort' sorted [] i = (sorted,i) -- recursive call insertion_sort' sorted (x:xs) i = insertion_sort' ( _isort x sorted ) xs (i+1) -- main function for insertion sort insertion_sort :: Ord a => [a]->([a],Int) insertion_sort s = insertion_sort' [] s 0

0.4.2 Implementation
Ill be implementing all the algorithms using haskel. Since recursion is basic mechanism to loop in Haskell ,it fits in naturally within recursive algorithmic structure of divide and conquer algorithms. The code can be found at https://github.com/pi19404/m19404/blob/ master/Algorithm/sort/sort.hs

7|7