Question

class Sort
{
    int[] arr;
    int counter=0;

    //Constructor
    public Sort()
    {
        arr = new int[10000];
    }

    string address;

    public void SwitchCase(int Case)
    {
            switch (Case)
            {
                case 1:
                    address = @"C:\Users\Aqib Saeed\Desktop\case1.txt";
                    break;
                case 2:
                    address = @"C:\Users\Aqib Saeed\Desktop\case2.txt";
                    break;
                case 3:
                    address = @"C:\Users\Aqib Saeed\Desktop\case3.txt";
                    break;
                default:
                    break;
            }
    }

    //Read file for input
    public void FillArray()
    {
        using (StreamReader rdr = new StreamReader(address))
        {  
            for (int i = 0; i < arr.Length; i++)
            {
                arr[i] = Convert.ToInt32(rdr.ReadLine());
            }
        }
    }


    // Insertion Sort
    public void InsertionSort()
    {
        int insert;

        for (int i = 1; i < arr.Length; i++)
        {
            insert = arr[i];

            int moveItem = i;

            while (moveItem > 0 && arr[moveItem - 1] > insert)
            {
                arr[moveItem] = arr[moveItem - 1];
                moveItem--;
                counter++;
            }
            arr[moveItem] = insert;

        }
    }

    public void Counter()
    {
        Console.WriteLine(counter);
    }

    //Bubble Sorting
    public void BubbleSort()
    {
        int temp;

        for (int i = 0; i < arr.Length; i++)
        {
            for (int j = 0; j < arr.Length - 1 - i; j++)
            {
                if (arr[j] > arr[j + 1])
                {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    counter++;
                }
            }
        }
    }

    //Selection Sorting
    public void SelectionSort()
    {
        int min, temp;

        for (int i = 0; i < arr.Length; i++)
        {
            min = i;

            for (int j = i + 1; j < arr.Length; j++)
            if (arr[j] < arr[min])

            min = j;

            temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
            counter++;
        }
    }

    // Write Output to file
    public void Writer()
    {
        using (StreamWriter wrtr = new StreamWriter(@"C:\Users\AqibSaeed\Desktop\SortedOutput.txt"))
        {
            for (int i = 0; i < arr.Length; i++)
            {
                wrtr.WriteLine(arr[i]);
            }
        }
    }
}

static void Main(string[] args)
    {
        Sort srt = new Sort();

        Console.WriteLine("Enter Case 1 OR 2 OR 3");


        srt.SwitchCase(Convert.ToInt32(Console.ReadLine()));

        srt.FillArray();

        srt.BubbleSort();

        srt.Writer();

        Console.WriteLine("Sorted Output File Is Ready");
        srt.Counter();
        Console.ReadLine();

    }

I implement my Sort class for sorting integers and place int counter to determine number of swaps and comparsions. But I am not sure it is working correctly! Is there any other way to determine number of swaping and comparsions?

Answer 1

You could create a class which implements IComparable to count the comparator access and a specialized collection which counts the swaps. Like that you dont have to count the access inside of the sort algorithms and you delegate the tasks more strict to code parts.

In the index operator you count the swap operations and in the IComparable implementation you count the comparisons

Example for a class SortItem which implements the IComparable:

public class SortItem<T> : IComparable<T> where T : IComparable
{
    private static int _ComparisonCount = 0;
    public static int ComparisonCount
    {
        private set
        {
            _ComparisonCount = value;
        }
        get
        {
            return _ComparisonCount;
        }
    }

    public T Value
    {
        get;
        set;
    }

    public static void ResetComparisonCount()
    {
        _ComparisonCount = 0;
    }

    #region IComparable<T> Members

    public int CompareTo(T other)
    {
        ComparisonCount++;
        return this.Value.CompareTo(other);
    }

    #endregion
}

and the sorting collection:

public class SortCollection<T> : IList<SortItem<T>>
{
    public SortCollection(IList<T> sortList)
    {
        InnerList = sortList;
    }

    private IList<T> InnerList = null;

    public T this[int key] 
    { 
        get 
        {
            return InnerList[key]; 
        } 
        set 
        {
            SwapCount++;
            InnerList[key] = value; 
        } 
    }

    private int _SwapCount = 0;
    public int SwapCount
    {
        private set
        {
            _SwapCount = value;
        }
        get
        {
            return _SwapCount;
        }
    }

    public void ResetSwapCount()
    {
        _SwapCount = 0;
    }


}

Here the execution:

List<Int32> baseList = new List<int>(new Int32 {6, 2, 7, 3, 1, 6, 7 });
SortCollection<Int32> sortList = new SortCollection<int>(baseList);

//do the sorting....

Console.WriteLine("Swaps: " + sortList.SwapCount.ToString());
Console.WriteLine("Comparisons: " + SortItem<Int32>.ComparisonCount.ToString());
SortItem<Int32>.ResetComparisonCount();
sortList.ResetSwapCount();