排序(C#版)
1.冒泡排序
using System;
using System.Collections.Generic;
using System.Text;
/// <summary>
/// 冒泡排序
/// </summary>
public class BubbleSorter
{
private static int[] myArray;
private static int arraySize;
public static void Sort(int[] a)
{
myArray = a;
arraySize = myArray.Length;
BubbleSort(myArray);
}
/// <summary>
/// 冒泡算法
/// </summary>
/// <param name="myArray"></param>
public static void BubbleSort(int[] myArray)
{
for (int i = 0; i < myArray.Length; i++)//循环的趟数
{
for (int j = 0; j < myArray.Length - 1 - i; j++)//每次循环的次数
{
if (myArray[j] > myArray[j + 1])
{
Swap(ref myArray[j], ref myArray[j + 1]);
}
}
}
}
/// <summary>
/// 交换
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
private static void Swap(ref int left, ref int right)
{
int temp;
temp = left;
left = right;
right = temp;
}
public static void Main(string[] args)
{
int[] a = new int[] { 4, 2, 1, 6, 3, 6, 0, -5, 1, 1 };
BubbleSorter.Sort(a);
for (int i = 0; i < a.Length; i++)
{
System.Console.WriteLine(a[i]);
}
}
}
2.鸡尾酒排序（双冒泡排序、搅拌排序或涟漪排序）
using System;
using System.Collections.Generic;
using System.Text;
public class CockTailSorter
{
private static int[] myArray;
private static int arraySize;
public static void Sort(int[] a)
{
myArray = a;
arraySize = myArray.Length;
CockTailSort(myArray);
}
public static void CockTailSort(int[] myArray)
{
int low, up, index, i;
low = 0;
up = myArray.Length - 1;
index = low;
while (up > low)
{
for (i = low; i < up; i++)//从上向下扫描
{
if (myArray[i] > myArray[i + 1])
{
Swap(ref myArray[i], ref myArray[i + 1]);
index = i;
}
}
up = index;//记录最后一个交换的位置
for (i = up; i > low; i--)//从最后一个交换位置从下往上扫描
{
if (myArray[i] < myArray[i - 1])
{
Swap(ref myArray[i], ref myArray[i - 1]);
index = i;
}
}
low = index;//记录最后一个交换的位置
}
}
/// <summary>
/// 交换
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
private static void Swap(ref int left, ref int right)
{
int temp;
temp = left;
left = right;
right = temp;
}
public static void Main(string[] args)
{
int[] a = new int[] { 4, 2, 1, 6, 3, 6, 0, -5, 1, 1 };
CockTailSorter.Sort(a);
for (int i = 0; i < a.Length; i++)
{
System.Console.WriteLine(a[i]);
}
}
}
3.选择排序
using System;
using System.Collections.Generic;
using System.Text;
public class SelectSorter
{
private static int[] myArray;
private static int arraySize;
public static void Sort(int[] a)
{
myArray = a;
arraySize = myArray.Length;
SelectSort(myArray);
}
/// <summary>
///
/// </summary>
/// <param name="myArray"></param>
public static void SelectSort(int[] myArray)
{
int i, j, smallest;
for (i = 0; i < myArray.Length - 1; i++)//数据起始位置，从0到倒数第二个数据
{
smallest = i;//记录最小数据的下标
for (j = i + 1; j < myArray.Length; j++)
{
if (myArray[j] < myArray[smallest])//在剩下的数据中寻找最小数据
{
smallest = j;//如果有比它更小的，记录下标
}
}
Swap(ref myArray[i], ref myArray[smallest]);//将最小数据和未排序的第一个数据交换
}
}
/// <summary>
/// 交换
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
private static void Swap(ref int left, ref int right)
{
int temp;
temp = left;
left = right;
right = temp;
}
public static void Main(string[] args)
{
int[] a = new int[] { 4, 2, 1, 6, 3, 6, 0, -5, 1, 1 };
SelectSorter.Sort(a);
for (int i = 0; i < a.Length; i++)
{
System.Console.WriteLine(a[i]);
}
}
}
4.插入排序
using System;
using System.Collections.Generic;
using System.Text;
public class InsertSorter
{
private static int[] myArray;
private static int arraySize;
public static void Sort(int[] a)
{
myArray = a;
arraySize = myArray.Length;
InsertSort(myArray);
}
/// <summary>
///
/// </summary>
/// <param name="myArray"></param>
public static void InsertSort(int[] myArray)
{
int i, j, temp;
for (i = 1; i < myArray.Length; i++)
{
temp = myArray[i];//保存当前数据
j = i - 1;
//将数据插入有序表中，如果表中的数据比该数据大
//那么就依次向后移动有序表中的数据，直到找到第一个比它小的数据
//将它放在那个数据后面
while (j >= 0 && myArray[j] > temp)
{
myArray[j + 1] = myArray[j];
j--;
}
myArray[j + 1] = temp;
}
}
public static void Main(string[] args)
{
int[] a = new int[] { 4, 2, 1, 6, 3, 6, 0, -5, 1, 1 };
InsertSorter.Sort(a);
for (int i = 0; i < a.Length; i++)
{
System.Console.WriteLine(a[i]);
}
}
}
5.希尔排序
using System;
using System.Collections.Generic;
using System.Text;
public class ShellSorter
{
private static int[] myArray;
private static int arraySize;
public static void Sort(int[] a)
{
myArray = a;
arraySize = myArray.Length;
ShellSort(myArray);
}
/// <summary>
///
/// </summary>
/// <param name="myArray"></param>
public static void ShellSort(int[] myArray)
{
int i, j, increment;
int temp;
for (increment = myArray.Length / 2; increment > 0; increment /= 2)
{
for (i = increment; i < myArray.Length; i++)
{
temp = myArray[i];
for (j = i; j >= increment; j -= increment)
{
if (temp < myArray[j - increment])
myArray[j] = myArray[j - increment];
else
break;
}
myArray[j] = temp;
}
}
}
public static void Main(string[] args)
{
int[] a = new int[] { 4, 2, 1, 6, 3, 6, 0, -5, 1, 1 };
ShellSorter.Sort(a);
for (int i = 0; i < a.Length; i++)
{
System.Console.WriteLine(a[i]);
}
}
}
6.快速排序
using System;
using System.Collections.Generic;
using System.Text;
public class QuickSorter
{
private static int[] myArray;
private static int arraySize;
public static void Sort(int[] a)
{
myArray = a;
arraySize = myArray.Length;
QuickSort(myArray, 0, myArray.Length - 1);
}
/// <summary>
/// 快速排序算法
/// </summary>
/// <param name="myArray"></param>
public static void QuickSort(int[] myArray, int left, int right)
{
int i, j, s;
if (left < right)
{
i = left - 1;
j = right + 1;
s = myArray[(i + j) / 2];
while (true)
{
while (myArray[++i] < s) ;
while (myArray[--j] > s) ;
if (i >= j)
break;
Swap(ref myArray[i], ref myArray[j]);
}
QuickSort(myArray, left, i - 1);
QuickSort(myArray, j + 1, right);
}
}
/// <summary>
/// 交换
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
private static void Swap(ref int left, ref int right)
{
int temp;
temp = left;
left = right;
right = temp;
}
public static void Main(string[] args)
{
int[] a = new int[] { 4, 2, 1, 6, 3, 6, 0, -5, 1, 1 };
QuickSorter.Sort(a);
for (int i = 0; i < a.Length; i++)
{
System.Console.WriteLine(a[i]);
}
}
}
7.归并排序
using System;
using System.Collections.Generic;
using System.Text;
public class MergeSorter
{
private static int[] myArray;
private static int arraySize;
public static void Sort(int[] a)
{
myArray = a;
arraySize = myArray.Length;
MergeSort();
}
/// <summary>
/// 利用归并的方法排序数组，首先将序列分割
/// 然后将数列归并
/// 时间是O(nlog n)
/// </summary>
/// <param name="myArray"></param>
public static void MergeSort()
{
int[] temp = new int[arraySize];
Msort(temp, 0, arraySize - 1);
}
private static void Msort(int[] temp, int left, int right)
{
int mid;
if (right > left)
{
mid = (right + left) / 2;
Msort(temp, left, mid);//分割左边的序列
Msort(temp, mid + 1, right);//分割右边的序列
Merge(temp, left, mid + 1, right);//归并序列
}
}
private static void Merge(int[] temp, int left, int mid, int right)
{
int i, left_end, num_elements, tmp_pos;
left_end = mid - 1;
tmp_pos = left;
num_elements = right - left + 1;
while ((left <= left_end) && (mid <= right))
{
if (myArray[left] <= myArray[mid])//将左端序列归并到temp数组中
{
temp[tmp_pos] = myArray[left];
tmp_pos = tmp_pos + 1;
left = left + 1;
}
else
{
temp[tmp_pos] = myArray[mid];
tmp_pos = tmp_pos + 1;
mid = mid + 1;
}
}
while (left <= left_end)//复制左边剩余的数据到temp数组中
{
temp[tmp_pos] = myArray[left];
left = left + 1;
tmp_pos = tmp_pos + 1;
}
while (mid <= right)//复制右边剩余的数据到temp数组中
{
temp[tmp_pos] = myArray[mid];
mid = mid + 1;
tmp_pos = tmp_pos + 1;
}
for (i = 0; i < num_elements; i++)
{
myArray[right] = temp[right];
right = right - 1;
}
}
public static void Main(string[] args)
{
int[] a = new int[] { 4, 2, 1, 6, 3, 6, 0, -5, 1, 1 };
MergeSorter.Sort(a);
for (int i = 0; i < a.Length; i++)
{
System.Console.WriteLine(a[i]);
}
}
}
8.堆排序
using System;
using System.Collections.Generic;
using System.Text;
public class HeapSorter
{
private static int[] myArray;
private static int arraySize;
public static void Sort(int[] a)
{
myArray = a;
arraySize = myArray.Length;
HeapSort();
}
public static void HeapSort()
{
BuildHeap();//将原始序列建成一个堆
while (arraySize > 1)
{
arraySize--;
Exchange(0, arraySize);//将最大值放在数组最后
TraversingHeap(0);//将序列从0到n-1看成一个新的序列，重新建立堆
}
}
private static void BuildHeap()
{
for (int vNode = arraySize / 2 - 1; vNode >= 0; vNode--)
{
TraversingHeap(vNode);
}
}
//利用向下遍历子节点建立队
private static void TraversingHeap(int vNode)
{
int wNode = 2 * vNode + 1;//结点wNode是节点vNode的第一个子结点
while (wNode < arraySize)
{
if (wNode + 1 < arraySize)//如果结点vNode下面有第二个子结点
if (myArray[wNode + 1] > myArray[wNode])
wNode++;//将子结点wNode设置成节点vNode下面值最大的子结点
if (myArray[vNode] >= myArray[wNode])
return;
Exchange(vNode, wNode);//如果不是，就交换节点vNode和结点wNode的值
vNode = wNode;
wNode = 2 * vNode + 1;//继续向下找子结点
}
}
private static void Exchange(int i, int j)
{
int t = myArray[i];
myArray[i] = myArray[j];
myArray[j] = t;
}
public static void Main(string[] args)
{
int[] a = new int[] { 4, 2, 1, 6, 3, 6, 0, -5, 1, 1 };
HeapSorter.Sort(a);
for (int i = 0; i < a.Length; i++)
{
System.Console.WriteLine(a[i]);
}
}
}
