深入浅出算法
分类:正版必中一肖图计算机

深入浅出排序算法,深入浅出算法

    最近在忙着准备找工作,对于码农来说,找工作之前必备的就是各种的排序算法,其中包括算法实现、复杂度分析。于是我也开始研究各种排序算法,但是看完几遍之后发现,其原理并不复杂,于是就在思考,这些算法这么重要,那么它们在实际解决问题时如何来使用呢?这篇文章我就个人的理解,尽量形象、简单的描述各种基本排序算法的原理,并对其复杂度进行了相应的分析,最后说明其在实际使用中的应用。我希望我的这篇文章尽量的通俗形象,让我们展开想象的空间吧!

一、算法原理分析:

 1、冒泡排序:

  首先从它的名字上来理解它的原理,假设一个湖底从左到右并排了10(n)个泡泡,我们在湖底从左向右游动,每次只比较相邻的两个泡泡,如果左边的比右边的小则交换其位置,这样游玩了一趟之后,即比较了9(n-1)次,最大的那个就得到了,这时我们将这个泡泡冒出水面,以此类推,我们需要这样重复9(n-1)次即可(考虑最后只剩下两个),每一次需要比较(n-i)次,j为跑了的次数。

伪代码如下:

    for i = 1:n-1 (n-1趟)

      for j = 1:n-i(比较n-i次)

        if a[j] > a[j + 1]

          swap(a[j],a[j+1])

        endif

      endfor

    endfor

当然由于数组元素从0开始,则编程时只需要将循环的首尾均减一即可。

复杂度分析:本算法共有两个循环,外循环共(n-1)个,内循环共(n-i)个,则总数为(n-1)+(n-2)+...+1 = [n*(n-1)]/2=O(n^2).

 2、插入排序:

    本算法也从其名字来理解,这次我们想象一下学生们排队好了,每个学生的身高都不同,现在希望他们能够快速的按照从矮到高的顺序排好队。我们的策略是插入的人都和队伍中的人挨个比,如果比队伍中的人矮,那就将队伍中的人向后移动一个位置,一直到合适的位置将其插入进去。这时候我们假设第一个元素已经在数组中了(因为没人和他比),这时我们只需要将剩下的n-1个人插入到队伍中就好了。假设队伍中已经插入了i个人,则第i+1个人需要和队伍中的i个人比才可以。

  for i = 2:n  //插入第i个人

    key = a[i]; //设其为关键字用来跟每一个位置进行比较

    j = i-1;

    for j = i-1:1 //关键字和前面i-1个人比较

        if a[j] > key //大于关键字则将其向后移动一个,空一个空出来

      a[j+1] = a[j];

     else   //如果key大于队伍中的值时就退出

      break;

     endif

    endfor

    a[j+1] = key;//将其插入到该值的后面

  endfor

复杂度分析:该算法也包含两层循环,外层有n-1个元素,内层有i-1个元素,则共有1+2+...+n-1 = [n*(n-1)]/2 = O(n^2)

 

稍微休息一下,纵观以上两个算法,虽然算法不同,但是都得需要循环比较,在相对有序时,快速排序的内层循环可以快速退出,因此其效果相对好一点,而冒泡排序还是从头比较。

 3、归并排序:

  看了两个循环嵌套的算法,下面看看递归的算法吧。归并排序是典型的具有归并性质的算法。先来说说它的思想,归并,换言之就是合并,既然要合并那就得先把原来的数组分开吧。咱们还是接着上面的例子,我们先将队伍分成两组,然后对两组排序,排序后进行合并。分成的两组其实又可以继续分为两组并合并,因此此处就可以使用递归的方法。

 

Merge://合并的代码

input:a[]

n1 = med;

n2 = n-med;

L[] = a[1:n1];

R[] = a[med+1:n];

L[n1+1] = 65535;//哨兵牌,每次到这之后只将剩下的那一摞放到数组中即可

R[n2+1] = 65535;

 

i = 1:n1;

j = 1:n2;

 for k = 1:n

  if(L[i] < R[j])

    a[k] = L[i]

    i++;

  else

    a[k] = R[j]

    j++;

  endif

endfor

MergeSort:

  q = n/2;

  MergeSort(a,1,q);

  MergeSort(a,q+1,n);

  Merge(a,1,q,n);

复杂度分析:对于递归调用的复杂度分析,要明白主方法:T(n)=aT(n/b)+f(n) 要掌握三种情况:1)如果f(n)比n^(log(b)a)小,则T(n) = Ot(n^(log(b)a));2)如果f(n)比n^(log(b)a)大,则T(n)= ot(f(n));3)如果f(n)和n^(log(b)a)差不多大,则T(n)= ot(n^(log(b)a) * lgn)。

在此算法中,a = 2,b = 2;故 n^(log(b)a) = n = f(n),所以满足3),故T(n)= O(nlgn)。虽然该算法时间很快,但是需要使用两个数组来存储L和R,典型的空间换取时间的手法。

4、快速排序:

  听到这个名字,相必大家很快就觉得这个算法肯定很快,事实上也确实如此。该算法也采用了分而治之以及递归的思想。其主要的思想是:先随机选择一个关键人物作为标准,将比他矮的放到左边,比他高的放到右边。然后再在剩下的两组中按照此种方法进行递归。

Partition://分开确定pivot的位置,方便将其分开递归排序

  pivote = a[1];//将第一个人作为标准

  p_low = 1;

  for i = 2:n

    if a[i]<pivote

     swap(a[i],a[p_low]);

     p_low++;

     endif

     endfor

return p_low;

QuickSort:

  p = Partition(a,1,n);  

  QuickSort(a,1,p-1);

  QuickSort(a,p+1,n);

复杂度分析:类似于归并排序,该算法也将原问题分成两部分,T(n)=  T(n/p)+T(n/(1-p))+n,其最好情况T(n)=2T(n/2)+n=O(nlgn),最坏的情况是T(n)= T(n-1)+O(n),T(n) = O(n^2);而对于不均分的情况,分析得出T(n)=O(nlgn)。

                该算法虽然和快速排序算法的复杂度一样,但是该算法在基本排好序的情况下属于最坏的情况,因此使用时需谨慎。

5、堆排序:

  下面就来说一说堆排序,堆排序相对于上面几种排序稍微麻烦一点,但是只要掌握其精髓,也是很容易理解的。这个举实际的例子确实不太好举,但是大家可以想象出一棵二叉树。

  堆排序,主要利用了最大堆和最小堆,其本质就是棵二叉树。

  该排序过程大概可以分成如下三步:1)建立一个二叉树  2)将堆变为最大堆(即将最大值转移到堆顶),从最后一个非叶子节点开始  3)将堆顶元素和最后一个元素互换,然后调整堆,使其满足最大堆(堆长度在变)

 1)此处不需要什么操作,只是提醒大家数组中的元素在树中的位置为前序遍历存储(根左右)

2)

BuildMaxHeap(a,n):

  第一个非叶子节点为:n/2

  for i = n/2:1

    HeapAjust(a,i,n);

  end

HeapAjust(a,i):调整为最大堆

  l=LEFT(i);//左子树

  r = RIGHT(i);//右子树

  if l<n && a[l] > a[i]

    largest = l;

  endif

  if r<n && a[r] >a[largest]

    largest = r;

  endif

  if largest != i

    swap(a[i],a[largest]);

    HeapAjust(a,largest);

  endif

HeapSort(a,n)

  BuildMaxHeap(a,n);

  for i  = n:2

    swap(a[1],a[i];

    HeapAjust(a,1,i-1);

  endfor

复杂度分析:该算法主要包括两部分,第一部分是堆调整O(lgn),建最大堆时,共调用(n/2)次,故其为O(nlgn).堆排序时主要包括O(nlgn)+ O(nlgn) = O(nlgn)

堆排序不需要大量的递归或者多维的暂存数组。这对于数据量非常巨大的序列是合适的。比如超过数百万条记录,因为快速排序,归并排序都使用递归来设计算法,在数据量非常大的时候,可能会发生堆栈溢出错误。但是快速的时间一般线性增长,但是堆排序为nlgn的速度。

最近在忙着准备找工作,对于码农来说,找工作之前必备的就是各种的排序算法,其中包括算法实现、复...

本文由正版必中一肖图发布于正版必中一肖图计算机,转载请注明出处:深入浅出算法

上一篇:别返回引用 下一篇:没有了
猜你喜欢
热门排行
精彩图文