C#算法

递归

 

任何一个方法既能够调用其余方法又能够调用本身,而当这个方法调用本身时,咱们就叫它递归函数或者递归方法!

一般递归有两个特色:    

1.递归方法一直会调用本身直到某些条件知足,也就是说必定要有出口;

2.递归方法会有一些参数,而它会把这些新的参数值传递给本身;(本身调本身);

冒泡排序

经过相邻两个值的大小比较（屡次），保证数值排序为从小到大的排序方法。

　　　　效果及实现原理：外层的数列个数次的循环，每次循环会将最大的数值“冒泡”到右端，由于是相邻的两两比较。

　　　　具体实现：双重循环，外层数列个数次，保证每个数值都处于正确位置（由于每循环一次，至少会肯定一个数值的正确位置），内层从数列个数次逐渐减小次数，由于每一次外层循环会肯定最大值、倒数第二大值……咱们在下一次循环就能够忽略掉他们。

 

插入排序

插入排序（Insert Sort）：本质上是待排序列里的元素一个一个的与已排列好的元素进行比较，将其插入到已排列好的序列中，直到没有待排列的元素。相似于打牌的时候摸牌的动做：手上的牌是排列好的，桌子上的牌是待排序的，每从桌子上抓到一只牌，按照必定次序将其插入到手中

int i = 0, j = 0;
int key;
for (j = 1; j < array.Length; j++)
{
　　key = array[j];
　　i = j - 1;
　　while (i >= 0 && array[i] > key)
　　{
　　　　array[i + 1] = array[i];
　　　　i -= 1;
　　}
　　array[i + 1] = key;
　　Console.Write("Step {0}:", j);
　　DisplayArrayToConsole(array);
}

 

快速排序

快速排序（Quicksort）是对 冒泡排序的一种改进。

（在数据量小于20的时候，插入排序具备最好的性能。当大于20时，快速排序具备最好的性能，归并(merge sort)和堆排序(heap sort)也可望不可即，尽管复杂度都为nlog2(n)。）

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：经过一趟排序将要排序的数据分割成独立的两部分，其中一部分的全部数据都比另一部分的全部数据都要小，而后再按此方法对这两部分数据分别进行快速排序，整个排序过程能够递归进行，以此达到整个数据变成有序序列。

由此思想，咱们能够实现快速排序的代码：
注意基准数据永远不变，永远是和基准数据进行比较，不管在什么位置，最后的目的就是把基准数据放在中间，小的放前面大的放后面。

namespace QuickSort
{
class QuickSort
{
private int Func(int[] n, int left, int right)
{
　　int baseNum = n[left]; // 基准数据

　　int i = left;
　　int j = right;
　　while (true)
　　{
　　　　if (n[i] < baseNum && i < j)
　　　　{
　　　　　　i++;
　　　　}
　　　　else if (n[i] > baseNum && i < j)
　　　　{
　　　　　　int number = n[i];
　　　　　　n[i] = n[j];
　　　　　　n[j] = number;
　　　　　　j--;
　　　　}
　　　　else if (n[j] < baseNum && i < j)
　　　　{
　　　　　　int number = n[i];
　　　　　　n[i] = n[j];
　　　　　　n[j] = number;
　　　　　　i++;
　　　　}
　　　　else if (n[j] > baseNum && i < j)
　　　　{
　　　　　　j--;
　　　　}
　　　　else if (i == j)
　　　　{
　　　　　　n[i] = baseNum;
　　　　　　break;
　　　　}
　　}
　　return i;
}

public void QuickSortFunc(int[] n, int left, int right)
{
　　//左下标必定小于右下标，不然就超越了
　　if (left < right)
　　{
　　　　//对数组进行分割，取出下次分割的基准标号
　　　　int i = Func(n, left, right);

　　　　//对“基准标号“左侧的一组数值进行递归的切割，以致于将这些数值完整的排序
　　　　QuickSortFunc(n, left, i - 1);

　　　　//对“基准标号“右侧的一组数值进行递归的切割，以致于将这些数值完整的排序
　　　　QuickSortFunc(n, i + 1, right);

　　}
}
static void Main(string[] args)
{
　　int[] n = { 23, 45, 60, 10, 17, 101,12};
　　QuickSort qs = new QuickSort();
　　qs.QuickSortFunc(n, 0, n.Length - 1);
　　for (int i = 0; i < n.Length; i++)
　　{　　
　　　　Console.WriteLine(n[i]);
　　}

　　Console.ReadLine();
}
}
}

归并排序

 归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题而后递归求解，而治(conquer)的阶段则将分的阶段获得的各答案"修补"在一块儿，即分而治之)。

而它的时间复杂度就是N*logN，此算法采用的是二分法，因此能够认为对应的对数函数底数为2，也有多是三分法，底数为3，以此类推。

每次合并操做的平均时间复杂度为O(n)，而彻底二叉树的深度为|log2n|。总的平均时间复杂度为O(nlogn)。并且，归并排序的最好，最坏，平均时间复杂度均为O(nlogn)。

 

外排序

 

Bit-map空间压缩和快速排序去重

1. Bit-map的基本思想　　32位机器上，对于一个整型数，好比int a=1 在内存中占32bit位，这是为了方便计算机的运算。可是对于某些应用场景而言，这属于一种巨大的浪费，由于咱们能够用对应的32bit位对应存储十进制的0-31个数，而这就是Bit-map的基本思想。Bit-map算法利用这种思想处理大量数据的排序、查询以及去重。　　Bitmap在用户群作交集和并集运算的时候也有极大的便利。