首页 > 代码库 > C# 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序

C# 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序

2024-07-27 07:19:36   226人阅读

C# 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序
下面列出了数据结构与算法的八种基本排序：插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序，然后是测试的例子。代码位置：http://download.csdn.net/detail/luozuolincool/8040027
排序类：
public class Sortings
    {
        //插入排序
        public void insertSort(int[] array)
        {
            int temp = 0;
            int index = 0;
            for (int i = 0; i < array.Length; i++)
            {
                for (int j = 0; j < i; j++)
                {
                    if (array[i] < array[j])//从j到i之间的数整体右移动，将i数据放到j位置
                    {
                        index = i;
                        temp = array[i];
                        while (index > j)
                        {
                            array[index] = array[index - 1];
                            index--;
                        }
                        array[j] = temp;
                        break;
                    }
                }
            }
            printArray(array, "插入排序:");
        }
        public void printArray(int[] array, String type)
        {
            Console.WriteLine(type);
            for (int i = 0; i < array.Length; i++)
            {
                Console.Write(array[i] + ",");
            }
            Console.WriteLine();
        }
        //冒泡排序
        public void bubbleSort(int[] array)
        {
            int temp = 0;
            bool exchanged = true;
            for (int i = 0; i < array.Length; i++)
            {
                if (!exchanged)
                    break;
                for (int j = array.Length - 1; j > i; j--)
                {
                    exchanged = false;
                    if (array[j] < array[j - 1])//后面的数比前面的小就交换
                    {
                        temp = array[j];
                        array[j] = array[j - 1];
                        array[j - 1] = temp;
                        exchanged = true;
                    }
                }
            }
            printArray(array, "冒泡排序:");
        }
        //选择排序:从前到后依次选择最小的放在最前面，第二小的放在第二个位置
        public void selectionSort(int[] array)
        {
            int minIndex = 0;
            int temp = 0;
            for (int i = 0; i < array.Length; i++)
            {
                minIndex = i;
                for (int j = i; j < array.Length; j++)
                {
                    if (array[j] < array[minIndex])
                        minIndex = j;
                }
                //将i到j之间最小的数放到位置i
                temp = array[minIndex];
                array[minIndex] = array[i];
                array[i] = temp;
            }
            printArray(array, "选择排序：");
        }
        //快速排序
        public void quickSort(int[] array)
        {
            quicksort1(array, 0, array.Length - 1);
            printArray(array, "快速排序：");
        }
        public void quicksort1(int[] array, int start, int end)
        {
            if (start >= end)
                return;
            int i = start, j = end;
            int k = array[i];
            while (i < j)
            {
                while (array[j] >= k && i < j)
                    j--;
                array[i] = array[j];
                while (array[i] < k && i < j)
                    i++;
                array[j] = array[i];
            }
            array[i] = k;
            quicksort1(array, start, i -1);
            quicksort1(array, i +1, end);
        }
        //堆排序
        public void stackSort(int[] array)
        {
            MyHeap h = new MyHeap();
            h.buildHeap(array);
            h.HeapSort();
            h.printHeap();
        }
        //归并排序
        public void mergeSort(int[] array)
        {
            mergeSort1(array, 0, array.Length - 1);
            printArray(array, "归并:");
        }
        private void mergeSort1(int[] array ,int start,int end)
        {
            if (start >= end)
                return;
            mergeSort1(array, start, (start+end) / 2);
            mergeSort1(array, (start + end) / 2+1,end);
            merge(array, start, (start + end) / 2, end);
            
        }
        private void merge(int[] array,int start,int mid,int end)
        {
            Queue<int> q = new Queue<int>();
            int i = start, j = mid + 1;
            while (i <=mid && j <=end)
            {
                if (array[i] < array[j])
                {
                    q.Enqueue(array[i]);
                    i++;
                }
                else
                {
                    q.Enqueue(array[j]);
                    j++;
                }
            }
            while (i <= mid)
                q.Enqueue(array[i++]);
            while (j <= end)
                q.Enqueue(array[j++]);
           
            for (i = start; i <= end; i++)
                array[i] = q.Dequeue();
        }
        //基数排序
        public void radixSort(int[] array)
        {
            int maxlength=0;//数据最大位数
            //申请空间用于存放数据
            List<List<int>> lists=new List<List<int>>();
            //申请10个桶，用于存放0-9
            for (int i = 0; i < 10; i++)
                lists.Add(new List<int>());
            //获取数据的最大位数
            for (int i = 0; i < array.Length; i++)
                maxlength = maxlength < array[i].ToString().Length ? array[i].ToString().Length : maxlength;
            for (int i = 0; i < maxlength; i++)
            {
                //数据入桶
                for (int j = 0; j < array.Length; j++)
                {
                    lists[array[j] / (int)(Math.Pow(10, i)) - array[j] / (int)(Math.Pow(10, i+1))*10].Add(array[j]);
                }
                int t = 0;
                //将桶里面的数据重新放入数组
                for (int k = 0; k < 10; k++)
                {
                    
                    foreach (int item in lists[k])
                        array[t++] = item;
                }
                //清空桶里面的数据
                for (int k = 0; k < 10; k++)
                {
                    lists[k].Clear();
                }


            }
            printArray(array, "基数排序");
        }
        //希尔排序
        public void shellSort(int[] array)
        {
            int step = array.Length / 2;
            while (step > 0)
            {
                shellInsert(array, step);
                Console.WriteLine();
                printArray(array, "希尔");
                step = step / 2;
            }
            printArray(array, "希尔");
        }
        private void shellInsert(int[] array,int step)
        {
            int temp = 0;
            int index = 0;
            for (int i = 0; i < array.Length; i=i+step)
            {
                for (int j = 0; j < i; j=j+step)
                {
                    if (array[i] < array[j])//从j到i之间的数整体右移动，将i数据放到j位置
                    {
                        index = i;
                        temp = array[i];
                        while (index > j)
                        {
                            array[index] = array[index - 1];
                            index--;
                        }
                        array[j] = temp;
                        break;
                    }
                }
            }
        }
    }
测试代码：
 static void Main(string[] args)
        {
            int[] array = { 12,3,23,4,21,44,2,3,11};
            Console.WriteLine("待排序数组：");
            for (int i = 0; i < array.Length; i++)
            {
                Console.Write(array[i]+",");
            }
            Console.WriteLine();
           // insertSort(array);
           // bubbleSort(array);
           // selectionSort(array);
          //  (new Sortings()).quickSort(array);
          //  (new Sortings()).stackSort(array);
           // (new Sortings()).mergeSort(array);
            //(new Sortings()).shellSort(array);
            (new Sortings()).radixSort(array);
            Console.Read();
        }

C# 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序


联系
我们