- 目录
冒泡排序
冒泡排序：比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置，直到没有元素再需要交换，排序完成。
代码实现：
using System;
namespace cchoop
{
class Program
{
static void Main(string[] args)
{
int[] arr = new int[] { 23, 45, 23, 22, 3, 4, 1, 0 };
BubbleSort(arr);
foreach (var item in arr)
{
Console.Write(item + " ");
}
}
static void BubbleSort(int[] arr)
{
for (int i = 0; i < arr.Length - 1; i++)
{
for (int j = 0; j < arr.Length - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
}鸡尾酒排序（改进的冒泡排序）
鸡尾酒排序：也叫定向冒泡排序，是冒泡排序的一种改进。此算法与冒泡排序的不同处在于从低到高然后从高到低，而冒泡排序则仅从低到高去比较序列里的每个元素。他可以得到比冒泡排序稍微好一点的效能。
代码实现：
using System;
namespace cchoop
{
class Program
{
static void Main(string[] args)
{
int[] arr = new int[] { 23, 45, 23, 22, 3, 4, 1, 0 };
CocktailSort(arr);
foreach (var item in arr)
{
Console.Write(item + " ");
}
}
static void CocktailSort(int[] arr)
{
int left = 0;
int right = arr.Length - 1;
while (left < right)
{
for (int i = left; i < right; i++)
{
if (arr[i] > arr[i + 1])
{
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
right--;
for (int i = right; i > left; i--)
{
if (arr[i] < arr[i - 1])
{
int temp = arr[i];
arr[i] = arr[i - 1];
arr[i - 1] = temp;
}
}
left++;
}
}
}
}选择排序
选择排序：初始时在序列中找到最小（大）元素，放到序列的起始位置作为已排序序列；然后，再从剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
实现代码：
using System;
using System.Collections;
using System.Collections.Generic;
namespace cchoop
{
class Program
{
static void Main(string[] args)
{
int[] arr = new int[] { 23, 45, 23, 22, 3, 4, 1, 0 };
SelectionSort(arr);
foreach (var item in arr)
{
Console.Write(item + " ");
}
}
static void SelectionSort(int[] arr)
{
for (int i = 0; i < arr.Length - 1; i++)
{
int minIndex = i;
for (int j = i + 1; j < arr.Length; j++)
{
if (arr[j] < arr[minIndex])
{
minIndex = j;
}
}
if (minIndex != i)
{
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
}
}插入排序
插入排序：从第一个元素开始，该元素可以认为已经被排序，取出下一个元素，在已经排序的元素序列中从后向前扫描
如果该元素（已排序）大于新元素，将该元素移到下一位置，直到找到已排序的元素小于或者等于新元素的位置，将新元素插入到该位置，重复以上步骤直到数组排好序。
代码实现：
using System;
using System.Collections;
using System.Collections.Generic;
namespace cchoop
{
class Program
{
static void Main(string[] args)
{
int[] arr = new int[] { 23, 45, 23, 22, 3, 4, 1, 0 };
InsertionSort(arr);
foreach (var item in arr)
{
Console.Write(item + " ");
}
}
static void InsertionSort(int[] arr)
{
for (int i = 1; i < arr.Length; i++)
{
int temp = arr[i];
for (int j = i - 1; j >= 0; j--)
{
if (temp < arr[j])
{
arr[j + 1] = arr[j];
if (j == 0) //如果这个要插入的数最小，把它放在首位
{
arr[j] = temp;
}
continue;
}
if (j + 1 != i)
{
arr[j + 1] = temp;
}
break;
}
}
}
}
}二分插入排序
对于插入排序，如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的次数，我们称为二分插入排序
二分插入排序：插入操作的改进版，通过数组查找二分法来查找到元素应该插入到的位置，在进行插入操作，可以有一定概率减少比较操作的次数。
using System;
using System.Collections;
using System.Collections.Generic;
namespace cchoop
{
class Program
{
static void Main(string[] args)
{
int[] arr = new int[] { 23, 45, 23, 22, 3, 4, 1, 0 };
InsertionSortDichotomy(arr);
foreach (var item in arr)
{
Console.Write(item + " ");
}
}
static void InsertionSortDichotomy(int[] arr)
{
for (int i = 1; i < arr.Length; i++)
{
int temp = arr[i];
int index = SelectDichotomy(arr, i - 1, temp);
for (int j = i - 1; j >= index; j--)
{
arr[j + 1] = arr[j];
}
arr[index] = temp;
}
}
//二分查找到下标
static int SelectDichotomy(int[] arr, int right, int value)
{
int left = 0;
while (left <= right)
{
int mindle = (left + right) / 2;
if (arr[mindle] <= value)
{
left = mindle + 1;
}
else
{
right = mindle - 1;
}
}
return left;
}
}
}快速排序
快速排序的思想：选择一个基准数（一般为左边第一个数），比它大的排在它的右边，比它小的排在右边，然后以这个数为基准线，对左右分而治之，重复上面的操作。
代码实现：
using System;
using System.Collections;
using System.Collections.Generic;
namespace cchoop
{
class Program
{
static void Main(string[] args)
{
int[] arr = new int[] { 23, 45, 23, 22, 3, 4, 1, 0 };
QuickSort(arr, 0, arr.Length - 1);
foreach (var item in arr)
{
Console.Write(item + " ");
}
}
//3, 4, 1, 23, 45, 22
//挖坑法，左右分治
static void QuickSort(int[] arr, int low, int high)
{
if (low < high)
{
int index = QucikSortUnit(arr, low, high);
QuickSort(arr, low, index - 1);
QuickSort(arr, index + 1, high);
}
}
static int QucikSortUnit(int[] arr, int low, int high)
{
int temp = arr[low];
while (low < high)
{
while (low < high && arr[high] > temp)
{
high--;
}
arr[low] = arr[high];
while (low < high && arr[low] <= temp)
{
low++;
}
arr[high] = arr[low];
}
arr[low] = temp;
return low;
}
}
}