算法

算法大全： http://www.2cto.com/kf/201401/274983.html http://blog.csdn.net/xuemoyao/article/details/8035076 http://www.studyofnet.com/news/186.html

平均时间复杂度从高到低依次是：
选择排序（o(n2)），冒泡排序（o(n2)），插入排序（o(n2)），快速排序（o(nlogn)），堆排序（o(nlogn)），归并排序（o(nlogn)）， 希尔排序（o(n1.25)），基数排序（o(n)），桶排序
稳定性算法:   基数排序 , 直接插入排序 , 冒泡排序, 归并排序
不稳定性算法: 桶排序, 二分插入排序,希尔排序, 快速排序, 简单选择排序,堆排序
1.选择排序
原理：第一次从数组中选出最小的数，将它放在数组的第一位置，第二次再从数组中选出最小的数，将它放置在第二个位置，以后每次都选出最小的数，按照上边的排序方式，放置在数组中合适的位置，这样到最后选出的数就是有序的。
代码：
Private void static XuanZe()
{
Int [ ] shuJu=new int [int]{ 12,43,2,34,87,54,32,16,67,49};
Int  min,temp;//分别用来标记最小的数组中最小数的下表，和存储临时数据（数字交换时使用）
For(int i=0;i<shuJu.Length-1;i++)
{
     Min=i;//标记下表为（当前的排序次数-1）的数组数字为当前的最小值
     For(int j=i+1;j<shuJu.Length;j++)//依次和数组中的其他数据进行比较，如果其他数据有比当前标记的最小值小的，则数组最小值下表赋值为两者之间较小值的下标
     {
       If(shuJu[j]<shuJu[min])
        {
           Min=j;
        }
        Temp=shuJu[i];
        shuJu[i]=shuJu[min];
        shuJu[min]=temp;
     }
}
最差时间复杂度 О(n²)
最优时间复杂度 О(n²)
平均时间复杂度 О(n²)代码：
2.冒泡排序
原理：从头开始，每一个元素和它的下一个元素比较，如果它大，就将它与比较的元素交换，否则不动。大的元素总是在向后慢慢移动直到遇到比它更大的元素。所以每一轮交换完成都能将最大值
冒到最后。
代码：
Private static void MaoPao()
{
Int [ ] shuJu=new int [int]{ 12,43,2,34,87,54,32,16,67,49};
For(int i=1;i<=shuJu.Length-1;i++)
{
   For(int j=shuJu.Length;j>=i;j--)
    {
      If(shuJu[j]<shuJu[j-1])
        {
         Int temp=shuJu[j];
         shuJu[j]=shuJu[j-1];
         shuJu[j-1]=temp;
        }
   }
}
最差时间复杂度 O(n*n)
最优时间复杂度 O(n)
平均时间复杂度 O(n*n})

3.插入排序
原理：每次向数组中插入一个数，将插入的数与之前插入的有序的数进行比较，如果大于之前插入的数，则直接插入，如果小于之前插入的数，则进行交换后再插入，这样到最后插入的数全部都是有序的。
代码：
Private static void ChaRu()
{
Int [ ] shuJu=new int [int]{ 12,43,2,34,87,54,32,16,67,49};
Int temp;
For(int i=1;i<shuJu.Length;i++)
{
   Int t=shuJu[i];//标记为排序的数据
   Int j=i;
   While(j>0 && shuJu[j-1]>t) 如果当前未排数据小于上一个数据，且当前j大于0，则将上一个数据移致当前的数据所在的下标位置，同时j下标要减一，
   {
      shuJu[j]=shuJu[j-1];
      j--;
   }
   shuJu[j]=t;
 }   
}
最差时间复杂度 O(n*n)
最优时间复杂度 O(n)
平均时间复杂度O(n*n)

4.快速排序
原理：主要用到了“分治”的思想，先将数组中找到任意一个数为基准分成两部分，一般是用数组的中间元素，并且使左边部分的数字全部小于基准数字，右边的部分全部大于基准数字，然后在递归调用快速排序分别对左右区间进行排序，这样形成的数组就是有序的了。
代码：
private static void KaiSu(int[] shuJu,int left,int right)
{
     shuJu=new int [int]{ 12,43,2,34,87,54,32,16,67,49};
     int a=left-1;//左区域
     int b=right+1;//右区域
     int mid = shuJu[(left + right) / 2];//基准数字
     if (left < right)
     {
       while (true)
       {
          while (shuJu[++a] <mid);
          while (shuJu[--b] > mid);
          if (a >= b)
          {
              break;
           }
           int temp = shuJu[a];
           shuJu[a] = shuJu[b];
           shuJu[b] = temp;
        }
           KaiSu(shuJu, left, a );//再递归调用对左区域进行排序
           KaiSu(shuJu, b, right);//递归调用对右区域进行排序
      }

5.希尔排序
原理：：取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量   =1(   <   …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。
代码：
public void Sort(int[] list)
{
                int inc;
                for (inc = 1; inc <= list.Length / 9; inc = 3 * inc + 1) ;
                for (; inc > 0; inc /= 3)
                {
                    for (int i = inc + 1; i <= list.Length; i += inc)
                    {
                        int t = list[i - 1];
                        int j = i;
                        while ((j > inc) && (list[j - inc - 1] > t))
                        {
                            list[j - 1] = list[j - inc - 1];
                            j -= inc;
                        }
                        list[j - 1] = t;
                    }
                }
}
最差时间复杂度 根据步长串行的不同而不同。O(nlog^2 n)
最优时间复杂度 O(n)
平均时间复杂度  根据步长串行的不同而不同。
6.基数排序

7.归并排序 原理：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

8.堆排序

9.二分查找的基本思想是将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2],则找到x,算法中止；如果x<a[n/2],则只要在数组a的左半部分继续搜索x,如果x>a[n/2],则只要在数组a的右半部搜索x.