C#之快速排序 C#之插入排序 C#之选择排序 C#之冒泡排序
C#之快速排序
算法描述
1.假定数组首位元素为“枢轴”，设定数列首位（begin）与末位（end）索引；
2.由末位索引对应元素与“枢轴”进行比较，如果末位索引对应元素大于“枢轴”元素，对末位索引减一（end--），直到比较出大于“枢轴”元素，将该元素覆盖到首位，对应索引上的数值空出；
3.由首位索引对应元素与“枢轴”进行比较，如果首位索引对应元素小于“枢轴”元素，对首位索引加一（begin++）;直到比较出小于“枢轴”元素，将该元素覆盖到步骤2中空出位置，同时对应索引上的数值空出；
4.重复步骤2与步骤3，直到begin==end结束循环，这时候begin与end已指向同一位置，将“枢轴”元素覆盖到该位置；
5.这时候该位置前面元素都小于“枢轴”元素，该位置后面元素都大于“枢轴”元素，第一轮循环结束，对前后两部分执行相同步骤，通过“递归”最终将数组中数值完成排序；
代码实现
public int[] Quick(int[] arr, int begin, int end) // 通过自我调用实现“递归”
{
if (begin >= end)
{
return arr;
}
int pivotIndex = QuickCondition(arr, begin, end); // 获得“枢轴”索引
Quick(arr, begin, pivotIndex - 1); // 对所有小于“枢轴”元素再次比较
Quick(arr, pivotIndex + 1, end);// 对所有大于“枢轴”元素再次比较
return arr;
}
public int QuickCondition(int[] arr, int begin, int end)
{
int pivot = arr[begin]; // 设定首位为“枢轴”元素
while (begin < end)
{
while (arr[end] > pivot && begin < end) // 通过比较找到小于“枢轴”元素的索引，进行替换
{
end--;
}
arr[begin] = arr[end];
while (arr[begin] < pivot && begin < end) // 通过比较找到第大于“枢轴”元素的索引，进行替换
{
begin++;
}
arr[end] = arr[begin];
}
arr[begin] = pivot; // 当begin == end 跳出循环将“枢轴”覆盖到该索引上
return begin;
}
完整代码
using System;
namespace QuickSortApplication
{
class Program
{
static void Main(string[] args)
{
var setArray = new SetArray();
var quickSort = new QuickSort();
int[] arr = setArray.GetArray();
int[] array = quickSort.Quick(arr, 0, arr.Length - 1);
quickSort.DisPlay(array);
Console.ReadLine();
}
}
class SetArray
{
public int[] GetArray()
{
int length;
int[] arr;
Console.WriteLine("请输入数组长度：");
length = Convert.ToInt32(Console.ReadLine());
arr = new int[length];
for (int i = 0; i <= length - 1; i++)
{
Console.Write("请输入数组第{0}位数值：", i);
arr[i] = Convert.ToInt32(Console.ReadLine());
}
Console.Clear();
Console.Write("arr[] = {");
foreach (int item in arr)
{
Console.Write(item + " ");
}
Console.Write("}\n");
return arr;
}
}
class QuickSort
{
public int[] Quick(int[] arr, int begin, int end) // 通过自我调用实现“递归”
{
if (begin >= end)
{
return arr;
}
int pivotIndex = QuickCondition(arr, begin, end); // 获得“枢轴”索引
Quick(arr, begin, pivotIndex - 1); // 对所有小于“枢轴”元素再次比较
Quick(arr, pivotIndex + 1, end);// 对所有大于“枢轴”元素再次比较
return arr;
}
public int QuickCondition(int[] arr, int begin, int end)
{
int pivot = arr[begin]; // 设定首位为“枢轴”元素
while (begin < end)
{
while (arr[end] > pivot && begin < end) // 通过比较找到小于“枢轴”元素的索引，进行替换
{
end--;
}
arr[begin] = arr[end];
while (arr[begin] < pivot && begin < end) // 通过比较找到第大于“枢轴”元素的索引，进行替换
{
begin++;
}
arr[end] = arr[begin];
}
arr[begin] = pivot; // 当begin == end 跳出循环将“枢轴”覆盖到该索引上
return begin;
}
public void DisPlay(int[] arr)
{
Console.Write("快速排序：");
foreach (int item in arr)
{
Console.Write(item + " ");
}
Console.WriteLine();
}
}
}
C#之插入排序
算法描述
1.假定数组第一位为有序序列，抽出后一位元素与有序序列中元素依次比较；
2.如果有序序列元素大于抽出元素，将该元素向后移位；
3.重复前面步骤依次抽取无序序列中首位元素进行比较，直到所有数值排序完成；
代码实现
/*
例如：对数组：{ 2，7，6，3，1 }进行比较
第一轮：{ 2，7，6，3，1 } ：共比较一次
第二轮：{ 2，6，7，3，1 } ：共比较二次
第三轮：{ 2，3，4，7，1 } ：共比较三次
第四轮：{ 1，2，3，6，7 } ：共比较四次
*/
public void Insert(int[] arr)
{
int number;
int numIndex;
for (int i = 1; i < arr.Length; i++)
{
number = arr[i];
numIndex = i - 1;
while (numIndex >= 0 && number < arr[numIndex])
{
arr[numIndex + 1] = arr[numIndex];
numIndex--;
}
arr[numIndex + 1] = number;
Console.Write("插入排序：");
foreach (int item in arr)
{
Console.Write(item + " ");
}
Console.WriteLine();
}
}
完整代码
using System;
namespace InsertSortApplication
{
class Program
{
static void Main(string[] args)
{
var setArray = new SetArray();
var insertSort = new InsertSort();
int[] arr = setArray.GetArray();
insertSort.Insert(arr);
Console.ReadLine();
}
}
class SetArray
{
public int[] GetArray()
{
int length;
int[] arr;
Console.WriteLine("请输入数组长度：");
length = Convert.ToInt32(Console.ReadLine());
arr = new int[length];
for (int i = 0; i <= length - 1; i++)
{
Console.Write("请输入数值第{0}位数值：", i);
arr[i] = Convert.ToInt32(Console.ReadLine());
}
Console.Clear();
Console.Write("arr[] = {");
foreach (int item in arr)
{
Console.Write(item + " ");
}
Console.Write("}\n");
return arr;
}
}
class InsertSort // 插入排序
{
public void Insert(int[] arr)
{
int number;
int numIndex;
for (int i = 1; i < arr.Length; i++)
{
number = arr[i];
numIndex = i - 1;
while (numIndex >= 0 && number < arr[numIndex])
{
arr[numIndex + 1] = arr[numIndex];
numIndex--;
}
arr[numIndex + 1] = number;
}
Console.Write("插入排序：");
foreach (int item in arr)
{
Console.Write(item + " ");
}
Console.WriteLine();
}
}
}
C#之选择排序
算法描述
1.假定未排序序列中第一位为数组最小值，通过与后面的数值进行比较，找到未排序序列中最小值，与未排序序列第一位交换位置；
2.重复步骤一，对剩余未排序序列进行比较找出最小值，与未排序序列中第一位数值交换位置，直到数组所有数值排序完成；
代码实现
/*
例如：对数组：{ 2，7，6，3，1 }进行比较
第一轮：{ 1，7，6，3，2 } ：共比较四次
第二轮：{ 1，2，6，3，7 } ：共比较三次
第三轮：{ 1，2，3，6，7 } ：共比较二次
第四轮：{ 1，2，3，6，7 } ：共比较一次
*/
public void Select(int[] arr)
{
int temp;
int number;
int numIndex;
bool flag;
for (int i = 0; i < arr.Length -1; i++)
{
flag = true;
number = arr[i];
numIndex = i;
for (int j = i + 1; j < arr.Length; j++)
{
if (number > arr[j])
{
number = arr[j];
numIndex = j;
flag = false;
}
}
temp = arr[i];
arr[i] = arr[numIndex];
arr[numIndex] = temp;
if (flag == true)
{
break;
}
Console.Write("选择排序：");
foreach (int item in arr)
{
Console.Write(item + " ");
}
Console.WriteLine();
}
}
完整代码
using System;
namespace SelectSortApplication
{
class Program
{
static void Main(string[] args)
{
var setArray = new SetArray();
var selectSort = new SelectSort();
int[] arr = setArray.GetArray();
selectSort.Select(arr);
Console.ReadLine();
}
}
class SetArray
{
public int[] GetArray()
{
int length;
int[] arr;
Console.WriteLine("请输入数组长度：");
length = Convert.ToInt32(Console.ReadLine());
arr = new int[length];
for (int i = 0; i <= length -1; i++)
{
Console.Write("请输入数组第{0}位数值：", i);
arr[i] = Convert.ToInt32(Console.ReadLine());
}
Console.Clear();
Console.Write("arr[] = {");
foreach (int item in arr)
{
Console.Write(item + " ");
}
Console.Write("}\n");
return arr;
}
}
class SelectSort
{
public void Select(int[] arr)
{
int temp;
int number;
int numIndex;
bool flag;
for (int i = 0; i < arr.Length -1; i++)
{
flag = true;
number = arr[i];
numIndex = i;
for (int j = i + 1; j < arr.Length; j++)
{
if (number > arr[j])
{
number = arr[j];
numIndex = j;
flag = false;
}
}
temp = arr[i];
arr[i] = arr[numIndex];
arr[numIndex] = temp;
if (flag == true)
{
break;
}
}
Console.Write("选择排序：");
foreach (int item in arr)
{
Console.Write(item + " ");
}
Console.WriteLine();
}
}
}
C#之冒泡排序
算法描述
1.由数组第一位数值开始与相邻数值进行比较，每次将比较后大的数值后移。最后将会把数组中最大值移动到数组最后；
2.依次对数组中未排序序列重复进行比较排序，将比较后的最大值移动到未排序序列的最后；
代码实现
/*
例如：对数组：{ 5，4，3，2，1 }进行比较
第一轮：{ 4，3，2，1，5 } ：共比较四次
第二轮：{ 3，2，1，4，5 } ：共比较三次
第三轮：{ 2，1，3，4，5 } ：共比较二次
第四轮：{ 1，2，3，4，5 } ：共比较一次
*/
public void Bubble(int[] arr)
{
int temp;
bool flag;
for (int i = 0; i < arr.Length - 1; i++) // 循环轮数
{
flag = true;
for (int j = 0; j < arr.Length - i - 1; j++) // 比较次数
{
if (arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
flag = false;
}
}
if (flag == true)
{
break;
}
}
Console.Write("冒泡排序：");
foreach (int item in arr)
{
Console.Write(item + " ");
}
}
完整代码
using System;
namespace BubbleSortApplication
{
class Program
{
static void Main(string[] args)
{
var setArray = new SetArray();
var bubbleSort = new BubbleSort();
int[] arr = setArray.GetArray();
bubbleSort.Bubble(arr);
Console.ReadLine();
}
}
class SetArray // 数组类
{
public int[] GetArray()
{
int length; // 数组长度
int[] arr;
Console.WriteLine("请输入数组长度：");
length = Convert.ToInt32(Console.ReadLine());
arr = new int[length];
for (int i = 0; i <= length - 1; i++)
{
Console.Write("请输入数组第{0}位数值：", i);
arr[i] = Convert.ToInt32(Console.ReadLine());
}
Console.Clear();
Console.Write("arr[] = {");
foreach (int item in arr)
{
Console.Write(item + " ");
}
Console.Write("}\n");
return arr;
}
}
class BubbleSort // 冒泡排序
{
public void Bubble(int[] arr)
{
int temp;
bool flag;
for (int i = 0; i < arr.Length - 1; i++)
{
flag = true;
for (int j = 0; j < arr.Length - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
flag = false;
}
}
if (flag == true)
{
break;
}
}
Console.Write("冒泡排序：");
foreach (int item in arr)
{
Console.Write(item + " ");
}
}
}
}
