any errors in my bubble/insertion/selection sort?

[unregistered]

everything seems to work fine but I was wondering if there are any errors in my code that I have not spotted or are there any ways to optimize my code?

Thanks

#include<iostream>
#include<fstream>
#include<ctime>
#include<cstdlib>

using namespace std;

const short MAX = 20;
const short LISTNO = 3;

void createInput( fstream&, const char [], short );
void storeArray( fstream&, short [], short );
void printArray( short [], short );
void storeOutput( fstream&, const char [], short [], short );
void swap( short&, short& );
short findMin( short [], short, short );
void bubbleSort( short [], short );
void insertionSort( short [], short );
void selectionSort( short [], short );

int main()
{
	fstream inFile;
	short list[LISTNO][MAX];

	srand( time( NULL ) );

	createInput( inFile, "input.txt", MAX );

	for ( short idx = 0; idx < LISTNO; idx++ )
		storeArray( inFile, list[idx], MAX );

	for ( short idx = 0; idx < LISTNO; idx++ )
	{
		cout << "Before sorting: list " << idx << endl;
		printArray( list[idx], MAX );
	}

	bubbleSort( list[0], MAX );
	insertionSort( list[1], MAX );
	selectionSort( list[2], MAX );

	for ( short idx = 0; idx < LISTNO; idx++ )
	{
		cout << "After sorting: list " << idx << endl;
		printArray( list[idx], MAX );
	}

	storeOutput( inFile, "bubble.txt" , list[0], MAX );
	storeOutput( inFile, "insertion.txt" , list[1], MAX );
	storeOutput( inFile, "selection.txt" , list[2], MAX );

	return 0;
}

void createInput( fstream& inFile, const char fileName[], short max )
{
	inFile.open( fileName, ios::out);

	for ( short idx = 0; idx < max; idx++ )
	{
		inFile << rand() % 30 + 1 << endl;
	}

	inFile.close();

	return;
}

void storeArray( fstream& inFile, short list[], short size)
{

	inFile.open("inFile.txt", ios::in );

	for ( short idx = 0; idx < size; idx++ )
		inFile >> list[idx];

	inFile.close();

	return;
}

void printArray( short list[], short size )
{
	for ( short idx = 0; idx < size; idx++ )
		cout << list[idx] << endl;

	return;
}

void storeOutput( fstream& inFile, const char fileName[], short list[], short size)
{
	inFile.open( fileName, ios::out );

	for ( short idx = 0; idx < size; idx++ )
		inFile << list[idx] << endl;

	inFile.close();

	return;
}


void swap( short& firstNum, short& secondNum)
{
	short temp = firstNum;
	firstNum = secondNum;
	secondNum = temp;

	return;
}

short findMin( short list[], short startIdx, short size )
{
	short minIdx = startIdx;

	for ( short idx = startIdx + 1; idx < size; idx++ )
	{
		if ( list[idx] < list[minIdx] )
		minIdx = idx;
	}

	return minIdx;
}

void bubbleSort( short list[], short size)
{
	bool sorted = false;
	short wallIdx,
	      idx;

	for ( wallIdx = 0; wallIdx < size - 1 && !sorted; wallIdx++ )
	{
		sorted = true;

		for ( idx = size - 1; idx > wallIdx; idx-- )
		{
			if ( list[idx] < list[idx - 1] )
			{
				swap( list[idx], list[idx-1] );
				sorted = false;
			}
		}

	}

	return;
}

void insertionSort( short list[], short size )
{
	short wallIdx,
	      idx,
	      temp;

	for ( wallIdx = 1; wallIdx < size; wallIdx++ )
	{
		temp = list[wallIdx];
		for ( idx = wallIdx; idx > 0 && list[idx - 1] > temp; idx-- )
			list[idx] = list[idx - 1];
		list[idx] = temp;
	}
	return;
}


void selectionSort( short list[], short size )
{
	short wallIdx,
	      minIdx;

	for ( wallIdx = 0; wallIdx < size - 1; wallIdx++ )
	{
		minIdx = findMin( list, wallIdx, size );
		if ( wallIdx != minIdx )
			swap( list[wallIdx], list[minIdx] );
	}
	return;
}

[unregistered]

ups

[mahlerfive]

Your sorts look good to me. If you want to optimize though, you could remove the swap and findMin functions and just put the code directly into the sorts. This removes function call overhead. Optimization almost always comes at a cost to readability/maintainability though - in this case it is more readable/maintainable for those functions to be separate, so it's up to you.

[jsmith]

STL contains a templated std::swap function. I'd use that. The compiler will decide if it can inline the swap to eliminate the function call.

[seymore15074]

Small suggestion: use the prefix increment operator any time that you can. If you were to implement similar functions to post and pre increment for ints they would look something like this:

int preinc( int & n )
{
    return n += 1;
}

int postinc( int & n )
{
    int before( n );
    n += 1;
    return  before;
}

The postinc function has an extra instantiation and may be a hair slower...

If you are just looking for cool things to play with, try to make the functions templates so that they work on more than just shorts.

For example, swap could be something like:

template<class T>
void swap( T & a, T & b )
{
    T t( a );
    a = b;
    b = t;
}