简单排序

来源：互联网发布：淘宝网变形金刚玩具编辑：程序博客网时间：2024/05/17 07:48

冒泡排序算法：最慢的排序算法之一

详细分析：

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Linq;

usingSystem.Text;

usingSystem.Threading.Tasks;

namespace冒泡排序

{

class Program

{

static void Main(string[] args)

{

CArray nums =new CArray(10);

Random rnd =new Random(100);

for (inti = 0; i < 10; i++)

{

nums.Insert(rnd.Next(0, 100));

}

Console.WriteLine("排序前数组：");

nums.Display();

Console.WriteLine("排序过程：");

nums.BubbleSort();

Console.WriteLine("冒泡排序结果：");

nums.Display();

}

class CArray

{

#region 数组类测试环境

private int[] arr;

private int upper;

private int numElement;

public CArray(intsize)

{

arr =new int[size];

upper = size - 1;

numElement = 0;

}

public void Insert(intitem)

{

arr[numElement] = item;

numElement++;

}

public void Display()

{

for (inti = 0; i <= upper; i++)

{

Console.Write(arr[i] +" ");

}

Console.WriteLine();

}

public void Clear()

{

for (inti = 0; i < upper; i++)

{

arr[i] = 0;

}

numElement = 0;

}

#endregion

//冒泡排序算法

public void BubbleSort()

{

int temp;

for (intouter = upper; outer >= 1; outer--)

{

for (intinner = 0; inner <= upper - 1; inner++)

{

if (arr[inner] > arr[inner + 1])

{

temp = arr[inner];

arr[inner] = arr[inner + 1];

arr[inner + 1] = temp;

}

this.Display();

}

以上为冒泡排序算法的C#代码。

此图为排序输出结果。

外层循环用outer进行计数，根据数组中元素的个数进行设定循环次数。此因数组有元素10个

************************************************************************************************

排序前数组：

96 15 66 90 35 94 71 61 34 14

排序过程：

15 96 66 90 35 94 71 61 34 14

15 66 96 90 35 94 71 61 34 14

15 66 90 96 35 94 71 61 34 14

15 66 90 35 96 94 71 61 34 14

15 66 90 35 94 96 71 61 34 14

15 66 90 35 94 71 96 61 34 14

15 66 90 35 94 71 61 96 34 14

15 66 90 35 94 71 61 34 96 14

15 66 90 35 94 71 61 34 14 96

第1轮排序

15 66 90 35 94 71 61 34 14 96

15 66 35 90 94 71 61 34 14 96

15 66 35 90 71 94 61 34 14 96

15 66 35 90 71 61 94 34 14 96

15 66 35 90 71 61 34 94 14 96

15 66 35 90 71 61 34 14 94 96

第2轮排序

15 66 35 90 71 61 34 14 94 96

15 35 66 90 71 61 34 14 94 96

15 35 66 71 90 61 34 14 94 96

15 35 66 71 61 90 34 14 94 96

15 35 66 71 61 34 90 14 94 96

15 35 66 71 61 34 14 90 94 96

第3轮排序

15 35 66 71 61 34 14 90 94 96

15 35 66 61 71 34 14 90 94 96

15 35 66 61 34 71 14 90 94 96

15 35 66 61 34 14 71 90 94 96

第4轮排序

15 35 66 61 34 14 71 90 94 96

15 35 61 66 34 14 71 90 94 96

15 35 61 34 66 14 71 90 94 96

15 35 61 34 14 66 71 90 94 96

第5轮排序

15 35 61 34 14 66 71 90 94 96

15 35 34 61 14 66 71 90 94 96

15 35 34 14 61 66 71 90 94 96

第6轮排序

15 35 34 14 61 66 71 90 94 96

15 34 35 14 61 66 71 90 94 96

15 34 14 35 61 66 71 90 94 96

第7轮排序

15 34 14 35 61 66 71 90 94 96

15 14 34 35 61 66 71 90 94 96

第8轮排序

14 15 34 35 61 66 71 90 94 96

第9轮排序

冒泡排序结果：

14 15 34 35 61 66 71 90 94 96

**************************************************************************************************

选择排序算法：最简单排序算法之一

原理：从数组的起始处开始，把第一个元素与数组中的其他元素一一进行比较，然后，将最小的元素放在第0位置上，接着再从第1个位置开始再次进行排序操作。这种操作会一直到除最后一个元素外的每一个元素都作为新循环的起始点操作过后才终止。

使用了两层循环，外层循环从数组的第一个元素移动到数组的最后一个元素之前的元素，而内层循环则从数组的第二个元素移动到数组的最后一个元素，并且查找比当前外层循环所指元素更小的数值。在内层循环遍历一遍之后，就会把数组内最小值赋值到数组中合适的位置上。

在每次内层循环时，选择出比当前外层循环数值小的元素，记录其位置索引，直到本次内层循环遍历到最后获得最小数值的索引值，再进行元素的互换。

代码：

//选择排序

public void SelectSort()

{

int min, temp;

for (intouter = 0; outer <= upper; outer++)

{

min = outer;

for (intinner = outer + 1; inner <= upper; inner++)

{

if (arr[inner] < arr[min]) min = inner;

}

temp = arr[outer];

arr[outer] = arr[min];

arr[min] = temp;

this.Display();

}

排序结果：

插入排序算法：最简单排序算法之一

代码：

public void InsertionSort()

{

int inner, temp;

for (intouter = 1; outer <= upper; outer++)

{

temp = arr[outer];

inner = outer;

while (inner > 0 && arr[inner - 1] >= temp)

{

arr[inner] = arr[inner - 1];

inner -= 1;

}

arr[inner] = temp;

this.Display();

}

输出结果：

基础查找算法：

对列表内数据的查找的方法：顺序查找、二叉查找。

顺序查找适用于当数据在列表内随机排列的时候；二叉查找适用于当数据在列表内有序排列时。

顺序查找：也称线性查找。从记录集的开始处顺次遍历每条记录，指导找到所要的记录或者是达到数据集的末尾。从数组的起始处开始，把每个访问道德数组元素依次与所要查找的数值进行比较，如果找到匹配的数据项，纠结大户查找操作，如果便利到数组的末尾仍没有产生匹配，那么就说明此数值不再数组内。

代码：

public static bool SeqSearch(int[] arr, int sValue)

{

for (intindex = 0; index <= arr.Length - 1; index++)

{

if (arr[index] == sValue)

{

return true;

}

return false;

}

自组织数据加快顺序查找速度：

所要查询的数据如果处于集合的开始处，那么查找的速度将会大大增加。把数据集中的最频繁查找的数据项放在数据集的开始部分，那么在程序运行时进行查找操作的速度将大大加快。因为此过程是在程序运行中进行完成的，似乎程序具有自组织的能力，故称为自组织数据。

代码：

//逐步地将查找的元素向数据集的开始处进行移动，更符合现实需求。

static bool SeqSearch(int[] arr, int sValue)

{

for (intindex = 0; index < arr.Length; index++)

{

if (arr[index] == sValue)

{

Swap(arr, index, index - 1);

return true;

}

return false;

}

递归二叉查找：

实际上是一种递归算法。因为此算法会不断的划分数组直到找到所要的数据项（或者是查找完全部数组）才会终止，而每次划分都是表示成一个比原有问题规模更小的同类问题。

代码：

classProgram

{

static void Main(string[] args)

{

int[] nums =new int[10] { 11, 21, 31, 41, 51, 61, 71, 81, 91, 101 };

//Random rnd = new Random();

//for (int i = 0; i < 100; i++)

//{

// nums[i] = rnd.Next(0, 100);

//}

Console.WriteLine("原始数组为：");

for (intj = 0; j < nums.Length; j++)

{

Console.Write(nums[j] +" ");

}

Console.WriteLine();

int result1;

int result2;

result1 = RbinSearch(nums, 51, 1, 10);

result2 = Bsearch(nums, 51);

Console.WriteLine("用户自定义二叉查找的结果是："+ result1);

Console.WriteLine("系统内置二叉查找的结果是："+ result2);//内置二叉查找速度总比用户自定义的快10倍。

}

public static int RbinSearch(int[] arr, int value,int lower,int upper)

{

if (lower > upper)

{

return -1;

}

else

{

int mid;

mid = (int)(upper + lower) / 2;

//Console.WriteLine("(upper + lower) / 2为：" + mid);

if (value < arr[mid])

{

return RbinSearch(arr, value, lower, mid - 1);

}

else if (value == arr[mid])

{

return mid;

}

else

{

return RbinSearch(arr, value, mid + 1, upper);

}

static int Bsearch(int[] arr, int value)

{

return Array.BinarySearch(arr, value);

}

这里给出用户自定义二叉查找算法和系统内置的算法，系统内置的算法总是比用户自定义的要快10倍。因此需要用二叉查找时优先使用系统内置的实现方案。

阅读全文

0 0