数据结构算法-排序

1.冒泡排序实现

        /// <summary>
        /// BubbleSorter冒泡排序
        /// n个元素的数组
        /// 第一轮排序：处理的数组元素下标：0到n-1，邻近两个元素依次比较，将最大的元素放到数组尾部，即数组下标为n-1的位置；
        /// 第二轮排序：处理的元素0到n-2个元素，进行第一轮的比较，将最大的元素放到数组下标为n-2的位置，后续几轮排序依次类推
        /// 空间复杂度：O(1),平均时间复杂度：O(n^2)，最好时间复杂度：O(n),最坏时间复杂度：O(n^2),稳定算法，（排序之后，相同元素的在数组中的相对位置保持不变，则该算法为稳定算法）
        /// </summary>
        public void BubbleSort(int[] args)
        {
            if (args==null|| args.Length<=1 )
            {
                return;
            }

            var flag = false;
            for (int i = 0; i < args.Length; i++)
            {
                for (int j = 0; j < args.Length-i-1; j++)
                {
                    if (j<args.Length && args[j]>args[j+1])
                    {
                        var temp = args[j+1];
                        args[j+1] = args[j];
                        args[j] = temp;
                        flag = true;
                    }
                }

                if (!flag)
                {
                    break;
                }
            }
        }

2.插入排序

        /// <summary>
        /// 插入排序
        /// 插入排序，第一个元素默认是有序的，此时有序数组包含第一个元素，从第二个元素开始依次将后续
        /// 元素插入到前面的有序数组中，并保持新的数组是有序的
        /// 空间复杂度：O(1),平均时间复杂度：O(n^2)，最好时间复杂度：O(n),最坏时间复杂度：O(n^2)，稳定算法
        /// </summary>
        /// <param name="args"></param>
        public void InsertSort(int[] args)
        {
            if (args == null || args.Length <= 1)
            {
                return;
            }

            for (int i = 0; i < args.Length; i++)
            {
                var element = args[i];//把要插入有序数组的目标元素保存下来
                var j = i - 1;
                while (j >= 0 && element < args[j])
                {
                    args[j + 1] = args[j];//将现有有序数组中，比目标元素大的元素往有序数组的后面移动
                    j--;
                }
                //执行最后一次j减了1，所以要再加1
                args[j + 1] = element;

            }
        }

3.选择排序

         /// <summary>
        /// 选择排序
        /// 选择数组中最小的一个元素放到数组第一个位置，除数组第一个元素外，挑选数组中剩余的最小的数放到数组的第二位置，除数组第一，二个元素外，
        /// 挑选数组中剩余的最小的数放到数组的第三个位置，依次类推
        /// 空间复杂度：O(1),平均时间复杂度：O(n^2)，最好时间复杂度：O(n^2),最坏时间复杂度：O(n^2),稳定算法
        /// </summary>
        /// <param name="args"></param>
        public void SelectSort(int[] args)
        {
            if (args==null||args.Length<=1)
            {
                return;
            }

            for (int i = 0; i < args.Length; i++)
            {
                var element = i;
                for (int j = i; j < args.Length-i; j++)
                {
                    if (args[j]<args[element])
                    {
                        element = j;
                    }
                }

                var temp = args[i];
                args[i] = args[element];
                args[element] = temp;
            }
        }