排序算法(选择、希尔、二分插入、冒泡、直接插入、快速排序)

选择排序法                                                                                   

第1趟,在待排序记录r[1]~r[n]中选出最小的记录,将它与r[1]交换;第2趟,在待排序记录r[2]~r[n]中选出最小的记录,将它与r[2]交换;以此类推,第i趟在待排序记录r[i]~r[n]中选出最小的记录,将它与r[i]交换,使有序序列不断增长直到全部排序完毕。

初始序列:49 27 65 97 76 12 38 }

第1趟:12与49交换:12 { 27 65 97 76 49 38 }

第2趟:27不动:12 27 { 65 97 76 49 38 }

第3趟:65与38交换:12 27 38 { 97 76 49 65 }

第4趟:97与49交换:12 27 38 49 { 76 97 65 }

第5趟:65与76交换:12 27 38 49 65 { 97 76 }

第6趟:97与76交换:12 27 38 49 65 76 97 完成

代码                                                                                            

复制代码
public class Sort {       
    public static void main(String[] args) {         
        int[] i = { 1, 5, 6, 12, 4, 9, 3, 23, 39, 403, 596, 87 };         
        System.out.println("结果:");        
        xuanZe(i);         
        System.out.println();     
    }       
    // 选择排序算法     
    public static void xuanZe(int[] x) {        
        for (int i = 0; i < x.length; i++) {            
            int lowerIndex = i;             
            // 找出最小的一个索引             
            for (int j = i + 1; j < x.length; j++) {                 
                if (x[j] < x[lowerIndex]) {                     
                lowerIndex = j;                
                }            
            }             

            // 交换             
            int temp = x[i];
            x[i] = x[lowerIndex];
            x[lowerIndex] = temp;         
        }
        for (int i : x) {
            System.out.print(i + " ");
        }
    }
}  
复制代码

 

时间复杂度为O(N2

希尔排序                                                                                      

对于n个元素的数组,假设增量为 h:

第一趟  :  从第1个元素开始,每隔h取一个元素,那么最后可以得到n/h个元素,一边取,一边通过直接插入将这h个元素排序

第二趟  :  从第2个元素开始,每隔h取一个元素,跟第一趟一样。  

...

第h趟   :  从第h个元素开始,每隔h取一个元素,跟第一趟一样。

(此时,整个数组还不是有序的)

然后,减少h的值,重复上面的操作,直到h减小为1,排序完成。

1

代码                                                                                          

复制代码
public static void sort(int[] nums) {  
        int len = nums.length / 2;  
        while (len >=1) {  
            for (int i = 0; i < len; i++) {  
                // 直接插入排序对分组进行排序  
                for (int k = i; k < nums.length-len; k +=len) {  
                    int j = k + len;  
                    int temp = nums[j];  
  
                    while (k >= 0 && nums[k] > temp) {  
                        nums[j] = nums[k];  
                        k -= len;  
                        j -= len;  
                    }  
  
                    nums[j] = temp;  
                }  
            }  
            len = len/2;  
        }  
    }
复制代码

时间复杂度是O(N*lgN)

二分插入排序                                                                               

二分查找插入排序的原理:是直接插入排序的一个变种,区别是:在有序区中查找新元素插入位置时,为了减少元素比较次数提高效率,采用二分查找算法进行插入位置的确定。

代码                                                                                           

复制代码
public class BinarySearch1 {  
    public static void main(String args[])  
    {  
        int array[]={49,38,65,97,76,13,27};  
        binarySort(array,array.length);  
        System.out.println(Arrays.toString(array));  
    }  
      
    //二分查找  
    public static int binarySearch(int array[],int low,int high,int temp)  
    {  
        int mid=0;  
        while(low<=high)  
        {  
            mid=(low+high)/2;  
            if(array[mid]<temp&&temp<=array[mid+1])  
                return (mid+1);  
            else if(array[mid]<temp)  
                low = mid + 1;  
            else  
                high = mid -1;  
        }  
        return high;  
    }  
      
    //二分排序  
    public static void binarySort(int array[],int size)  
    {  
        int i,j,k,temp;  
        for(i=1;i<size;i++)  
        {  
            temp=array[i];  
            if(array[i]<array[0])  
                k=0;  
            else  
                k = binarySearch(array,0,i,temp);  
              
            for(j=i;j>k;j--)  
            {  
                array[j]=array[j-1];  
            }  
            array[k]=temp;  
            System.out.println(Arrays.toString(array));  
        }  
    }  
}

复制代码

冒泡法                                                                                         

第1趟:依次比较0和1、1和2、2和3...n-2和n-1索引处的元素,发现前面的大于后面的,就交换它们,这样一趟下来,最大的元素排到了最后面。

第2趟:继续按照第1趟的做法再做一遍,一趟下来,第二大的元素排到了最后面。

 ......

这样经过n-1趟比较、交换,n个数据排序完毕。如果某一趟没有交换,表明已经排序完毕,可提前结束排序。

代码                                                                                            

复制代码
int size = arr.length;
        for (int i = 0; i < size - 1; i++) {
            for (int j = 0; j < size - i - 1; j++) {
                if arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
         }
复制代码

冒泡排序最好的时间复杂度O(N);冒泡排序的最坏时间复杂度为O(N2)

综上,因此冒泡排序总的平均时间复杂度为O(N2)

冒泡排序

冒泡排序也被称为下沉排序,是一个简单的排序算法,通过多次重复比较每对相邻的元素,并按规定的顺序交换他们,最终把数列进行排好序。一直重复下去,直到结束。该算法得名于较小元素“气泡”会“浮到”列表顶部。由于只使用了比较操作,所以这是一个比较排序。

冒泡排序算法的运作如下:

1.    比较相邻的元素。如果第一个比第二个大,就交换他们两个。

2.    对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。

3.    针对所有的元素重复以上的步骤,除了最后一个。

4.    持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

由于它的简洁,冒泡排序通常被用来对于程序设计入门的学生介绍算法的概念。但同样简单的插入排序比冒泡排序性能更好,所以有些人认为不需要再教冒泡排序了。

 

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

public IList BubbleSort(IList arrayToSort)

{

    int n = arrayToSort.Count - 1;

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

    {

        for (int j = n; j > i; j--)

        {

            if (((IComparable)arrayToSort[j - 1]).CompareTo(arrayToSort[j]) > 0)

            {

                object temp = arrayToSort[j - 1];

                arrayToSort[j - 1] = arrayToSort[j];

                arrayToSort[j] = temp;

                //RedrawItem(j);

                //RedrawItem(j - 1);

                //pnlSamples.Refresh();

                //if (chkCreateAnimation.Checked)

               //     SavePicture();

            }

        }

    }

    return arrayToSort;

}

Worst case performance:

O(n2)

 

Best case performance:

O(n)

 

Average case performance:

O(n2)

 

Worst case space complexity:

O(1) auxiliary

 


直接插入法                                                                                  

第一趟:把第2个元素拿出来跟第1个元素对比,小的在前面、大的在后面。

第二趟:把第3个元素拿出来插入到前2个元素中,使他们有序。

第三趟:把第4个元素拿出来插入到前3个元素中,使他们有序。

......

第n-1趟:把第n个元素拿出来插入到前n-1个元素中,排序完成。

代码                                                                                           

复制代码
int size = arr.length;
        // 从第二个开始,遍历每一个数组元素
        for (int i = 1; i < size; i++) {
            // 取出来
            int temp = arr[i];
            // 从后往前遍历,找到插入位置
            int j;
            for (j = i - 1; j >= 0 && temp < arr[j]; j--) {
                arr[j + 1] = arr[];
            }
            // 由于上面的循环完毕之后执行了j--,所以这里给arr[j+1]赋值
            arr[j + 1] = temp;
         }
复制代码

直接插入排序属于稳定的排序,最坏时间复杂性为O(N2)空间复杂度为O(1)


插入排序

插入排序的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。

具体算法描述如下:

1.    从第一个元素开始,该元素可以认为已经被排序

2.    取出下一个元素,在已经排序的元素序列中从后向前扫描

3.    如果该元素(已排序)大于新元素,将该元素移到下一位置

4.    重复步骤3,直到找到已排序的元素小于或者等于新元素的位置

5.    将新元素插入到该位置后

6.    重复步骤2~5

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

public IList InsertionSort(IList arrayToSort)

{

    for (int i = 1; i < arrayToSort.Count; i++)

    {

        object val = arrayToSort[i];

        int j = i - 1;

        bool done = false;

        do

        {

            if (((IComparable)arrayToSort[j]).CompareTo(val) > 0)

            {

                arrayToSort[j + 1] = arrayToSort[j];

                //RedrawItem(j + 1);

               // pnlSamples.Refresh();

                //if (chkCreateAnimation.Checked)

                //    SavePicture();

                j--;

                if (j < 0)

                {

                    done = true;

                }

            }

            else

            {

                done = true;

            }

 

        } while (!done);

        arrayToSort[j + 1] = val;

 

        //RedrawItem(j + 1);

        //pnlSamples.Refresh();

       // if (chkCreateAnimation.Checked)

       //     SavePicture();

    }

    return arrayToSort;

}

Worst case performance:

O(n2)

 

Best case performance:

O(n)

 

Average case performance:

O(n2)

 

Worst case space complexity:

O(1)

 


快速排序法                                                                                  

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

通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

一趟快速排序的算法是:

1)设置两个变量i、j,排序开始的时候:i=0,j=N-1;

2)以第一个数组元素作为关键数据,赋值给key,即key=A[0];

3)从j开始向前搜索,即由后开始向前搜索(j--),找到第一个小于key的值A[j],将A[j]赋给A[i];

4)从i开始向后搜索,即由前开始向后搜索(i++),找到第一个大于key的A[i],将A[i]赋给A[j];

5)重复第3、4步,直到i=j; (3,4步中,没找到符合条件的值,即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值,使得j=j-1,i=i+1,直至找到为止。找到符合条件的值,进行交换的时候i, j指针位置不变。另外,i==j这一过程一定正好是i+或j-完成的时候,此时令循环结束)。

代码                                                                                            

复制代码
public class Main {
    /**
     * @param pData
     *            需要排序的数组
     * @param left
     *            左边的位置,初始值为0
     * @param right
     *            右边的位置,初始值为数组长度
     */
    public static void QuickSort(int[] pData, int left, int right) {
        int i, j;
        int first, temp;
        i = left;
        j = right;
        first = pData[left]; // 这里选其他的数也行,不过一般选第一个
        // 一趟快速排序
        while (true) {
            // 从第二个数开始找大于中枢的数 ,从前面开始找大于pData[left]的数
            while ((++i) < right - 1 && pData[i] < first)
                ;
            // 从最后一个数开始找第一个小于中枢pData[left]的数
            while ((--j) > left && pData[j] > first)
                ;
            if (i >= j)
                break;
            // 交换两边找到的数
            temp = pData[i];
            pData[i] = pData[j];
            pData[j] = temp;

        }
        // 交换中枢
        pData[left] = pData[j];
        pData[j] = first;
        // 递归快排中枢左边的数据
        if (left < j)
            QuickSort(pData, left, j);
        // 递归快排中枢右边的数据
        if (right > i)
            QuickSort(pData, i, right);
    }

    public static void main(String[] args) {

        int[] pData = new int[5];
        for (int i = 0; i < 5; i++)
            pData[i] = (int) (Math.random() * 100);// Produce 10 random integers

        for (int i = 0; i < pData.length; i++) {
            System.out.print(pData[i] + " ");
        }
        Main.QuickSort(pData, 0, pData.length);

        System.out.println("\n***********************");

        for (int i = 0; i < pData.length; i++) {
            System.out.print(pData[i] + " ");
        }
    }
}
复制代码

快速排序

快速排序采用分而治之的策略,把一个列表划分为两个子列表。步骤是:

·        从列表中,选择一个元素,称为基准(pivot)。

·        重新排序列表,把所有数值小于枢轴的元素排到基准之前,所有数值大于基准的排基准之后(相等的值可以有较多的选择)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。

·        分别递归排序较大元素的子列表和较小的元素的子列表。

递归的结束条件是列表元素为零或一个,即已不需要排序。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

public IList QuickSort(IList a, int left, int right)

{

    int i = left;

    int j = right;

    double pivotValue = ((left + right) / 2);

    int x = (int)a[int.Parse(pivotValue.ToString())];

 

    while (i <= j)

    {

        while (((IComparable)a[i]).CompareTo(x) < 0)

        {

            i++;

        }

        while (((IComparable)x).CompareTo(a[j]) < 0)

        {

            j--;

        }

        if (i <= j)

        {

            object temp = a[i];

            a[i] = a[j];

            //RedrawItem(i);

            i++;

            a[j] = temp;

            //RedrawItem(j);

            j--;

            //pnlSamples.Refresh();

           // if (chkCreateAnimation.Checked)

           //     SavePicture();

        }

    }

    if (left < j)

    {

        QuickSort(a, left, j);

    }

    if (i < right)

    {

        QuickSort(a, i, right);

    }

    return a;

}

Worst case performance:

O(n2)

 

Best case performance:

O(n log n)

 

Average case performance:

O(n log n)

 

Worst case space complexity:

O(log n)

 


快速排序的时间复杂度在最坏情况下是O(N2),平均的时间复杂度是O(N*lgN)


阅读更多
换一批

没有更多推荐了,返回首页