C#学习笔记——常见算法

冒泡排序

设置数组初始值为 int[] array=new int[]{8,4,6,2}

冒泡的思想就是依次比较相邻两个值的大小，依次比较过后总是最大的值排在最后

比如8，4，6，2

两两比较：4，8交换 形成4，8，6，2

8，6交换 形成 4，6，8，2

最终4，6，2，8

然后第一轮结束开始下一轮比较

依次进行，结束

int[] BuddingSort(int[] arr)
	{

		for (var i = 0; i < arr.Length - 1; i++)
		{
			for (var j = 1; j < arr.Length - i; j++)
			{
				if (arr[j - 1] > arr[j])
				{
					int a = arr[j - 1];
					arr[j - 1] = arr[j];
					arr[j] = a;

				}
			}
		}
		return arr;
	}

选择排序

设置数组初始值为 int[] array=new int[]{8,4,6,2}

选择排序的思想就是依次找出该序列中最小的一个数字

比如8，4，6，2

设置初始值为i=0，也就是8

依次和后面数字进行比较

如果有比8小的数字，设置最小值为新的数字在和后面的比较

 int min=8;

4<8

min=4,在和后面数字比较

4>2

min=2

最终索引=0的值为2

依次类推

int[] SelectSort(int[] arr)
	{
		for (var i = 0; i < arr.Length; i++)
		{
			int min = arr[i];
			int index = i;
			for (var j = 1 + i; j < arr.Length; j++)
			{
				if (min > arr[j])
				{
					min = arr[j];
					index = j;
				}
			}
			if (min != arr[i])
			{
				arr[index] = arr[i];
				arr[i] = min;
			}
		}

		return arr;
	}

插入排序

插入排序的思想是根据最新的值与前面的值做比较，根据值的大小插入相应的位置

有点类似于打扑克

比如我手里现在有三张牌分别是{2，3，7}

现在新来的一张牌大小为6，插入3，7之间

设置数组初始值为 int[] array=new int[]{8,4,6,9，1}

假设现在我手里只有一张牌为8，也就是array[0]

新来的第一张牌为4，大小比8小，交换位置

交换后4，8

又新来一张牌6，顺序4，6，8

新来一张牌为9，这时我们发现只有当新的牌值比左边值小的时候才需要更换，否则不用更改

依次类推

int[] InsertSort(int[] arr)
	{
		for (var i = 1; i < arr.Length; i++)
		{
			int compare = arr[i];
			for (var j = i - 1; j > 0; j--)
			{
				if (arr[i] >= arr[j])
				{
					break;
				}
				else
				{
					//交换
					arr[i] = arr[j];
					arr[j] = compare;
				}
			}

		}

		return arr;
	}

快速排序

快速排序的思想是将当前值找到其应该对应的索引

设置数组初始值为 int[] array=new int[]{3,8,4,6,2}

快速排序需要一开始设置一个初始值，然后找到其应该处于的位置

比如上述3，8，4，6，2

我们设置第一个数值3为初始值

如果我们手动去排序3的索引应该是几

2，3，4，6，8

应该是第二位

那么我们现在开始进行排序

首先我们找到比3大的数字全部放在3的右边，比3小的数字全部放在3的左边

做法：从数组末尾向前查找小于当前初始值的值，再从左边找大于初始值的值，当它们的位置交换

我们从最数组右边开始查找值为2，2的值比3小，说明它应该在3左边，这时停止查找，因为我们要交换位置了，那么跟谁交换位置，

当然是大于3的数，我们从左边开始查找，第一个数字8就是大于当前3的数值，好，停在这里

我们将8和2交换位置

3，8，4，6，2交换

3，2，4，6，8

我们再次从新的数组也就是3，2，4，6，8进行查找

从右边开始查找小于3的数，找到谁了只有2，从左边查找也是到2停止了，因为左右两边查找已经交汇了，不能再往下交换了要不就乱套了

此时已经不用找了，直接将3和2进行位置交换为

2，3，4，6，8

我们此时发现3正好是处于第二个位置也就是他应该所在的索引

不过这个数组排好序了只是碰巧

正常将3找到他的位置之后，这个3就已经不能动了因为他的索引已经是正确了的

接下来只需要在进行3左边的模块和3右边的模块排序就可以了

/// <summary>
	/// 快速排序
	/// </summary>
	/// <returns></returns>
	int[] QuickSort(int[] array, int leftIndex, int rightIndex)
	{
		if (leftIndex >= rightIndex)
		{
			return null;
		}
		else
		{
			int mindleIndex = array[leftIndex];

			int i = leftIndex;
			int j = rightIndex;
			while (i != j)
			{
				while (array[j] >= mindleIndex && i < j)
					j--;
				while (array[i] <= mindleIndex && i < j)//再找右边的
					i++;
				if (i < j)
				{
					int t = array[i];
					array[i] = array[j];
					array[j] = t;
				}
			}
			array[leftIndex] = array[i];
			array[i] = mindleIndex;
			QuickSort(array, leftIndex, i - 1);
			QuickSort(array, i + 1, rightIndex);


		}
		return array;
	}

完整代码如下： 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Arithmatic : MonoBehaviour
{
	void PrintArr(int[] m)
	{
		print("打印开始");
		foreach (var item in m)
		{
			print("数字：" + item);
		}
	}
	int[] array = new int[] { 54, 0, 654, 6, -1 };
	int[] array2 = new int[] { 6, 1, 2, 7, 9, 11, 4, 5, 10, 8 };
	private void Start()
	{

		//PrintArr(BuddingSort(array));
		//PrintArr(SelectSort(array2));
		//PrintArr(InsertSort(array2));
		PrintArr(QuickSort(array2, 0, array2.Length - 1));


	}
	#region 冒泡
	/// <summary>
	/// 冒泡
	/// </summary>
	/// <param name="arr"></param>
	/// <returns></returns>
	int[] BuddingSort(int[] arr)
	{

		for (var i = 0; i < arr.Length - 1; i++)
		{
			for (var j = 1; j < arr.Length - i; j++)
			{
				if (arr[j - 1] > arr[j])
				{
					int a = arr[j - 1];
					arr[j - 1] = arr[j];
					arr[j] = a;

				}
			}
		}
		return arr;
	}
	#endregion

	#region 选择排序
	/// <summary>
	/// 选择排序
	/// </summary>
	/// <param name="arr"></param>
	/// <returns></returns>
	int[] SelectSort(int[] arr)
	{
		for (var i = 0; i < arr.Length; i++)
		{
			int min = arr[i];
			int index = i;
			for (var j = 1 + i; j < arr.Length; j++)
			{
				if (min > arr[j])
				{
					min = arr[j];
					index = j;
				}
			}
			if (min != arr[i])
			{
				arr[index] = arr[i];
				arr[i] = min;
			}
		}

		return arr;
	}
	#endregion

	#region insert
	/// <summary>
	/// 插入排序
	/// 判断新来的值是否比左侧值大   
	/// 	int[] array = new int[] { 54, 0, -5, 6, -1 };   
	/// 	int[] array = new int[] { 54, -5,0, 6, -1 };   
	/// </summary>
	/// <param name="arr"></param>
	/// <returns></returns>
	int[] InsertSort(int[] arr)
	{
		for (var i = 1; i < arr.Length; i++)
		{
			int compare = arr[i];
			for (var j = i - 1; j > 0; j--)
			{
				if (arr[i] >= arr[j])
				{
					break;
				}
				else
				{
					//交换
					arr[i] = arr[j];
					arr[j] = compare;
				}
			}

		}

		return arr;
	}
	#endregion

	/// <summary>
	/// 快速排序
	/// </summary>
	/// <returns></returns>
	int[] QuickSort(int[] array, int leftIndex, int rightIndex)
	{
		if (leftIndex >= rightIndex)
		{
			return null;
		}
		else
		{
			int mindleIndex = array[leftIndex];

			int i = leftIndex;
			int j = rightIndex;
			while (i != j)
			{ 
				while (array[j] >= mindleIndex && i < j)
					j--;
				while (array[i] <= mindleIndex && i < j)//再找右边的
					i++;
				if (i < j)
				{
					int t = array[i];
					array[i] = array[j];
					array[j] = t;
				}
			}	
			array[leftIndex] = array[i];
			array[i] = mindleIndex;
			QuickSort(array, leftIndex, i - 1);
			QuickSort(array, i + 1, rightIndex);


		}
		return array;
	}


}