经典排序算法（Java版）

 

经典排序算法（ Java 版）

权当复习，以备引用（理论来源于：http://www.zsqz.com/jsbase/Suanfa/index.html?defination.htm，感谢该网站。JAVA源码为我所写）

1、冒泡排序 Bubble Sort

最简单的排序方法是冒泡排序方法。这种方法的基本思想是，将待排序的元素看作是竖着排列的 “ 气泡 ” ，较小的元素比较轻，从而要往上浮。在冒泡排序算法中我们要对这个 “ 气泡 ” 序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即 “ 轻 ” 的元素在下面，就交换它们的位置。显然，处理一遍之后， “ 最轻 ” 的元素就浮到了最高位置；处理二遍之后， “ 次轻 ” 的元素就浮到了次高位置。在作第二遍处理时，由于最高位置上的元素已是 “ 最轻 ” 元素，所以不必检查。一般地，第 i 遍处理时，不必检查第 i 高位置以上的元素，因为经过前面 i-1 遍的处理，它们已正确地排好序。这个算法可实现如下。

算法如下：

/**

      * 冒泡排序

      * @param src 待排序数组

      */

    void doBubbleSort( int [] src)

    {

       int len=src. length ;

       for ( int i=0;i<len;i++)

       {

           for ( int j=i+1;j<len;j++)

           {

              int temp;

              if (src[i]>src[j])

              {

                  temp=src[j];

                  src[j]=src[i];

                  src[i]=temp;

              }            

           }

           printResult(i,src);

       }     

    }

2、选择排序 Selection Sort

选择排序的基本思想是：对待排序的记录序列进行 n-1 遍的处理，第 1 遍处理是将 L[1..n] 中最小者与 L[1] 交换位置，第 2 遍处理是将 L[2..n] 中最小者与 L[2] 交换位置， ...... ，第 i 遍处理是将 L[i..n] 中最小者与 L[i] 交换位置。这样，经过 i 遍处理之后，前 i 个记录的位置就已经按从小到大的顺序排列好了。
　　当然，实际操作时，也可以根据需要，通过从待排序的记录中选择最大者与其首记录交换位置，按从大到小的顺序进行排序处理。

算法如下：

       /**

      * 选择排序

      * @param src 待排序的数组

      */

    void doChooseSort( int [] src)

    {

       int len=src. length ;

       int temp;

       for ( int i=0;i<len;i++)

       {

           temp=src[i];

           int j;

           int samllestLocation=i; // 最小数的下标

           for (j=i+1;j<len;j++)

           {

              if (src[j]<temp)

              {

                  temp=src[j]; // 取出最小值

                  samllestLocation=j; // 取出最小值所在下标

              }

           }

           src[samllestLocation]=src[i];

           src[i]=temp;

           printResult(i,src);

       }

    }

3 、插入排序 Insertion Sort

插入排序的基本思想是，经过 i-1 遍处理后 ,L[1..i-1] 己排好序。第 i 遍处理仅将 L[i] 插入 L[1..i-1] 的适当位置，使得 L[1..i] 又是排好序的序列。要达到这个目的，我们可以用顺序比较的方法。首先比较 L[i] 和 L[i-1] ，如果 L[i-1]≤ L[i] 騆 [1..i] 已排好序，第 i 遍处理就结束了；否则交换 L[i] 与 L[i-1] 的位置，继续比较 L[i-1] 和 L[i-2] ，直到找到某一个位置 j(1≤j≤i-1) ，使得 L[j] ≤L[j+1] 时为止。
　　简言之 , 插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。插入排序方法分直接插入排序和折半插入排序两种，这里只介绍直接插入排序，折半插入排序留到 “ 查找 ” 内容中进行。
　　图 1 演示了对 4 个元素进行直接插入排序的过程，共需要 (a),(b),(c) 三次插入。

图 1 对 4 个元素进行插入排序

在下面的插入排序算法中，为了写程序方便我们可以引入一个哨兵元素 L[0] ，它小于 L[1..n] 中任一记录。所以，我们设元素的类型 ElementType 中有一个常量 -∞ ，它比可能出现的任何记录都小。如果常量 -∞ 不好事先确定，就必须在决定 L[i] 是否向前移动之前检查当前位置是否为 1 ，若当前位置已经为 1 时就应结束第 i 遍的处理。另一个办法是在第 i 遍处理开始时，就将 L[i] 放入 L[0] 中，这样也可以保证在适当的时候结束第 i 遍处理。下面的算法中将对当前位置进行判断。

算法如下：

    /**

      * 插入排序 (WHILE 循环实现 )

      * @param src 待排序数组

      */

    void doInsertSort1( int [] src)

    {

       int len=src. length ;

       for ( int i=1;i<len;i++)

       {  

           int temp=src[i];

           int j=i;

          

           while (src[j-1]>temp)

           {

              src[j]=src[j-1];

              j--;

              if (j<=0)

                  break ;

           }

           src[j]=temp;

           printResult(i+1,src);

       }

    }

    /**

      * 插入排序 (FOR 循环实现 )

      * @param src 待排序数组

      */

    void doInsertSort2( int [] src)

    {

       int len=src. length ;

       for ( int i=1;i<len;i++)

       {

           int j;

           int temp=src[i];

           for (j=i;j>0;j--)

           {

              if (src[j-1]>temp)

              {

                  src[j]=src[j-1];

                 

              } else // 如果当前的数，不小前面的数，那就说明不小于前面所有的数，

                    // 因为前面已经是排好了序的，所以直接通出当前一轮的比较

                  break ;

           }

           src[j]=temp;

           printResult(i,src);

       }

    }