关闭

排序算法的分析及java实现

标签: 排序算法
313人阅读 评论(0) 收藏 举报
分类:

排序大的分类可以分为两种:内排序和外排序。在排序过程中,全部记录存放在内存,则称为内排序,如果排序过程中需要使用外存,则称为外排序。下面讲的排序都是属于内排序。

  内排序有可以分为以下几类:

  (1)、插入排序:直接插入排序、二分法插入排序、希尔排序。

  (2)、选择排序:简单选择排序、堆排序。

  (3)、交换排序:冒泡排序、快速排序。

  (4)、归并排序

  (5)、基数排序

一、插入排序
•思想:每步将一个待排序的记录,按其顺序码大小插入到前面已经排序的字序列的合适位置,直到全部插入排序完为止。
•关键问题:在前面已经排好序的序列中找到合适的插入位置。
•方法:
–直接插入排序
–二分插入排序
–希尔排序

①直接插入排序(从后向前找到合适位置后插入)

  1、基本思想:每步将一个待排序的记录,按其顺序码大小插入到前面已经排序的字序列的合适位置(从后向前找到合适位置后),直到全部插入排序完为止。

  2、实例
这里写图片描述
  

  3、java实现
  

/**
 * 插入排序
 * @author XGL
 *
 */
public class insert_sort {

    public static void main(String[] args) {
         int[] a={49,38,65,97,76,13,27,49,78,34,12,64,1};
            System.out.println("排序之前:");
            for (int i = 0; i < a.length; i++) {
                System.out.print(a[i]+" ");
            }
            insertSort(a);
            System.out.println();
            System.out.println("排序之后:");
            for (int i = 0; i < a.length; i++) {
                System.out.print(a[i]+" ");
            }
    }

    private static void insertSort(int a[]){
        //直接插入排序
        for (int i = 1; i < a.length; i++) {
            //待插入元素
            int temp = a[i];
            int j=0;
            for (j = i-1; j>=0 && a[j]>temp; j--) {
                //将大于temp的往后移动一位
                a[j+1] = a[j];
            }
            a[j+1]=temp;
        }
    }

}

4、分析

  直接插入排序是稳定的排序。关于各种算法的稳定性分析可以参考http://www.cnblogs.com/Braveliu/archive/2013/01/15/2861201.html

  文件初态不同时,直接插入排序所耗费的时间有很大差异。若文件初态为正序,则每个待插入的记录只需要比较一次就能够找到合适的位置插入,故算法的时间复杂度为O(n),这时最好的情况。若初态为反序,则第i个待插入记录需要比较i+1次才能找到合适位置插入,故时间复杂度为O(n2),这时最坏的情况。

  直接插入排序的平均时间复杂度为O(n2)。
  
 ②二分法插入排序(按二分法找到合适位置插入)

  1、基本思想:二分法插入排序的思想和直接插入一样,只是找合适的插入位置的方式不同,这里是按二分法找到合适的位置,可以减少比较的次数。

  2、实例

3、java实现

/**
 * 二分法排序 在插入第i个元素时,对前面的0~i-1元素进行折半,先跟他们 中间的那个元素比,如果小,则对前半再进行折半,否则对后半
 * 进行折半,直到left>right,然后再把第i个元素前1位与目标位置之间 的所有元素后移,再把第i个元素放在目标位置上。
 * 
 * @author XGL
 * 
 */
public class dichotomy_sort {

    public static void DichotomySort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int start = 0,end = i-1,mid=0;
            int temp = array[i];
            while (start <= end) {
                mid = (start + end) / 2;
                if (array[mid] > temp)// 要排序元素在已经排过序的数组左边
                {
                    end = mid - 1;
                } else {
                    start = mid + 1;
                }
            }
            for (int j = i - 1; j > end; j--)// 找到了要插入的位置,然后将这个位置以后的所有元素向后移动

            {
                array[j + 1] = array[j];
            }
            array[end + 1] = temp;

        }
    }

    public static void main(String[] args) {
        int a[] = { 49, 38, 34, 12, 64, 55 };
        System.out.println("排序之前:");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        DichotomySort(a);
        System.out.println();
        System.out.println("排序之后:");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

}

4、分析

  当然,二分法插入排序也是稳定的。

  二分插入排序的比较次数与待排序记录的初始状态无关,仅依赖于记录的个数。当n较大时,比直接插入排序的最大比较次数少得多。但大于直接插入排序的最小比较次数。算法的移动次数与直接插入排序算法的相同,最坏的情况为n2/2,最好的情况为n,平均移动次数为O(n2)。
  
二、选择排序
•思想:每趟从待排序的记录序列中选择关键字最小的记录放置到已排序表的最前位置,直到全部排完。
•关键问题:在剩余的待排序记录序列中找到最小关键码记录。
•方法:
–直接选择排序
–堆排序

①简单的选择排序
  1、基本思想:在要排序的一组数中,选出最小的一个数与第一个位置的数交换;然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环到倒数第二个数和最后一个数比较为止。
  
  2、实例
  这里写图片描述
3、java实现

/**
 * 选择排序
 * 
 * @author XGL
 * 
 */
public class select_sort {

    public static void main(String[] args) {
        int[] a = { 49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 1, 8 };
        System.out.println("排序之前:");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        // 简单的选择排序
        for (int i = 0; i < a.length; i++) {
            int min = a[i];
            int n = i; // 最小数的索引
            for (int j = i + 1; j < a.length; j++) {
                if (a[j] < min) { // 找出最小的数
                    min = a[j];
                    n = j;
                }
            }
            a[n] = a[i];
            a[i] = min;

        }
        System.out.println();
        System.out.println("排序之后:");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
}

 4、分析

  简单选择排序是不稳定的排序。

  时间复杂度:T(n)=O(n2)。
  
三、交换排序

①冒泡排序

  1、基本思想:在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。

  2、实例
  
  这里写图片描述
3、java实现

/**
 * 冒泡排序
 * 
 * @author XGL
 * 
 */
public class bubbling_sort {

    public static void bubbleSort() {
        int a[] = { 49, 38, 13, 65, 97, 76,  27, 49, 78, 34, 12, 64};
        int temp = 0;
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
                for (int k = 0; k < a.length; k++){
                    System.out.print(a[k]+"/");
                }
                System.out.println("\n");
            }
        }
        System.out.println(a.length);
    }

    public static void main(String[] args) {
        bubbleSort();
    }
}

4、分析

  冒泡排序是一种稳定的排序方法。 
•若文件初状为正序,则一趟起泡就可完成排序,排序码的比较次数为n-1,且没有记录移动,时间复杂度是O(n)
•若文件初态为逆序,则需要n-1趟起泡,每趟进行n-i次排序码的比较,且每次比较都移动三次,比较和移动次数均达到最大值∶O(n2)
•起泡排序平均时间复杂度为O(n2)
②快速排序
  1、基本思想:选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描,将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
  
  2、实例
这里写图片描述
  3、java实现
  

/**
 * 快速排序
 * @author XGL
 *
 */
public class quick_sort {

    public static int getMiddle(int a[],int low ,int high){
        //将数组第一个设为基准,将比基准大的放到数组右边,小的放在左边
        int temp = a[low];
        while(low < high){
            //如果比基准大则往前继续寻找
            while(low < high && a[high] >= temp){
                high --;
            }
            //如果比基准小则交换,移到左端
            a[low] = a[high];
            while(low < high && a[low] <= temp){
                low ++;
            }
            //如果比基准大则交换,移到右端
            a[high]=a[low];
        }

        a[low] = temp;
        return low;                   //返回中轴的位置   

    }

    public static void _quickSort(int[] list, int low, int high) {     

        if (low < high) {     

           int middle = getMiddle(list, low, high);  //将list数组进行一分为二     

            _quickSort(list, 0, middle - 1);        //对低字表进行递归排序     

           _quickSort(list, middle + 1, high);       //对高字表进行递归排序     

        }     

    }   

    public static void main(String[] args) {
        int a[] = { 49, 38, 34, 12, 64,55};

        int low = 0;
        int high = a.length-1;
        _quickSort(a,low,high);

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



}

4、分析

  快速排序是不稳定的排序。

  快速排序的时间复杂度为O(nlogn)。

  当n较大时使用快排比较好,当序列基本有序时用快排反而不好。

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:7387次
    • 积分:305
    • 等级:
    • 排名:千里之外
    • 原创:24篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类