常用排序查找算法c#（冒泡，插入，选择，希尔，快排，二分，堆，归并）
排序模版：
public static bool less(int a,int b)
{
return a - b < 0;
}
public static void exch(int[] a,int i,int j)
{
int t = a[i];
a[i] = a[j];
a[j] = t;
}
（1）冒泡排序
int[] arr = { 2, 3, 4, 67, 23, 99, 1 };
冒泡排序 n^2，稳定的排序算法 bubble sort
for (int j = 0; j <= arr.Length - 1; j++)
{
for (int i = 0; i < arr.Length - 1 - j; i++)
{
if (arr[i] > arr[i + 1])
{
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
}
（2）插入排序
过程如图所示：
插入排序，希尔排序是其的改良版 n^2，稳定排序
public int[] Insertion(int[] a)
{
int length = a.Length;
for(int i = 1; i < length; i++)
{
for(int j = i; j > 0 && less(a[j], a[j - 1]); j--)
{
exch(a, j, j - 1);
}
}
return a;
}
（3）选择排序
选择排序 n^2 不是稳定排序
public int[] Selection(int[] a)
{
int length = a.Length;
for(int i = 0; i < length; i++)
{
int min = i;
for(int j = i+1; j<a.Length;j++)
{
if (less(a[j], a[min]))
min = j;
}
exch(a, i, min);
}
return a;
}
（4）希尔排序
ps：分的间隔算法可以不一样
希尔排序 nlog2n 稳定排序
public int[] shell(int[] a)
{
int length = a.Length;
int h = 1;
while (h<length/3) h = 3 * h + 1;//分好间隔
while (h >= 1)//一直逆推，让间隔=1
{
for (int i = h; i < length; i++)
{
for (int j = i; j >= h && less(a[j], a[j - h]); j -= h)
{
exch(a, j, j - h);
}
}
h = h / 3;
}
return a;
}
（5）快速排序
快速排序：空间1，时间nlogn，是一种不稳定的排序算法
private static void QuickSort(int[] arr,int begin,int end){
if(begin>=end) return;
int pivotIndex=QuickSort_Once(arr,begin,end);
QuickSort(arr,begin,pivotIndex-1);
QuickSort(arr,pivotIndex+1,end);
}
private static int QuickSort_Once(int[] arr,int begin,int end){
int pivot=arr[begin];
int i=begin;
int j=end;
while(i<j){
while(arr[j]>=pivot&&i<j)
j--;
arr[i]=arr[j];
while(arr[i]<=pivot&&i<j)
i++;
arr[j]=arr[i];
}
arr[i]=pivot;
return i;
}
}
（6）折半查找，二分查找，时间复杂度logn。
条件：一定要有序。
public int Search_Bin(int[] arr，int key)
{
int low=0;
int high=arr.length-1;
while(low<=high){
int mid=(low+high)/2
if(arr[mid]==key) return mid;
else if(key<arr[mid])
high=mid-1;
else if(key>arr[mid])
low=mid+1;
}
return 0;
}
（7）堆排序
时间复杂度：nlogn
不稳定排序
///
if (max != i)
{
exch(tree, max, i);
heapify(tree, n, max);
}
return tree;
}
/// （8）归并排序 nlogn，稳定排序
///