C# 几种简单的排序，冒泡排序 选择排序 插入排序 快速排序

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Choice
{
class Program
{
static void Main(string[] args)
{
var arr = new IComparable[] { 72,6,57,88,60,42,83,73,48,85 };
//var result = Sorted(arr);
//Array.ForEach(arr, Console.WriteLine);
var resulto = SortedInsert(arr);
// Array.ForEach(arr, Console.WriteLine);
//var resulquite = SortedQuite(arr,0, arr.Length-1);
Console.WriteLine("排序是否成功?{0}", IsSorted(resulto) ? "是" : "否");
Array.ForEach(arr, Console.WriteLine);
//Console.WriteLine("排序是否成功?{0}", IsSorted(result) ? "是" : "否");
Console.ReadKey();

}
public static bool IsSorted(IComparable[] arrlist) {

for (int i=1;i<arrlist.Length;i++) {

if (Less(arrlist[i], arrlist[i - 1])) { return false; }
}
return true;
}
//1.选择排序 ：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。
public static IComparable[] Sorted(IComparable[] arrllist){

int count = arrllist.Length;
for (int i = 0; i < count; i++) {
int min =i;
for (int j = i + 1; j < count; j++) {

if (Less(arrllist[j], arrllist[min])) {
min = j; //最小
}
}
Exchange(arrllist,i,min);
}
return arrllist;
}
//2.插入排序 假设数列第一个元素为已排序数列，剩余数列为未排序将待排序元素挨个插入到已排序数列中每次插入都必须保证数列是有序的，即通过比较和移动有序数列中的元素，将元素插入到合适的位置
public static IComparable[] SortedInsert(IComparable[] arrllist)
{
int count = arrllist.Length;
for (int i = 1; i < count; i++)
{
int temp = int.Parse((arrllist[i].ToString()));
for (int j=i-1;j>=0;j--) { //大于返回F 小于返回T

if (!Less(temp, arrllist[j])) { break; }

else {
Exchange(arrllist, j, j+1);
}
}
}
// Array.ForEach(arrllist, Console.WriteLine);
return arrllist;
}

//3.冒泡排序 依次比较两个相邻的元素,大小就把他们交换过来
public static IComparable[] SortedMao(IComparable[] arrllist)
{
int count = arrllist.Length;
for (int i = 0; i < count-1; i++)
{
for (int j = 0; j < count -1-i; j++) {
if (!Less(arrllist[j], arrllist[j+1])) {
Exchange(arrllist, j, j + 1);
}
}
}
return arrllist;
}
//该方法的基本思想是：
//1．先从数列中取出一个数作为基准数。
//2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
//3．再对左右区间重复第二步，直到各区间只有一个数。
public static IComparable[] SortedQuite(IComparable[] arrllist,int left,int right)
{
//Console.WriteLine("输出 左边排序"+left+","+right);

if (left < right) {
Console.WriteLine("输出 右边排序" + left + "," + right);
int x = int.Parse(arrllist[left].ToString());
int i = left;
int j= right;
while (i < j) {
while (i < j) {
if(Less(arrllist[j], x))
{
arrllist[i] = arrllist[j];
break;
}
else{
j--;
}
}
while (i < j)
{
if (!Less(arrllist[i], x))
{
arrllist[j] = arrllist[i];
break;
}
else
{
i++;
}
}
}
arrllist[i] = x;
SortedQuite(arrllist, left, i - 1);
SortedQuite(arrllist, i+1,right);
}
return arrllist;

}
/// <summary>
/// 交换一轮循环后的结果
/// </summary>
/// <param name="array"></param>
/// <param name="i"></param>
/// <param name="min"></param>
private static void Exchange(IComparable[] array, int i, int min)
{
var temp = array[i];
array[i] = array[min];
array[min] = temp;
}
/// <summary>
/// 判断两个元素的大小
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
private static bool Less(IComparable a, IComparable b)
{
var res = a.CompareTo(b);
return res < 0;
}

}
}