Chinaunix首页 | 论坛 | 博客
  • 博客访问: 700766
  • 博文数量: 112
  • 博客积分: 2486
  • 博客等级: 大尉
  • 技术积分: 1541
  • 用 户 组: 普通用户
  • 注册时间: 2009-12-14 18:30
文章分类

全部博文(112)

文章存档

2012年(5)

2011年(48)

2010年(26)

2009年(33)

我的朋友

分类: Java

2011-11-22 12:23:10

按平均时间将排序分为四类:

(1)平方阶(O(n2))排序
     一般称为简单排序,例如直接插入、直接选择和冒泡排序;

(2)线性对数阶(O(nlgn))排序

     如快速、堆和归并排序;

(3)O(n1+£)阶排序

     £是介于0和1之间的常数,即0<£<1,如希尔排序;

(4)线性阶(O(n))排序

     如桶、箱和基数排序。

各种排序方法比较

     简单排序中直接插入最好,快速排序最快,当文件为正序时,直接插入和冒泡均最佳。

影响排序效果的因素

     因为不同的排序方法适应不同的应用环境和要求,所以选择合适的排序方法应综合考虑下列因素:
  ①待排序的记录数目n;
  ②记录的大小(规模);
  ③关键字的结构及其初始状态;
  ④对稳定性的要求;
  ⑤语言工具的条件;
  ⑥存储结构;
  ⑦时间和辅助空间复杂度等。

不同条件下,排序方法的选择

(1)若n较小(如n≤50),可采用直接插入或直接选择排序。
     当记录规模较小时,直接插入排序较好;否则因为直接选择移动的记录数少于直接插人,应选直接选择排序为宜。
(2)若文件初始状态基本有序(指正序),则应选用直接插人、冒泡或随机的快速排序为宜;
(3)若n较大,则应采用时间复杂度为O(nlgn)的排序方法:快速排序、堆排序或归并排序。
     快速排序是目前基于比较的内部排序中被认为是最好的方法,当待排序的关键字是随机分布时,快速排序的平均时间最短;
     堆排序所需的辅助空间少于快速排序,并且不会出现快速排序可能出现的最坏情况。这两种排序都是不稳定的。
     若要求排序稳定,则可选用归并排序。但本章介绍的从单个记录起进行两两归并的  排序算法并不值得提倡,通常可以将它和直接插入排序结合在一起使用。先利用直接插入排序求得较长的有序子文件,然后再两两归并之。因为直接插入排序是稳定的,所以改进后的归并排序仍是稳定的。

import java.lang.Math;
import java.util.Random;

/**
 * 排序
 *
 * @author javajack  
 */
public class OrderTest {

    public static void main(String args[]) {
        OrderTest.ExecOrder(2);
    }

    /**
     * 交换值,交换数组的两个值
     * @param array
     * @param i
     * @param j
     */
    private static void swap(int[] array,int i, int j)
    {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }    
    
    /**
     *
     * @param method
     *            1为升序,2为降序
     */
    public static void ExecOrder(int method) {
        int[] array = null;
        array = initArray(10, 210, 10);
        
         //int[] orderarray = bubbleOrder(array,method);
        int[] orderarray = doubleBubbleOrder(array,method);
        //int[] orderarray = insertOrder(array, method);
        //int [] orderarray = quickOrder(array,method);
        //int[] orderarray = selectOrder(array, method);
        for (int i = 0; i < orderarray.length; i++) {
            System.out.println(orderarray[i]);
        }
    }

    /**
     * 取随机数据,初始化一个数组
     *
     * @param min
     *            随机数的最小值
     * @param max
     *            最大值
     * @param size
     *            取得随机数的数量
     * @return
     */
    public static int[] initArray(int min, int max, int size) {
        int[] init = new int[size];

        for (int i = 0; i < size; i++) {
            Random ra = new Random();
            init[i] = min + (int) (Math.random() * (max - min + 1));
            System.out.println(i + "-------" + init[i]);
        }
        return init;
    }

    /**
     * 交换排序方法
     * 原理:依次交换值
     * @param array
     * @return
     */
    public static int[] convertOrder(int[] array, int method) {
        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++)
            {
                if (method==2)
                {
                    if (array[i] < array[j])
                        swap(array,i,j);
                }else if (method == 1) {
                    if (array[i] > array[j])
                        swap(array,i,j);
                }
            }
        }
        return array;
    }

    /**冒泡排序方法
     * 原理:从最后一个开始将小的或大的逐渐冒出
     * @param array
     * @param method
     * @return
     */
    public static int[] bubbleOrder(int[] array,int method)
    {
        for(int i=0;i        {
            for (int j=array.length -1 ;j>i;j--)
            {
                if (method==2)
                {
                    if (array[i] < array[j])
                        swap(array,i,j);
                }else if (method==1)
                    if (array[i] > array[j])
                        swap(array,i,j);
            }
        }
        return array;
    }
    
    /**
     * 双向冒泡排序
     * 原理:类似于冒泡排序,只不过是双向的
     * @param array
     * @param method
     * @return
     */
    public static int[] doubleBubbleOrder(int[] array,int method)
    {
        int left = 0;
        int right = array.length -1 ;
        while (left < right)
        {
            for(int i=left;i<=right;i++)
            {
                if (method==1)
                {
                    if (array[left] > array[i])
                        swap(array,left,i);
                }else
                {
                    if (array[left] < array[i])
                        swap(array,left,i);
                }
            }
            
            for (int i=left+1;i<=right;i++)
            {
                if (method==1)
                {
                    if (array[right] < array[i])
                        swap(array,right,i);
                }else
                {
                    if (array[right] > array[i])
                        swap(array,right,i);
                    
                }
            }
            left++;
            right--;
        }
        return array;
    }
    
    /**
     * 快速排序方法,运用到递归
     * 排序原理:随机找到一个值,然后以此值大小进行分为两个数组,大的放左边,小的放右边,
     * 然后再对左右两侧的数据依次排序根据
     * @param array
     * @param method
     * @return
     */
    public static int[] quickOrder(int[] array, int method)
    {
        quickDeal(array,0,array.length - 1,method);
        return array;
    }

    /**
     *
     * @param array
     * @param begin
     *            开始位置
     * @param end
     *            结束位置
     */
    private static void quickDeal(int[] array, int begin, int end,int method) {
        if (end > begin) {
            int pos = begin + (int) (Math.random() * (end - begin + 1)); // 计算分隔位置
            int posvalue = array[pos]; // 取得分隔位置的值
            swap(array,pos,end); //将posvalue放到最end的位置
            pos=begin; //初始化pos
            for (int i=begin; i < end; i++) {
                if (method==1)
                {    
                    if (array[i] < posvalue) { //当小于posvalue时,将此值移动到pos位置,也就是向前移动
                        swap(array,pos,i);
                        pos++; //移动后pos增1
                    }
                }else if(method == 2)
                {
                    if (array[i] > posvalue) { //当小于posvalue时,将此值移动到pos位置,也就是向前移动
                        swap(array,pos,i);
                        pos++; //移动后pos增1
                    }
                }
            }
            swap(array,pos,end); //end位置的值前移
            quickDeal(array,begin,pos -1,method);
            quickDeal(array,pos+1,end,method);
        }

    }

    /**
     * 插入排序方法
     * 排序原理:抽出一个数,做为排序基序列,然后依次抽出其它数与,与此序列中的数进行比较,放入合适的位置
     * @param array
     * @param method
     * @return
     */
    public static int[] insertOrder(int[] array, int method) {

        for (int i = 1; i < array.length; i++) {
            if (method == 1) {
                if (array[i - 1] > array[i]) {
                    int tmp = array[i]; //
                    int j = i - 1;
                    do {
                        array[j + 1] = array[j];
                        j--;
                    } while (j >= 0 && tmp < array[j]); //当j>=0并且 当前值大于数据中j位置的值时移动
                    array[j + 1] = tmp; //插入排序值
                }
            } else if (method == 2) {
                if (array[i - 1] < array[i]) {
                    int tmp = array[i];
                    int j = i - 1;
                    do {
                        array[j + 1] = array[j];
                        j--;
                    } while (j >= 0 && tmp > array[j]);
                    array[j + 1] = tmp;
                }
            }
        }
        return array;
    }

    /**
     * 选择排序方法
     * 排序原理:每次选择一个最大的或最小的数放到已排序序列中
     * @param array
     * @param method
     * @return
     */
    public static int[] selectOrder(int[] array,int method)
    {
        for (int i=0;i        {
            int tmp = array[i];
            int pos = i+1; //记录大值或小值的位置 
            for (int j=i+1;j            {
                if (method==1)
                {
                    if (array[j]                    {
                        tmp = array[j];
                        pos= j ;//记录大值或小值的位置
                    }
                }else if (method==2)
                {
                    if (array[j]>tmp)
                    {
                        tmp = array[j];
                        pos= j ;//记录大值或小值的位置
                    }
                }
            }
            if (tmp != array[i])
                swap(array,i,pos); //不相同时交换
        }
        return array;
    }

    
}

阅读(1763) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~