用java api进行sort

最新推荐文章于 2024-06-17 10:04:16 发布

牛十二

最新推荐文章于 2024-06-17 10:04:16 发布

阅读量3.8k

点赞数

分类专栏： java基础文章标签： java api list 算法 permutation pivot

本文链接：https://blog.csdn.net/s_ongfei/article/details/3125477

版权

java基础专栏收录该内容

26 篇文章 0 订阅

订阅专栏

本节中所描述的多态算法（polymorphic algorithms）是由 JDK 所提供的可重复使用的功能性片段。它们均取自Collections类，并都采用静态方法（它的第一个参数是执行操作的对象集）的形式。由Java平台所提供的绝大多数算法都操作于List对象，但有两个 (min 和 max) 操作于任意Collection对象。以下是关于算法的描述
　　
　　　　排序（Sorting）
　　
　　　　排序算法可为一个 List 重新排序，以使它的元素按照某种排序关系成上升式排序。有两种形式的操作被提供。简单形式的操作只采用一个 List 并按照它的元素的自然排序进行排序。如果你对自然排序的概念不熟悉，那么应该重新阅读对象排序（Object Ordering）.
　　
　　　　sort 操作使用做了些优化的合并排序（merge sort）算法。如果你不知道它的含义，而又很看重它的话，请阅读关于算法的任意一种教科书。这个算法的重要之处是：
　　
　　快速: 这个算法被保证运行在 n log(n) 时间内，并在已基本排序的列表上，它的速度实质上更快。经验表明，它的速度与高度优化的快速排序（quicksort）的速度差不多， Quicksort 一般被认为快于合并排序，但它不稳定，并不保证 n log(n)性能。中国网管论坛bbs.bitsCN.com
　　
　　　　稳定: 这就是说，它不为相等的元素重新排序。如果你为相同的列表做不同属性的重复排序，这一点对你来说是十分重要的。如果一个邮件程序的用户为它的邮件箱按日期排序，然后又按发件人排序，这个用户自然地期望某个特定发件人的现在相邻的消息列表将（仍然）按日期排序。这一点只有在第二个排序是稳定的时候才能得以保证。
　　
　　　　以下是一个小程序，它可按词典（字母）顺序打印它的参数：
　　
　　import java.util.*;
　　
　　public class Sort {
　　
　　public static void main(String args[]) {
　　
　　List l = Arrays.asList(args);
　　
　　Collections.sort(l);
　　
　　System.out.println(l);
　　
　　}
　　
　　}
　　
　　　　让我们运行这个程序：
　　
　　% java Sort i walk the line
　　
　　[i, line, the, walk]
　　
　　　　演示这个程序只是为了表示我是毫无保留的：这个算法确实是象它们所显现的那样简单。我不想低估你的能力而演示更傻的例子。
　　
　　　　第二种形式的 sort除采用一个 List 外，还采用一个 Comparator 并且使用 Comparator 对元素进行排序。还记得在 Map 课程结束时的排列组的例子吗? 它以一个非特定的顺序打印出排列组。假设你要以相反的大小顺序打印它们，大的排列在前面。下列例子将告诉你如何借助 sort 方法的第二种形式而达到你的目的。中国网管联盟bitsCN.com
　　
　　回想一下，排序表是以 List 对象的形式作为一个 Map 中的值而被存储的。修改后的打印代码通过 Map 的 values视图进行迭代, 将每一个通过最小尺寸测试的List放进List 之中。然后，代码使用一个期望 List 对象的 Comparator 为这个 List 排序，并实现反转大小排序。最终，代码通过现在已排序的 List 进行迭代，打印它的元素（排序组）。这个代码在 Perm 的 main 方法末尾替代了打印代码:
　　
　　// Make a List of all permutation groups above size threshold
　　
　　List winners = new ArrayList();
　　
　　for (Iterator i = m.values().iterator(); i.hasNext(); ) {
　　
　　List l = (List) i.next();
　　
　　if (l.size() = minGroupSize)
　　
　　winners.add(l);
　　
　　}
　　
　　// Sort permutation groups according to size
　　
　　Collections.sort(winners, new Comparator() {//需导入java.util.Comparator接口
　　
　　public int compare(Object o1, Object o2) {
　　
　　return ((List)o2).size() - ((List)o1).size();
　　
　　}
　　
　　});
　　
　　// Print permutation groups
　　
网管u家u.bitscn@com

　　for (Iterator i=winners.iterator(); i.hasNext(); ) {
　　
　　List l = (List) i.next();
　　
　　System.out.println(l.size() + ": " + l);
　　
　　}
　　
　　　　用与 Map 课程中使用的相同的词典运行这个程序，并使用相同的最小排序组尺寸（8），会产生下列输出:
　　
　　% java Perm dictionary.txt 8
　　
　　12: [apers, apres, asper, pares, parse, pears, prase, presa, rapes,
　　
　　reaps, spare, spear]
　　
　　11: [alerts, alters, artels, estral, laster, ratels, salter, slater,
　　
　　staler, stelar, talers]
　　
　　10: [least, setal, slate, stale, steal, stela, taels, tales, teals,
　　
　　tesla]
　　
　　9: [estrin, inerts, insert, inters, niters, nitres, sinter, triens,
　　
　　trines]
　　
　　9: [capers, crapes, escarp, pacers, parsec, recaps, scrape, secpar,
　　
　　spacer]
　　
　　9: [anestri, antsier, nastier, ratines, retains, retinas, retsina,
　　
　　stainer, stearin]
　　
　　9: [palest, palets, pastel, petals, plates, pleats, septal, staple, 网管网www_bitscn_com
　　
　　tepals]
　　
　　8: [carets, cartes, caster, caters, crates, reacts, recast, traces]
　　
　　8: [ates, east, eats, etas, sate, seat, seta, teas]
　　
　　8: [arles, earls, lares, laser, lears, rales, reals, seral]
　　
　　8: [lapse, leaps, pales, peals, pleas, salep, sepal, spale]
　　
　　8: [aspers, parses, passer, prases, repass, spares, sparse, spears]
　　
　　8: [earings, erasing, gainers, reagins, regains, reginas, searing,
　　
　　seringa]
　　
　　8: [enters, nester, renest, rentes, resent, tenser, ternes, treens]
　　
　　8: [peris, piers, pries, prise, ripes, speir, spier, spire]
　　
　　上一页 1 2 3 下一页
　　
　　a
　　
　　混排（Shuffling）
　　
　　　　混排算法所做的正好与 sort 相反: 它打乱在一个 List 中可能有的任何排列的踪迹。也就是说，基于随机源的输入重排该 List, 这样的排列具有相同的可能性（假设随机源是公正的）。这个算法在实现一个碰运气的游戏中是非常有用的。例如，它可被用来混排代表一副牌的 Card 对象的一个 List 。另外，在生成测试案例时，它也是十分有用的。网管论坛bbs_bitsCN_com
　　
　　　　这个操作有两种形式。第一种只采用一个 List 并使用默认随机源。第二种要求调用者提供一个 Random 对象作为随机源。这个算法的一些实际代码曾在 List 课程中被作为例子使用。
　　
　　　　常规数据操作（Routine Data Manipulation）
　　
　　　　Collections 类为在 List 对象上的常规数据操作提供了三种算法。这些算法是十分简单明了的:
　　
　　　　reverse: 反转在一个列表中的元素的顺序。
　　
　　　　fill: 用特定值覆盖在一个 List 中的每一个元素。这个操作对初始化一个 List 是十分有用的。
　　
　　　　copy: 用两个参数，一个目标 List 和一个源 List, 将源的元素拷贝到目标，并覆盖它的内容。目标 List 至少与源一样长。如果它更长，则在目标 List 中的剩余元素不受影响。
　　
　　　　搜索（Searching）
　　
　　　　binary search （二进制搜索）算法用二进制搜索算法在一个已排序的 List 中寻找特定元素。这个算法有两种形式。第一种采用一个 List 和一个要寻找的元素 ( "搜索键（search key）")。这种形式假设 List 是按照它的元素的自然排序排列成上升顺序的。第二种形式除采用 List 外，还采用一个 Comparator 以及搜索键，并假设 List 是按照特定 Comparator 排列成上升顺序的。排序算法(描述见上) 可优先于 binarySearch 而被用来为List 排序。网管u家u.bitscn@com
　　
　　　　两种形式的返回值是相同的: 如果 List 包含搜索键，它的索引将被返回；如果不包括，则返回值为 (-(insertion point) - 1), 这里的 insertion point 被定义为一个点，从这个点该值将被插入到这个 List 中：大于该值的第一个元素的位置索引，或list.size()。选用这个不可否认的难看的公式是为了保证如果且仅如果搜索键被发现，则返回值将等于0。它基本上是一个将布尔逻辑 ("found") 和整数 ("index") 综合到单一的int返回值的大杂烩。
　　
　　　　下列惯用程序对 binarySearch 操作的两种形式均适用，它寻找特定搜索键，如果搜索键不出现，则将它插入到适当的位置:
　　
　　int pos = Collections.binarySearch(l, key);
　　
　　if (pos < 0)
　　
　　l.add(-pos-1, key);
　　
　　　　寻找极值（Finding Extreme Values）
　　
　　　　min 和 max 算法分别返回包含在特定 Collection 中的最小和最大元素。这两个操作都各有两种形式，简单形式只采用一个 Collection, 并按照元素的自然排序返回最小 (或最大) 元素；另一种形式除采用 Collection 之外，还采用一个 Comparator，并按照特定 Comparator返回最小（或最大）元素。
　　
网管论坛bbs_bitsCN_com

　　　　这些就是由Java 平台提供的作用于与 List 对象相对的任意 Collection 对象上的仅有算法，就象上面提到的 fill 算法一样，这些算法都是非常简单明了的，它们是Java平台为程序员特别提供的便利工具。
【转自www.bitsCN.com】

java的各种排序方法..

论坛里询问排序的太多了..所以发一个上来.1个月后散分,希望能顶起来让大家看到,不完善的请补充.

这是我们同学整理的笔记,经他允许发到网上,都是他在书或网上摘抄的,希望对大家有帮助

用Java语言实现的各种排序，包括插入排序、冒泡排序、选择排序、Shell排序、快速排序、归并排序、堆排序、SortUtil等。

插入排序：

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;
/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class InsertSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for(int i=1;i<data.length;i++){
            for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
                SortUtil.swap(data,j,j-1);
            }
        }
    }

}
冒泡排序：

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class BubbleSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for(int i=0;i<data.length;i++){
            for(int j=data.length-1;j>i;j--){
                if(data[j]<data[j-1]){
                    SortUtil.swap(data,j,j-1);
                }
            }
        }
    }

}

快速排序：

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class QuickSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        quickSort(data,0,data.length-1);
    }
    private void quickSort(int[] data,int i,int j){
        int pivotIndex=(i+j)/2;
        //swap
        SortUtil.swap(data,pivotIndex,j);

        int k=partition(data,i-1,j,data[j]);
        SortUtil.swap(data,k,j);
        if((k-i)>1) quickSort(data,i,k-1);
        if((j-k)>1) quickSort(data,k+1,j);

    }
    /**
     * @param data
     * @param i
     * @param j
     * @return
     */
    private int partition(int[] data, int l, int r,int pivot) {
        do{
           while(data[++l]<pivot);
           while((r!=0)&&data[--r]>pivot);
           SortUtil.swap(data,l,r);
        }
        while(l<r);
        SortUtil.swap(data,l,r);
        return l;
    }

}
改进后的快速排序：

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class ImprovedQuickSort implements SortUtil.Sort {

    private static int MAX_STACK_SIZE=4096;
    private static int THRESHOLD=10;
    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] stack=new int[MAX_STACK_SIZE];

        int top=-1;
        int pivot;
        int pivotIndex,l,r;

        stack[++top]=0;
        stack[++top]=data.length-1;

        while(top>0){
            int j=stack[top--];
            int i=stack[top--];

            pivotIndex=(i+j)/2;
            pivot=data[pivotIndex];

            SortUtil.swap(data,pivotIndex,j);

            //partition
            l=i-1;
            r=j;
            do{
                while(data[++l]<pivot);
                while((r!=0)&&(data[--r]>pivot));
                SortUtil.swap(data,l,r);
            }
            while(l<r);
            SortUtil.swap(data,l,r);
            SortUtil.swap(data,l,j);

            if((l-i)>THRESHOLD){
                stack[++top]=i;
                stack[++top]=l-1;
            }
            if((j-l)>THRESHOLD){
                stack[++top]=l+1;
                stack[++top]=j;
            }

        }
        //new InsertSort().sort(data);
        insertSort(data);
    }
    /**
     * @param data
     */
    private void insertSort(int[] data) {
        int temp;
        for(int i=1;i<data.length;i++){
            for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
                SortUtil.swap(data,j,j-1);
            }
        }
    }

}

【journeydj】:
归并排序：

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class MergeSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] temp=new int[data.length];
        mergeSort(data,temp,0,data.length-1);
    }

    private void mergeSort(int[] data,int[] temp,int l,int r){
        int mid=(l+r)/2;
        if(l==r) return ;
        mergeSort(data,temp,l,mid);
        mergeSort(data,temp,mid+1,r);
        for(int i=l;i<=r;i++){
            temp[i]=data[i];
        }
        int i1=l;
        int i2=mid+1;
        for(int cur=l;cur<=r;cur++){
            if(i1==mid+1)
                data[cur]=temp[i2++];
            else if(i2>r)
                data[cur]=temp[i1++];
            else if(temp[i1]<temp[i2])
                data[cur]=temp[i1++];
            else
                data[cur]=temp[i2++];
        }
    }

}
改进后的归并排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class ImprovedMergeSort implements SortUtil.Sort {

    private static final int THRESHOLD = 10;

    /*
     * (non-Javadoc)
     *
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] temp=new int[data.length];
        mergeSort(data,temp,0,data.length-1);
    }

    private void mergeSort(int[] data, int[] temp, int l, int r) {
        int i, j, k;
        int mid = (l + r) / 2;
        if (l == r)
            return;
        if ((mid - l) >= THRESHOLD)
            mergeSort(data, temp, l, mid);
        else
            insertSort(data, l, mid - l + 1);
        if ((r - mid) > THRESHOLD)
            mergeSort(data, temp, mid + 1, r);
        else
            insertSort(data, mid + 1, r - mid);

        for (i = l; i <= mid; i++) {
            temp[i] = data[i];
        }
        for (j = 1; j <= r - mid; j++) {
            temp[r - j + 1] = data[j + mid];
        }
        int a = temp[l];
        int b = temp[r];
        for (i = l, j = r, k = l; k <= r; k++) {
            if (a < b) {
                data[k] = temp[i++];
                a = temp[i];
            } else {
                data[k] = temp[j--];
                b = temp[j];
            }
        }
    }

    /**
     * @param data
     * @param l
     * @param i
     */
    private void insertSort(int[] data, int start, int len) {
        for(int i=start+1;i<start+len;i++){
            for(int j=i;(j>start) && data[j]<data[j-1];j--){
                SortUtil.swap(data,j,j-1);
            }
        }
    }

【journeydj】:
堆排序：

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
* @author treeroot
* @since 2006-2-2
* @version 1.0
*/
public class HeapSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        MaxHeap h=new MaxHeap();
        h.init(data);
        for(int i=0;i<data.length;i++)
            h.remove();
        System.arraycopy(h.queue,1,data,0,data.length);
    }

     private static class MaxHeap{

        void init(int[] data){
            this.queue=new int[data.length+1];
            for(int i=0;i<data.length;i++){
                queue[++size]=data[i];
                fixUp(size);
            }
        }

        private int size=0;

        private int[] queue;

        public int get() {
            return queue[1];
        }

        public void remove() {
            SortUtil.swap(queue,1,size--);
            fixDown(1);
        }
        //fixdown
        private void fixDown(int k) {
            int j;
            while ((j = k << 1) <= size) {
                if (j < size && queue[j]<queue[j+1])
                    j++;
                if (queue[k]>queue[j]) //不用交换
                    break;
                SortUtil.swap(queue,j,k);
                k = j;
            }
        }
        private void fixUp(int k) {
            while (k > 1) {
                int j = k >> 1;
                if (queue[j]>queue[k])
                    break;
                SortUtil.swap(queue,j,k);
                k = j;
            }
        }

    }