WeiBlog

直插排序

static void InsertSort(int[] dateArray)
{
for (int i = 1; i < dateArray .Length ; i++)
{
int iValue = dateArray[i];
bool isInsert = false;
//从第二个元素开始拿到i位置元素，和前面的元素对比
//如比I大，就让其向后移动，（保证前面的元素从小到大排序）
for (int j = i - 1; j >= 0; j--)
{
if (dateArray [j]>iValue)
{
dateArray[j + 1] = dateArray[j];
}else//在前面发现一比i小的值就停止移动
{
dateArray[j + 1] = iValue;
isInsert = true;
break;
}
}
if (isInsert ==false)//前面的值都比i大将i放到最前面
{
dateArray[0] = iValue;
}
}
}

    冒泡排序
    static void BubbleSort(int[] dateArray)
    {
        for (int i = dateArray.Length-1; i > 0 ; i--)//总循环次数(n-1)
        {
            for (int j = 0; j < i; j++)//循环n次后后n个数已经最大不需在进入比较
            {
                if (dateArray [j]>dateArray [j+1])
                {
                    int temp = dateArray[j];
                    dateArray[j] = dateArray[j + 1];
                    dateArray[j + 1] = temp;
                }
            }
        }
    }
    static void BubbleSort2(int[] sortArray)
    {
        bool isChang = true;
        do
        {
            isChang = false;
            for (int i = 0; i < sortArray.Length - 1; i++)
            {
                if (sortArray[i] > sortArray[i + 1])
                {
                    int temp = sortArray[i];
                    sortArray[i] = sortArray[i + 1];
                    sortArray[i + 1] = temp;
                    isChang = true;
                }
            }
            //isChange仍为false,则说明相邻前面的数都比后面的数小不需要排序，退出循环
        } while (isChang);
    }

选择排序
static void SelectSort(int[] dateArray)
{
for (int i = 0; i < dateArray .Length-1 ; i++)
{
int minIndex = i;
for (int j = i+1; j < dateArray.Length ; j++)
{
if (dateArray [j]<mindate )
{
mindate = dateArray[j];
minIndex = j;
}
}
if (minIndex !=i)
{
int temp = dateArray[i];
dateArray[i] = mindate;
dateArray[minIndex] = temp;
}
}
}

//希尔排序
///

            for (int i = h; i <= arr .Length-1; i++)
            {
                temp = arr[i]; 
                inner = i;
                while((inner >h-1)&&arr[inner-h]>=temp)
                {
                    arr[inner] = arr[inner - h];
                    inner -= h;

                }
                arr[inner] = temp;

            }

            h = (h - 1) % 3;
        }
    }

    快速排序
    /// <summary>
    /// 对数组范围内的数据进行排序
    /// </summary>
    /// <param name="dateArray">要排序的数组</param>
    /// <param name="left">开始索引</param>
    /// <param name="right">结束索引</param>
    static void QuickSort(int [] dateArray,int left,int right)
    {
        if (left <right )
        {
            int x = dateArray[left];//基准数，把比它小或等于它的放在它左边，然后把比它大的放在右边
            int i = left;
            int j = right;

            while (true && i < j)
            {
                //从后往前比较，（从右往左找一个小于/等于x的数字）
                while (true && i < j)
                {
                    if (dateArray[j] < x)//找到了一个小于基准数的数字，把它放在x左边（i位置）
                    {
                        dateArray[i] = dateArray[j];
                        break;
                    }
                    else
                    {
                        j--;
                    }
                }
                //从前往后找一个（左到右找一个比x大的数字，放在放在基准位置（j）
                while (true && i < j)
                {
                    if (dateArray[i] > x)
                    {
                        dateArray[j] = dateArray[i];
                        break;
                    }
                    else
                    {
                        i++;
                    }
                }
            }
            dateArray[i] = x;
            QuickSort(dateArray, left, i - 1);
            QuickSort(dateArray, i + 1, right);
        }
    }
    //递归快排
    static void Qsort(int[] array,int left,int right)
    {
        if(left<right)
        {
            int i = left;
            int j = right + 1;
            int provt = array[i];
            do
            {
                do i++; while (array[i] < provt && i < array.Length-1);//从左往右找比基准值大的
                do j--; while (array[j] > provt && j >= 0);//从右往左找比基准值小的
                if(i<j)//左右未交错，即交换
                {
                    Swap(ref array[i], ref array[j]);
                }
            } while (i<j);//左右未交错继续寻找，交错则退出循环
            Swap(ref array[left], ref array[j]);//退出循环时j仍是比基准值小的数，i仍是比基准值大的数，可将基准值与j位置值交换。之后左右递归调用快排
            Qsort(array, left, j - 1);
            Qsort(array, j + 1, right);
        }
    }

    static void Swap(ref int a,ref int b)
    {
        int temp = a;
        a = b;
        b = temp;
    }