Design and Analysis of Algorithms

(CSE 5311)

Spring 2007

Team Project

April 30, 2007

Shruthi Komal Gudipati

 Project Report
Floyd Warshall’s :
• Algorithm is a Dynamic programming formulation to solve the All-pairs
shortest paths problem on a Directed Graph
• Complexity of Algorithm is Θ(v3)
• It works for even Negative-Weight edges but negative-Weight cycle is an
Exception for any Algorithm.
• The Algorithm considers the INTERMEDIATE vertices of the shortest path .

Johnson’s:
• Algorithm is another All-Source shortest path as Floyd-Warshall’s.
• Complexity is O( V2log2V + VE ).
• This Algorithm is better suited for Sparse Graphs.
• This algorithm is better than Floyd-Warshall’s for sparse graphs
• It considers Adjacency list as input
• Johnson’s Algorithm uses Bellman-Ford and Dijkstra’s algorithms.
• Reweighting technique is used which helps to apply Dijkstra’s for finding the
Shortest paths
• First Bellman-Ford Algorithm is applied then after Reweighting technique is
used Dijkstra’s algorithm is used

Comparison & Conclusion:

• Floyd Warshall’s is best suited for Dense graphs and takes input as an
Adjacency Matrix
• Johnson’s is best suited for Sparse graphs and takes input in the form of
Adjacency List
S.No Johnson’s Floyd’s

Connectivity of each vertex is 10 67269 61020

Connectivity is |V|/2 for each vertex 37934 33951

A Fully connected graph 34090 34776

A Ring 29481 34995

All above values are in milliseconds

QuickSort
• Quicksort sorts by employing a divide and conquer strategy to divide a list into
two sub-lists

The steps include:

1. Pick an element, called a pivot, from the list.

2. Reorder the list so that all elements which are less than the pivot come before the
pivot and so that all elements greater than the pivot come after it (equal values can
go either way). After this partitioning, the pivot is in its final position. This is
called the partition operation
3. Recursively sort the sub-list of lesser elements and the sub-list of greater elements
4. The base case of the recursion are lists of size zero or one, which are always
sorted.
5. This sort is a variation of the lesser known Hill Sort[.
6. The algorithm always terminates because it puts at least one element in its final
place on each iteration (the loop invariant).
7. Quicksort is usually O(n log n) but in the worst case slows to O(n2)

Disadvantage:

• Quicksort and its variations remains the same: The worst-case behavior of O(n’) comparisons
occurs when a list is nearly sorted or nearly sorted in reverse order, although it would seem that a
completely sorted or nearly sorted list would take the least time to sort

HeapSort
1. Heapsort is always O(n log n)
2. Uses binary tree
3. To sort:

heapify the array;

while the array isn’t empty {
remove and replace the root;
reheap the new root node;
}
MergeSort
• Step 1
– Divide
• Divide the n-element sequence to be sorted into two
subsequences of n/2 elements each
• Step 2
– Conquer
• Sort the subsequences recursively using merge sort
• When the size of the sequences is 1 there is nothing more to do
• Step 3
– Combine
• Merge the two sorted subsequences
• Running time insensitive of the input
• Advantages:
– Guaranteed to run in Θ(nlgn)
• Disadvantage
• Requires extra space ≈N

BSort ( Quick Sort + Bubble Sort).

1. Works best for nearly sorted lists as well as nearly sorted in reverse
2. For all distribution of keys within a file, Bsort requires no more than O(n logn)
comparisons.
3. For sorted lists or lists sorted in reverse, the algorithm takes O(n) comparisons
4. Bsort uses the technique associated with Bubble sort
5. If the list is sorted, the algorithm terminates and further passes are not necessary
6. It will be shown that Bsort has no “worst case” behavior, that it works best for nearly sorted lists,
and on an overall basis improves the average performance of Quicksort.

• Pseudocode
Experimental Results

Sorted List
Nof Inputs 20000 10000 2000
Quick Sort 23260 5126 773
MergeSort 5971 2136 415
HeapSort 12319 4474 638
Bsort 1324 725 133

Reverse Sorted List

Quick Sort 8979 4225 793

MergeSort 4716 2819 417
HeapSort 7933 3585 570
Bsort 1521 759 140

Random Numbers

Quick Sort 8938 4242 960

MergeSort 6468 3206 647
HeapSort 8778 4147 658
Bsort 3547 1760 295

Identical Numbers

Quick Sort 7390 3372 638

MergeSort 4743 2126 403
HeapSort 4210 828 63
Bsort Stack OverflowStack Overflow 6722

25 % of the No:s are Sorted

Quick Sort 8917 4242 794

MergeSort 6087 2948 513
HeapSort 11912 4484 627
Bsort 7859 1735 299