冒泡排序
private void BubbleSort(int[] array)
{
bool isSwapped;
for (int i = 0; i < array.Length; i++)
{
isSwapped = false;
//经过这一趟 最大的数已经到底
for (int j = 0; j < array.Length - 1 - i; j++)
{
int v1 = array[j];
int v2 = array[j + 1];
if (v1 > v2)
{
array[j] = v2;
array[j + 1] = v1;
isSwapped = true;
}
}
//没有发生过交换说明已经有序
if (!isSwapped)
break;
}
}
选择排序
private void SelectionSort(int[] array)
{
for (int i = 0; i < array.Length - 1; i++)
{
int minIndex = i;
for (int j = i + 1; j < array.Length; j++)
{
if (array[j] < array[minIndex])
minIndex = j;
}
int temp = array[minIndex];
array[minIndex] = array[i];
array[i] = temp;
}
}
插入排序
private void InsertSort(int[] array)
{
for (int i = 1; i < array.Length; i++)
{
int temp = array[i];
for (int j = i - 1; j >= 0; j--)
{
int val = array[j];
if (val > temp)
{
array[j + 1] = val;
array[j] = temp;
}
else
break;
}
}
}
希尔排序
private void ShellSort(int[] array, int gap)
{
while (true)
{
//以步长为gap做直接插入排序
for (int k = 0; k < gap; k++)
{
//以gap为步长的每一次直接插入排序
for (int i = gap + k; i < array.Length; i += gap)
{
int temp = array[i];
for (int j = i - gap; j >= 0; j -= gap)
{
int val = array[j];
if (val > temp)
{
array[j] = temp;
array[j + gap] = val;
}
else
break;
}
}
}
//做完步长为1后退出
if (gap == 1)
break;
//每次减少步长
gap = gap / 2 == 0 ? 1 : gap / 2;
}
}
归并排序
private List<int> Sort(List<int> array)
{
if (array.Count <= 1)
return array;
int mid = array.Count / 2;
List<int> left = new List<int>();
List<int> right = new List<int>();
for (int i = 0; i < mid; i++)
left.Add(array[i]);
for (int i = mid; i < array.Count; i++)
right.Add(array[i]);
left = Sort(left);
right = Sort(right);
return Merge(left, right);
}
private List<int> Merge(List<int> left, List<int> right)
{
List<int> result = new List<int>();
int i = 0, j = 0;
int v1 = 0, v2 = 0;
while (i < left.Count && j < right.Count)
{
v1 = left[i];
v2 = right[j];
if (v1 <= v2)
{
result.Add(v1);
i++;
}
else
{
result.Add(v2);
j++;
}
}
//将剩余的数直接挪到result中
if (j >= right.Count)
{
for (int k = i; k < left.Count; k++)
{
result.Add(left[k]);
}
}
if (i >= left.Count)
{
for (int k = j; k < right.Count; k++)
{
result.Add(right[k]);
}
}
return result;
}
//更简单的写法
private List<int> Merge(List<int> left, List<int> right)
{
List<int> result = new List<int>();
int v1 = 0, v2 = 0;
while (left.Count > 0 && right.Count > 0)
{
v1 = left[0];
v2 = right[0];
if (v1 <= v2)
{
result.Add(v1);
left.RemoveAt(0);
}
else
{
result.Add(v2);
right.RemoveAt(0);
}
}
//将剩余的数直接挪到result中
if (left.Count > 0)
{
for (int k = 0; k < left.Count; k++)
{
result.Add(left[k]);
}
}
if (right.Count > 0)
{
for (int k = 0; k < right.Count; k++)
{
result.Add(right[k]);
}
}
return result;
}
快速排序
private void QuickSort(List<int> array, int left, int right)
{
if (left < right)
{
int mid = Sort(array, left, right);
QuickSort(array, left, mid - 1);
QuickSort(array, mid + 1, right);
}
}
private int Sort(List<int> array, int left, int right)
{
int temp = array[left];
while (left < right)
{
while (left < right && temp <= array[right])
{
right--;
}
array[left] = array[right];
while (left < right && temp >= array[left])
{
left++;
}
array[right] = array[left];
}
array[right] = temp;
return right;
}
//非递归版
//利用栈,其实递归本质上也是利用栈
private void QuickSort(List<int> array, int left, int right)
{
Stack<int> stack = new Stack<int>();
stack.Push(left);
stack.Push(right);
while (stack.Count > 0)
{
right = stack.Pop();
left = stack.Pop();
int mid = Sort(array, left, right);
if (left < mid - 1)
{
stack.Push(left);
stack.Push(mid - 1);
}
if (mid + 1 < right)
{
stack.Push(mid + 1);
stack.Push(right);
}
}
}
堆排序
private void HeapAdjust(ref int[] arr, int start, int end)
{
int parent = start;
int child = start * 2 + 1;
while (child <= end)
{
//从孩子节点中选择一个较大的与父节点比较
if (child + 1 <= end && arr[child + 1] > arr[child])
child++;
//子节点大则交换位置
if (arr[child] > arr[parent])
{
int temp = arr[parent];
arr[parent] = arr[child];
arr[child] = temp;
parent = child;
child = parent * 2 + 1;
}
//否则如果父节点大于子节点代表调整完毕
else
{
break;
}
}
}
private void HeapSort(ref int[] arr)
{
//初始化大根堆
for (int i = arr.Length / 2 - 1; i >= 0; i--)
{
HeapAdjust(ref arr, i, arr.Length - 1);
}
for (int i = arr.Length - 1; i > 0; i--)
{
//将最大值放到最后
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
//调整大根堆
HeapAdjust(ref arr, 0, i - 1);
}
}