shell sort fixed i think

Author: rhiwatson

Makefile

@@ -0,0 +1,37 @@
+# a simple makefile for compiling C++ files
+
+# optimization is on
+CC = c++ -03
+# for debuging use this 
+#CC = c++ -g -O0
+
+all: sort
+
+sort: bubble-sort.o insertion-sort.o selection-sort.o shell-sort.o \
+option.o sort.o radix-sort.o
+	$(CC) -o sort bubble-sort.o insertion-sort.o selection-sort.o \
+	       shell-sort.o option.o sort.o radix-sort.o
+
+option.o: option.h option.cpp
+	$(CC) -c option.cpp
+
+bubble-sort.o: sort.h bubble-sort.cpp
+	$(CC) -c bubble-sort.cpp
+
+insertion-sort.o: sort.h insertion-sort.cpp
+	$(CC) -c insertion-sort.cpp
+
+selection-sort.o: sort.h selection-sort.cpp
+	$(CC) -c selection-sort.cpp
+
+shell-sort.o: sort.h shell-sort.cpp
+	$(CC) -c shell-sort.cpp
+
+radix-sort.o: sort.h radix-sort.cpp
+	$(CC) -c radix-sort.cpp
+
+sort.o: sort.h option.h sort.cpp
+	$(CC) -c sort.cpp
+
+clean:
+	/bin/rm -f *.o sort

bubble-sort.cpp

@@ -0,0 +1,33 @@
+//============================================================================
+// Name        : bubble-sort.cpp
+// Author      : 
+// Date        :
+// Copyright   : 
+// Description : Implementation of bubble sort in C++
+//============================================================================
+
+#include "sort.h"
+
+void 
+BubbleSort::sort(int A[], int size)			// main entry point
+{
+  num_cmps = 0;
+  bool done = false;
+  while(!done)
+  {
+	done = true;
+	num_cmps ++;
+	for(int n = 0; n < size ; ++n)
+	{
+		num_cmps++;
+		if(A[n] < A[n-1])
+		{
+			int temp = A[n];
+			A[n] = A[n-1];
+			A[n-1] = temp;
+			done = false;
+		}
+	}
+	num_cmps++;
+	}
+}

generator.cpp

@@ -0,0 +1,48 @@
+//generates the sequences
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <cstdlib>
+#include <ctime>
+#include <cstring>
+using namespace std;
+
+main(int argc, char** argv)
+{
+	int length = 100;
+	bool descending = false;
+	bool random = true;
+	string path = "";
+	if(argc > 1)
+		stringstream(argv[1]) >> length;
+	if(argc > 2)
+		if(strcmp(argv[2], "d")==0)
+		{
+			random = false;
+			descending = true;
+		}
+		else if(strcmp(argv[2], "r")==0)
+		{
+			random = true;
+			descending = false;
+		}
+		else
+		{
+			random = false;
+			descending = false;
+		}
+	if(argc > 3)
+	{
+		path = string(argv[3]);
+	}
+	ofstream file(path.c_str());
+	srand(clock());
+	file<<length<<" ";
+	while(length > 0)
+	{
+		file << (rand())<<" "<< endl;
+		--length;
+	}
+	file.close();
+}

insertion-sort.cpp

@@ -0,0 +1,64 @@
+//============================================================================
+// Name        : insertion-sort.cpp
+// Author      : 
+// Date        :
+// Copyright   : 
+// Description : Implementation of insertion sort in C++
+//============================================================================
+
+#include "sort.h"
+#include <ostream>
+
+void
+InsertionSort::sort(int A[], int size)				// main entry point
+{
+int j=0;
+int temp=0;
+int num=0;
+        for (int i=1; i<size; ++i) 
+        {
+           temp= A[i];
+           j = i-1;
+		   for(num=0; (j >= 0) && (A[j] > temp); num+=2)
+           {
+               A[j+1] = A[j];
+               j -= 1;
+           }
+            A[j+1]=temp;
+			num_cmps+=num;
+        }
+  }
+
+/*int i=0;
+int j=0;
+int key=0;
+{
+for (j=1; j<size; j++)
+{
+key= array[j];
+for (i=j-1; (i>=0) && (array[i]<key); i++)
+{
+array[i+1]= array[i];
+}
+array[i+1]=key;
+}
+return;
+}
+while(A[i]<A[i-1])
+			{
+			temp=A[i-1];
+			A[i-temp] = A[i];
+			A[i]=temp;
+			}
+			
+			
+  int temp=0;
+  int j = 0;
+	for(int i=1; i<size; ++i)
+	{
+	temp=A[i];
+	for(j=i-1; j>=0 && A[j]<temp; ++j)
+	A[j+1]=A[j];
+	}
+	A[j+1]=temp;			*/
+		

option.cpp

@@ -0,0 +1,70 @@
+//============================================================================
+// Name        : option.cpp
+// Author      : TA's
+// Date        :
+// Copyright   : 
+// Description : Command line processing for the sort program
+//============================================================================
+
+#include <iostream>
+#include "option.h"
+
+/* initialize options according to command line */
+void Option::init(int argc, char** argv)
+   throw (InvalidArgument)
+{
+   // loop through all the arguments except for the program name itself
+   for (int i = 1; i < argc; i++)
+      {
+         char* p = argv[i];
+
+         // if option does not start from dash, report an error
+         if (*p != '-') throw InvalidArgument(); 
+
+         switch (p[1]) // switch on whatever comes after dash
+            {
+            case 'a': if (i+1 < argc) alg = argv[++i][0]; break;
+            case 'f': if (i+1 < argc) input_file  = argv[++i]; break;
+            case 'o': if (i+1 < argc) output_file = argv[++i]; break;
+            case 'h': show_help   = true; break;
+            case 'd': show_input  = true; break;
+            case 't': show_time   = true; break;
+            case 'c': show_num_cmps = true; break;
+            case 'p': show_output = true;  break;
+            default : throw InvalidArgument();
+            }
+      }
+
+   if (!show_help && alg!='S' && alg!='B' &&
+       alg!='I' && alg!='H' && alg!= 'R')
+      throw InvalidArgument();          
+}
+
+
+void Option::printUsage() const {
+   std::cout <<
+      "Usage: ./sort [-a ALGORITHM] [-f INPUTFILE] [-o OUTPUTFILE] [-h] "
+      "[-d] [-p] [-t] [-c]\n"
+      "Read an integer sequence and display the sorted sequence, "
+      "a program written by\n"
+      "Author1, Author2 and Author3\n"
+      "Example: ./sort -a S -f input.txt -o output.txt -t -c -p\n"
+      "         ./sort -h\n"
+      "Options:\n"
+      "  -a ALGORITHM    Use ALGORITHM to sort.\n"
+      "     ALGORITHM is a single character representing an algorithm:\n"
+      "     S   (selection sort)\n"
+      "     B   (bubble sort)\n"
+      "     I   (insertion sort)\n"
+      "     H   (shell sort)\n"
+      "     R   (radix sort)\n" 
+      "  -f INPUTFILE    Obtain integers from INPUTFILE instead of STDIN\n"
+      "  -o OUTPUTFILE   Place output message into OUTPUTFILE "
+      "instead of STDOUT\n"
+      "  -h  Display this help and exit\n"
+      "  -d  Display input: unsorted integer sequence\n"
+      "  -p  Display output: sorted integer sequence\n"
+      "  -t  Display running time of the chosen algorithm in milliseconds\n"
+      "  -c  Display number of element comparisons (excluding radix sort)\n";
+}
+

option.h

@@ -0,0 +1,61 @@
+//============================================================================
+// Name        : option.h
+// Author      : TA's
+// Date        :
+// Copyright   : 
+// Description : Command line processing for the sort program
+//============================================================================
+
+#ifndef OPTION_H_
+#define OPTION_H_
+
+#include <stdexcept>
+
+class Option {
+public:
+   // user defined exception class
+   struct InvalidArgument:public std::invalid_argument {
+      InvalidArgument():std::invalid_argument(
+           "Usage: ./sort [-a ALGORITHM] [-f INPUTFILE] [-o OUTPUTFILE] "
+           "[-h] [-d] [-t] [-c]\n"
+           "Try `./sort -h' for more information.") {}
+   };
+  
+private:
+   /// variables representing command line options provided by the user
+   char        alg;         /// Algorithm selected
+   const char* input_file;  /// Name of the input file if provided
+   const char* output_file; /// Name of the output file if provided
+   bool        show_help;   /// Whether to show help or not
+   bool        show_input;  /// Whether to display unsorted input sequence
+   bool        show_time;   /// Whether to display running time
+   bool        show_num_cmps;/// Whether to display number of
+                             /// element comparisons
+   bool        show_output;  /// Whether to display sorted input sequence
+
+public:  
+   Option() : alg(0), input_file(NULL), output_file(NULL),
+              show_help(false), show_input(false), show_time(false),
+              show_num_cmps(false), show_output(false) {}
+  
+   /* initialize options according to command line */
+   void init(int argc, char** argv)
+      throw (InvalidArgument);
+  
+   /* accessor functions */
+   char getAlg() const { return alg; } 
+   const char* getInputFile() const { return input_file; }
+   const char* getOutputFile() const { return output_file; }
+  
+   /* query functions */
+   bool showHelp() const { return show_help; }
+   bool showInput() const { return show_input; }
+   bool showTime() const { return show_time; }
+   bool showNumCmps() const { return show_num_cmps; }
+   bool showOutput() const { return show_output; }
+  
+   /* print help message */
+   void printUsage() const;
+};
+
+#endif // OPTION_H_

radix-sort.cpp

@@ -0,0 +1,57 @@
+//============================================================================
+// Name        : radix-sort.cpp
+// Author      : Derek Wene
+// Date        :
+// Copyright   : Sure, lets say its copyrighted.
+// Description : Implementation of radix sort in C++
+//============================================================================
+
+#include "sort.h"
+#include <iostream>
+
+void
+RadixSort::sort(int A[], int size)
+{
+int digits=0;
+int x=0;
+for(int i =0; i<size; ++i)//Find largest number
+	{
+		if(A[i]>digits)
+		digits=A[i];
+	}
+digits=log10(digits);//find highest digit number
+int B[10];
+int C[size];
+int D[size];
+pow=1;
+while(true)//Get all the digits in the array
+	{
+	for(int j=0; j<size; ++j)//Set digits
+		{
+			D[j]=(A[j]/(pow))%10;
+		}
+		
+	//Counting sort starts here
+	for(int k=0; k<size; ++k)//Set number of each digit.
+		{
+			B[D[k]]++;
+		}
+	for(int l=1; l<10; ++l)//Do the less than equal part.
+		{	
+			B[l]=B[l]+B[l-1];
+		}
+	for(int m=0; m<size; ++m)//Actual Sorting Here
+		{
+		C[B[D[m]]-1]=A[m];
+		--B[D[m]];
+		}
+	for(int n=0; n<size; ++n)//reset A with new sorted part
+		{
+			A[n]=C[n];
+		}
+		if(digits=pow/10)//Detects if done with digits
+			break;
+		pow*=10;
+	}		
+		
+}