几种简单的排序算法

小灰灰 2022-03-30 10:28 236阅读 0赞

直接上代码吧！比简单只是太长时间不怎么写排序算法了，想着没事写写，温故而知新

using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    /// <summary>
    /// 简单排序算法
    /// </summary>
    public class BubbleSort : MonoBehaviour {
        int[] number0 = new int[10] {5,10,4,8,6,7,44,56,45,11 };
    
        private void Start()
        {
            int[] b = sort(number0);
            for (int i = 0; i < b.Length; i++)
            {
                Debug.Log(b[i]);
            }
        }
    
        /// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="n"></param>
        /// <returns></returns>
        public int[] sort(int[] n)
        {
            int[] returnnumber = n;
            for (int i = 0; i < n.Length-1; i++)
            {
                for (int j = 0; j < n.Length-1-i; j++)
                {
                    if (returnnumber[j]>returnnumber[j+1])
                    {
                       int a= returnnumber[j];
                       returnnumber[j] = returnnumber[j+1];
                       returnnumber[j+1] = a;
                    }
                }
            }
            return returnnumber;
        }
    
    
        /// <summary>
        /// 选择排序 （从数组中找到最小元素和当前比较的元素互换）
        /// </summary>
        /// <returns></returns>
        public int[] SelectionSort(int[] n)
        {
            int[] number=n;
            for (int i = 0; i < number.Length-1; i++)
            {
                int minPos = i;
                for (int j = i; j < number.Length; j++)
                {
                    if (number[j]<number[minPos])
                    {
                        minPos = j;//找出当前最小元素的位置
                    }
                }
                if (number[minPos]!=number[i])//如果最小元素与当前位置的元素不相等则交换位置
                {
                    int temp = number[minPos];
                    number[minPos] = number[i];
                    number[i] = temp;
                }
            }
            return number;
        }
    
        //由选择排序衍生数来的排序算法   双向选择排序（每次循环，同时选出最大值放在末尾，最小值放在前方）
        /// <summary>
        ///  双向选择排序（每次循环，同时选出最大值放在末尾，最小值放在前方）
        /// </summary>
        /// <param name="n"></param>
        /// <returns></returns>
        public int[] BothwaySelectionSort(int[] n)
        {
            int[] number = n;
            for (int i = 0; i < number.Length/2-1; i++)
            {
                int minpos = i, maxpos = number.Length - i - 1;
                for (int j = i; j < number.Length-i; j++)
                {
                    if (number[j]<number[minpos])
                    {
                        minpos = j;
                    }
    
                    if (number[maxpos]<number[j])
                    {
                        maxpos = j;
                    }
                }
                if (i!=minpos)
                {
                    swap(number,i,minpos);
                }
    
                if (maxpos!=number.Length-i-1)
                {
                    if (maxpos==i)若当前最大值在循环起始位置，则最大值一定在(1)处被交换到了minPos的位置
                    {
                        maxpos = minpos;
                    }
                    swap(number,maxpos,number.Length-i-1);
                }
            }
            return number;
        }
    
        /// <summary>
        /// 两数互相交换函数
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="a"></param>
        /// <param name="b"></param>
        public static void swap(int[] arr, int a, int b)
        {
    
            int temp = arr[a];
    
            arr[a] = arr[b];
    
            arr[b] = temp;
    
        }
    
    
        /// <summary>
        /// 插入排序算法  （从第二个开始对比插入）
        /// </summary>
        /// <param name="n"></param>
        /// <returns></returns>
        public int[] Insertion(int[] n)
        {
            int pos, temp;
            int[] number = n;
            for (int i = 1; i < number.Length; i++)
            {
                pos = i;
                while (pos!=0&&number[pos]<number[pos-1])
                {
                    temp = number[pos];
                    number[pos] = number[pos - 1];
                    number[pos - 1] = temp;
                    pos--;
                }
            }
            return number;
        }
    
    
        /// <summary>
        /// 鸡尾酒排序
        /// 鸡尾酒是冒泡排序的升级版，该排序从左往右找出最大值后，再从右往左
        ///找出最小值，类似鸡尾酒搅拌左右循环。在某些情况下，优于冒泡排序，
        ///以序列(2,3,4,5,1)为例，鸡尾酒排序只需要访问两次（升序降序各一次 ）
        ///次序列就可以完成排序，但如果使用冒泡排序则需要四次。
        /// </summary>
        /// <param name="n"></param>
        public static void CockTailsort(int[] n)
            {
    
            //依次将最大的数放置到数组末尾，将第二大的数放到倒数第二位...
            int[] number = n;
                bool changed;
    
                for (int i = 0; i < number.Length / 2; i++)
                {
    
                    changed = false;
    
                    //从前往后,比较相邻两个数,把大的放在后边.之前已放置成功的可以不再参与比较
    
                    for (int j = i; j < number.Length - 1 - i; j++)
                    {
    
    
    
                        if (number[j] > number[j + 1])
                        {
    
                            swap(number, j, j + 1);
    
                            changed = true;
    
                        }
    
                    }
    
                    if (!changed)
                    {
    
                        break;
    
                    }
    
                    for (int j = number.Length - 1 - i; j > i; j--)
                    {
    
    
    
                        if (number[j] < number[j - 1])
                        {
    
                            swap(number, j, j - 1);
    
                            changed = true;
    
                        }
    
                    }
    
                    if (!changed)
                    {
    
                        break;
    
                    }
    
                }
    
            }
    
    
     }