算法

算法大全: 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.

 

posted @ 2016-06-18 15:59  李寒星  阅读(191)  评论(0编辑  收藏  举报