c#的 排序算法--冒泡排序，快速排序

交换排序： 包括冒泡排序，快速排序。

选择排序： 包括直接选择排序，堆排序。

插入排序： 包括直接插入排序，希尔排序。

合并排序： 合并排序。

冒泡排序：比较第一个和第二个，后者小于前者两者交换，第二个比较第三个，第三个比较第四个，直到最后，然后重复该过程

9 8 7 6

8 9 7 6

8 7 9 6

8 7 6 9

7 8 6 9

7 6 8 9

6 7 8 9

over！

int temp;
int[] arrSort = new int[] { 10, 8, 3, 5, 6, 7, 9 };
for (int i = 0; i < arrSort.Length; i++)
{
for (int j = i + 1; j < arrSort.Length; j++)
{
if (arrSort[j] < arrSort[i])
{
temp = arrSort[j];
arrSort[j] = arrSort[i];
arrSort[i] = temp;

}
}
}

冒泡排序为：O(n^2 )

若第二个循环改成 for (i = 0; i < arrSort.Length - 1; i++) 内循环次数高于冒泡排序

快速排序，效率比冒泡排序高

1）、设置两个变量I、J，排序开始的时候I：=1，J：=N；

2）以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；

3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；

4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；

5）、重复第3、4步，直到I=J；

49 38 65 97 76 13 27

I=1 J=7 X =49

从后往前找小于的，并交换位置

27 38 65 97 76 13 49

J = 7 I = 1

从前往后找大于的，并 交换位置

27 38 49 97 76 13 65

I = 3,J =7

从后往前找小于的，并交换位置

27 38 13 97 76 49 65

J = 6, I=3

从前往后找大于的，并交换位置

27 38 13 49 76 97 65

I =6, J =6

第一次排序完成

{27，38，13}49{76，97，65}

再重复上述顺序，直到每个集合元素为1

{27 38 13 } { 76 97 65}

{13 38 27 } { 65 97 76}

{13 27 38 } { 65 76 97}

再重复上述顺序，直到每个集合元素为1

private void QuickSort(List<int> arr, int left, int right)
{
if (left < right)
{
int index = (left + right)/2;//取中间的数的下角标
int key = arr[index]; //取中间的数，作为对照数
int i = left;
int j = right;
while (true)
{
while (arr[i] <= key && i != index) //一直循环直到碰到第一个小于对照数时跳出循环,并且判断是否是相同的数，防止死循环 （去除对照数，防止把对照数当做相同的数出现运算错误）
{
i++;
}
while (arr[j] > key)//同上，碰到第一个大于对照数跳出
{
j--;
}
if (i >= j)//如果前面的位置大于后面的证明数组循环一遍了，跳出循环
{
break;

}
swap(arr, i, j);
}
QuickSort(arr, left, i);
QuickSort(arr, i + 1, right);
}
}

private void swap(List<int> arr, int i, int j)
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}