C# 简单排序算法。

最新推荐文章于 2021-12-21 13:43:19 发布

香蕉裤衩

最新推荐文章于 2021-12-21 13:43:19 发布

阅读量468

点赞数

分类专栏： C#学习文章标签： c# 排序算法

本文链接：https://blog.csdn.net/mengjiangtao/article/details/65936135

版权

C#学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SortMethod {


    public delegate void Sorts(ref double[] val);

    public static void GenSort(ref double[] val)
    {
    }

    public static void InsertSort(ref double[] val)
    {
        int length = val.Length;
        for(int i = 1;i < length;i++)
        {
            int frontIndex = i - 1;
            int currentIndex = i;
            while(frontIndex >= 0)
            {
                if (val[frontIndex] < val[currentIndex])
                {
                    SwapValue(ref val[currentIndex], ref val[frontIndex]);
                    currentIndex = frontIndex;
                }
                frontIndex--;
            }
        }
    }

    public static void SelectSort(ref double[] val)
    {
        int length = val.Length;
        for(int i = 0;i<length;i++)
        {
            double minValue = val[i];
            int currentIndex = i;
            for(int j = i;j<length;j++)
            {
                if(minValue>val[j])
                {
                    minValue = val[j];
                    currentIndex = j;
                }
            }
            SwapValue(ref val[i], ref val[currentIndex]);
        }
    }

    public static void BubbleSort(ref double[] val)
    {
        int length = val.Length;
        for(int i = 0;i<length;i++)
        {
            for (int j = i + 1; j < length; j++)
            {
                if(val[i] > val[j])
                {
                    SwapValue(ref val[i], ref val[j]);
                }
            }
        }
    }

    public static void QuickSort(ref double[] val, int StartIndex, int EndInderx)
    {
        int CurrentIndex = StartIndex;
        bool IsOrderSearched = true;
        bool IsDisOrderSearched = true;
        while(IsOrderSearched || IsDisOrderSearched)
        {
            IsDisOrderSearched = IsOrderSearched = false;
            for(int i = EndInderx;i>CurrentIndex;i--)
            {
                if (val[i] < val[CurrentIndex])
                {
                    SwapValue(ref val[i], ref val[CurrentIndex]);
                    CurrentIndex = i;
                    IsDisOrderSearched = true;
                    break;
                }
            }
            for(int i = StartIndex;i<CurrentIndex;i++)
            {
                if(val[i] > val[CurrentIndex])
                {
                    SwapValue(ref val[i], ref val[CurrentIndex]);
                    CurrentIndex = i;
                    IsOrderSearched = true;
                    break;
                }
            }
        }
        if(EndInderx - StartIndex >0)
        {
            if(CurrentIndex != StartIndex)
            {
                QuickSort(ref val, StartIndex, CurrentIndex - 1);
            }
            if(CurrentIndex != EndInderx)
            {
                QuickSort(ref val, CurrentIndex + 1, EndInderx);
            }
        }
    }
    static void SwapValue(ref double value1,ref double value2)
    {
        double Temp = value1;
        value1 = value2;
        value2 = Temp;
    }
}