Merge branch 'master' into edit-readme

Author: argonautica

C#/BinaryInsertionSort.cs

@@ -0,0 +1,38 @@
+// C# Program implementing 
+// binary insertion sort 
+using System; 
+
+class GFG { 
+	
+	public static void Main() 
+	{ 
+		int []arr = {37, 23, 0, 17, 12, 72, 31, 
+							46, 100, 88, 54 }; 
+
+		sort(arr); 
+
+		for(int i = 0; i < arr.Length; i++) 
+			Console.Write(arr[i] + " "); 
+	} 
+
+	public static void sort(int []array) 
+	{ 
+		for (int i = 1; i < array.Length; i++) 
+		{ 
+			int x = array[i]; 
+
+			// Find location to insert using 
+			// binary search 
+			int j = Math.Abs(Array.BinarySearch( 
+							array, 0, i, x) + 1); 
+
+			// Shifting array to one location right 
+			System.Array.Copy(array, j, array, 
+										j+1, i-j); 
+
+			// Placing element at its correct 
+			// location 
+			array[j] = x; 
+		} 
+	} 
+} 

C#/HeapSort.cs

@@ -0,0 +1,61 @@
+using System;
+class heapsort
+{
+    int[] r = { 2,5,1,10,6,9,3,7,4,8};
+    public void hsort()
+    {
+        int i, t;
+        for (i = 5; i >= 0; i--)
+        {
+            adjust(i, 9);
+        }
+        for (i = 8; i >= 0; i--)
+        {
+            t = r[i + 1];
+            r[i + 1] = r[0];
+            r[0] = t;
+            adjust(0, i);
+        }
+    }
+    private void adjust(int i, int n)
+    {
+        int t, j;
+        try
+        {
+            t = r[i];
+            j = 2 * i;
+            while (j <= n)
+            {
+                if (j < n && r[j] < r[j + 1])
+                    j++;
+                if (t >=r[j])
+                    break;
+                r[j / 2] = r[j];
+                j *= 2;
+            }
+            r[j / 2] = t;
+        }
+        catch (IndexOutOfRangeException e)
+        {
+            Console.WriteLine("Array Out of Bounds ", e);
+        }
+    }
+    public void print()
+    {
+        for (int i = 0; i < 10; i++)
+        {
+            Console.WriteLine("{0}", r[i]);
+        }
+ 
+    }
+    public static void Main()
+    {
+        heap obj = new heap();
+        Console.WriteLine("Elements Before sorting : ");
+        obj.print();
+        obj.hsort();
+        Console.WriteLine("Elements After sorting : ");
+        obj.print();
+        Console.Read();
+    }
+}

C#/InsertionSort.cs

@@ -0,0 +1,48 @@
+/*
+ * C# Program to Perform Insertion Sort
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+namespace ConsoleApplication1
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            int[] arr = new int[5] { 83, 12, 3, 34, 60 };
+            int i;
+            Console.WriteLine("The Array is :");
+            for (i = 0; i < 5; i++)
+            {
+                Console.WriteLine(arr[i]);
+            }
+            insertsort(arr, 5);
+            Console.WriteLine("The Sorted Array is :");
+            for (i = 0; i < 5; i++)
+                Console.WriteLine(arr[i]); 
+            Console.ReadLine();
+        }        
+        static void insertsort(int[] data, int n)
+        {
+            int i, j;
+            for (i = 1; i < n; i++)
+            {
+                int item = data[i];
+                int ins = 0;
+                for (j = i - 1; j >= 0 && ins != 1; )
+                {
+                    if (item < data[j])
+                    {
+                        data[j + 1] = data[j];
+                        j--;
+                        data[j + 1] = item;
+                    }
+                    else ins = 1;
+                }
+            }
+        }
+    }
+}

C#/MergeSort.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+ 
+namespace CSharpMergeSort
+{
+    class Mergesort
+    {
+ 
+        static public void DoMerge(int [] numbers, int left, int mid, int right)
+        {
+            int [] temp = new int[25];
+            int i, left_end, num_elements, tmp_pos;
+        
+            left_end = (mid - 1);
+            tmp_pos = left;
+            num_elements = (right - left + 1);
+        
+            while ((left <= left_end) && (mid <= right))
+            {
+                if (numbers[left] <= numbers[mid])
+                    temp[tmp_pos++] = numbers[left++];
+                else
+                    temp[tmp_pos++] = numbers[mid++];
+            }
+        
+            while (left <= left_end)
+                temp[tmp_pos++] = numbers[left++];
+ 
+            while (mid <= right)
+                temp[tmp_pos++] = numbers[mid++];
+ 
+            for (i = 0; i < num_elements; i++)
+            {
+                numbers[right] = temp[right];
+                right--;
+            }
+        }
+ 
+        static public void MergeSort_Recursive(int [] numbers, int left, int right)
+        {
+          int mid;
+        
+          if (right > left)
+          {
+            mid = (right + left) / 2;
+            MergeSort_Recursive(numbers, left, mid);
+            MergeSort_Recursive(numbers, (mid + 1), right);
+        
+            DoMerge(numbers, left, (mid+1), right);
+          }
+        }        
+ 
+        static void Main(string[] args)
+        {
+            int[] numbers = { 3, 8, 7, 5, 2, 1, 9, 6, 4 };
+            int len = 9;
+ 
+            Console.WriteLine("MergeSort By Recursive Method");
+            MergeSort_Recursive(numbers, 0, len - 1);
+            for (int i = 0; i < 9; i++)
+                Console.WriteLine(numbers[i]);
+ 
+            Console.WriteLine(numbers[i]);
+ 
+        }
+    }
+}

C#/QuickSort.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+ 
+namespace sortQuickAlgorithm
+{
+    class quickSortAlgorithm
+    {
+ 
+        private int[] array = new int[20];
+        private int len;
+ 
+        public void QuickSortAlgorithm()
+        {
+            sort(0, len - 1);
+        }
+ 
+        public void sort(int left, int right)
+        {
+            int pivot, leftend, rightend;
+ 
+            leftend = left;
+            rightend = right;
+            pivot = array[left];
+ 
+            while (left < right) { while ((array[right] >= pivot) &amp;&amp; (left < right))
+                {
+                    right--;
+                }
+ 
+                if (left != right)
+                {
+                    array[left] = array[right];
+                    left++;
+                }
+ 
+                while ((array[left] >= pivot) &amp;&amp; (left < right))
+                {
+                    left++;
+                }
+ 
+                if (left != right)
+                {
+                    array[right] = array[left];
+                    right--;
+                }
+            }
+ 
+            array[left] = pivot;
+            pivot = left;
+            left = leftend;
+            right = rightend;
+ 
+            if (left < pivot) { sort(left, pivot - 1); } if (right > pivot)
+            {
+                sort(pivot + 1, right);
+            }
+        }
+ 
+        public static void Main()
+        {
+            quickSortAlgorithm q_Sort = new quickSortAlgorithm();
+ 
+            int[] array = { 41, 32, 15, 45, 63, 72, 57, 43, 32, 52, 183};
+            q_Sort.array = array;
+            q_Sort.len = q_Sort.array.Length;
+            q_Sort.QuickSortAlgorithm();
+ 
+            for (int j = 0; j &lt; q_Sort.len; j++)
+            {
+                Console.WriteLine(q_Sort.array[j]);
+            }
+            Console.ReadKey();
+        }
+    }
+}

C#/SelectionSort.cs

@@ -0,0 +1,42 @@
+/*
+ * C# Program to Perform a Selection Sort
+ */
+using System;
+class Program
+{
+    static void Main(string[] args)
+    {
+        int array_size = 10;
+        int[] array = new int[10] { 100, 50, 20, 40, 10, 60, 80, 70, 90, 30 };
+        Console.WriteLine("The Array Before Selection Sort is: ");
+        for (int i = 0; i < array_size; i++)
+        {
+            Console.WriteLine(array[i]);
+        }
+        int tmp, min_key;
+ 
+        for (int j = 0; j < array_size - 1; j++)
+        {
+            min_key = j;
+ 
+            for (int k = j + 1; k < array_size; k++)
+            {
+                if (array[k] < array[min_key])
+                {
+                    min_key = k;
+                }
+            }
+ 
+            tmp = array[min_key];
+            array[min_key] = array[j];
+            array[j] = tmp;
+        }
+ 
+        Console.WriteLine("The Array After Selection Sort is: ");
+        for (int i = 0; i < 10; i++)
+        {
+            Console.WriteLine(array[i]);
+        }
+        Console.ReadLine();
+    }
+}

C#/ShellSort.cs

@@ -0,0 +1,32 @@
+private void SortArrayWithShellSort()
+        {
+            int[] array = { 297,183, 464 };
+            ShellSort(array);            
+        }
+       
+ 
+        private void ShellSort(int[] array)
+        {
+            int n = array.Length;
+            int gap = n / 2;
+            int temp;
+ 
+            while (gap > 0)
+            {
+                for (int i = 0; i + gap < n; i++)
+                {
+                    int j = i + gap;
+                    temp = array[j];
+ 
+                    while (j - gap >= 0 && temp < array[j - gap])
+                    {
+                        array[j] = array[j - gap];
+                        j = j - gap;
+                    }
+ 
+                    array[j] = temp;
+                }
+ 
+                gap = gap / 2;
+            }
+        }