Java实现8中常用的排序

最新推荐文章于 2022-11-16 16:15:23 发布
最新推荐文章于 2022-11-16 16:15:23 发布
阅读量4k 收藏 3
点赞数 2
分类专栏： 大家好 语言随笔 文章标签： java 插入排序 class 排序 冒泡
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pnoter/article/details/51553966
版权

直接插入排序

import java.util.HashMap;  
/** 
 * 直接插入排序 
 * @author HHF 
 * 2014年3月19日 
 */  
public class InsertSort {  
  
    private static int contrastCount = 0;//对比次数  
    private static int swapCount = 0;//交换次数  
  
    public static void main(String[] args) {  
        System.out.println("直接插入排序：\n  假设前面的序列都已经排序好了，把后面未排序的数往已排好序的序列内插入,时间复杂度O(n^2),空间复杂度O(1)，稳定排序");  
        HashMap<Integer,Integer> hashMap = new HashMap<Integer,Integer>();  
        init(hashMap);//初始化       
        System.out.println("初始序列为：");  
        print(hashMap, 0);//打印    
        insert(hashMap);//排序  
    }  
    /** 
     * 初始化函数 
     * @param hashMap 
     */  
    private static void init(HashMap<Integer, Integer> hashMap) {  
        hashMap.put(0, null);//第一位置空  
        hashMap.put(1, 0);  
        hashMap.put(2, 5);  
        hashMap.put(3, 11);  
        hashMap.put(4, 12);  
        hashMap.put(5, 13);  
        hashMap.put(6, 4);  
        hashMap.put(7, 1);  
        hashMap.put(8, 5);  
        hashMap.put(9, 8);  
        hashMap.put(10, 6);  
        hashMap.put(11, 4);  
        hashMap.put(12, 8);       
    }  
    /** 
     * 进行插入排序 
     * @param hashMap 待排序的表 
     */  
    private static void insert(HashMap<Integer, Integer> hashMap){  
        System.out.println("开始插入排序：");  
        int i,j;  
        //排序开始时间  
        long start = System.currentTimeMillis();      
        for(i=2; i<hashMap.size(); i++){//从第二个开始排序，知道最后一个结束  
            hashMap.put(0, hashMap.get(i));//储存待排序的数，以便前面的书好向后交换位置  
            swapCount++;//发生一次交换  
            j = i-1;//指向有序列  
            while(hashMap.get(0) < hashMap.get(j)){//当发现有比待排序书大的时候 该数后移一位  
                hashMap.put(j+1, hashMap.get(j));  
                j--;//继续向前寻找合适的位置  
                swapCount++;//发生一次交换  
                contrastCount++;//发生一次对比  
            }  
            contrastCount++;//跳出while循环还有一次对比  
            hashMap.put(j+1, hashMap.get(0));//放入合适的位置  
            swapCount++;//发生一次交换  
            /*比如说  我发现从第5号元素开始前面的数都比待排序值小 
                则j=5，且第6号元素位为合适的位置且为空 
                所以有j++ 
            */  
            print(hashMap, i-1);//输出每趟的序列  
        }  
        //排序结束时间  
        long end = System.currentTimeMillis();  
        System.out.println("结果为：");  
        print(hashMap, 0);//输出排序结束的序列  
        hashMap.clear();//清空  
        System.out.print("一共发生了 "+contrastCount+" 次对比\t");  
        System.out.print("一共发生了 "+swapCount+" 次交换\t");  
        System.out.println("执行时间为"+(end-start)+"毫秒");  
    }  
    /** 
     * 打印已排序好的元素 
     * @param hashMap 已排序的表 
     * @param j 第j趟排序 
     */  
    private static void print(HashMap<Integer, Integer> hashMap, int j){  
        if(j != 0)  
            System.out.print("第 "+j+" 趟：\t");  
        for(int i=1; i<hashMap.size(); i++){//从第一个一直输出到最后一个  
            System.out.print(hashMap.get(i)+"\t");  
        }  
        System.out.println();  
    }  
}

希尔排序

import java.util.HashMap;  
/** 
 * 希尔排序 
 * @author HHF 
 * 2014年3月19日 
 */  
public class HillSort {  
  
    private static int contrastCount = 0;//对比次数  
    private static int swapCount = 0;//交换次数  
  
    public static void main(String[] args) {  
        System.out.println("希尔排序：\n  分间隔的直接插入排序，假定一个增量d，把全部n个记录分成d组，各组内直接插入排序；再取d1<d，重复分组排序，直到d=1,时间复杂度O(n^1.3),空间复杂度O(1)，不稳定排序");         
        HashMap<Integer,Integer> hashMap = new HashMap<Integer,Integer>();  
        init(hashMap);//初始化       
        System.out.println("初始序列为：");  
        print(hashMap, 0, 0);//打印  
        hill(hashMap);//排序  
    }  
    /** 
     * 初始化函数 
     * @param hashMap 
     */  
    private static void init(HashMap<Integer, Integer> hashMap) {  
        hashMap.put(0, null);//第一位置空  
        hashMap.put(1, 10);  
        hashMap.put(2, 5);  
        hashMap.put(3, 11);  
        hashMap.put(4, 12);  
        hashMap.put(5, 13);  
        hashMap.put(6, 4);  
        hashMap.put(7, 1);  
        hashMap.put(8, 5);  
        hashMap.put(9, 8);  
        hashMap.put(10, 6);  
        hashMap.put(11, 4);  
        hashMap.put(12, 8);       
    }  
    /** 
     * 进行希尔排序 
     * @param hashMap 待排序的表 
     */  
    private static void hill(HashMap<Integer, Integer> hashMap){  
        System.out.println("开始希尔排序：");  
          
        //排序开始时间  
        long start = System.currentTimeMillis();  
          
        int d = hashMap.size()-1;//初始化增量d  
        int count = 1;//只为统计执行次数  
        while(true){  
            d = d / 2;//增量每次对半减  
            for(int x=1;x<=d;x++){//一共有d组 x表示每一组的一个数的下表  
                for(int i=x+d; i<hashMap.size(); i=i+d){//开始直接插入排序 每组内的数下标间隔d i表示这一组数的下标  
                    hashMap.put(0, hashMap.get(i));//当前被待排序的书  
                    swapCount++;//发生一次交换  
                    int j = 0;//i之前的同一组数的下标  
                    for(j=i-d; j>=0&&(hashMap.get(j)>hashMap.get(0)); j=j-d){//寻找i的当前合适位置 从i-d开始往前找  
                        //只有当被查下标有效 且 被查值比待排序值大时才应该发生交换  
                        hashMap.put(j+d, hashMap.get(j));  
                        contrastCount++;//发生一次对比  
                        swapCount++;//发生一次交换  
                    }  
                    contrastCount++;//跳出for循环还有一次对比  
                    hashMap.put(j+d, hashMap.get(0));//放入合适的位置  
                    swapCount++;//发生一次交换  
                    //一趟直接插入排序结束  
                }  
            }  
            print(hashMap, count++, d);  
            if(d == 1){  
                break;  
            }  
        }  
          
        //排序结束时间  
        long end = System.currentTimeMillis();  
        System.out.println("结果为：");  
        print(hashMap, 0, 0);//输出排序结束的序列  
        hashMap.clear();//清空  
        System.out.print("一共发生了 "+contrastCount+" 次对比\t");  
        System.out.print("一共发生了 "+swapCount+" 次交换\t");  
        System.out.println("执行时间为"+(end-start)+"毫秒");  
    }  
    /** 
     * 打印已排序好的元素 
     * @param hashMap 已排序的表 
     * @param j 第j趟排序 
     * @param d 当前的增量 
     */  
    private static void print(HashMap<Integer, Integer> hashMap, int j, int d){  
        if(j != 0)  
            System.out.print("第 "+j+" 趟：（d="+d+"）\t");  
        for(int i=1; i<hashMap.size(); i++){//从第一个一直输出到最后一个  
            System.out.print(hashMap.get(i)+"\t");  
        }  
        System.out.println();  
    }  
}

冒泡排序

import java.util.HashMap;  
  
/** 
 * 冒泡排序 
 * @author HHF 
 * 2014年3月19日 
 */  
public class BubbleSort {  
  
    private static int contrastCount = 0;//对比次数  
    private static int swapCount = 0;//交换次数  
  
    public static void main(String[] args) {  
        System.out.println("冒泡排序：\n  第一轮使最大值沉淀到最底下，采用从头开始的两两比较的办法，如果i大于i++则交换，下一次有从第一个开始循环，比较次数减一，然后依次重复即可,"  
                + "\n 如果一次比较为发生任何交换，则可提前终止，时间复杂度O(n^2),空间复杂度O(1)，稳定排序");          
        HashMap<Integer,Integer> hashMap = new HashMap<Integer,Integer>();  
        init(hashMap);//初始化       
        System.out.println("初始序列为：");  
        print(hashMap, 0);//打印  
        bubble(hashMap);//排序  
    }  
    /** 
     * 初始化函数 
     * @param hashMap 
     */  
    private static void init(HashMap<Integer, Integer> hashMap) {  
        hashMap.put(0, null);//第一位置空  
        hashMap.put(1, 10);  
        hashMap.put(2, 5);  
        hashMap.put(3, 11);  
        hashMap.put(4, 12);  
        hashMap.put(5, 13);  
        hashMap.put(6, 4);  
        hashMap.put(7, 1);  
        hashMap.put(8, 5);  
        hashMap.put(9, 8);  
        hashMap.put(10, 6);  
        hashMap.put(11, 4);  
        hashMap.put(12, 8);       
    }  
    /** 
     * 进行冒泡排序 
     * @param hashMap 待排序的表 
     */  
    private static void bubble(HashMap<Integer, Integer> hashMap){  
        System.out.println("开始冒泡排序：");  
          
        //排序开始时间  
        long start = System.currentTimeMillis();  
        boolean swap = false;//是否发生交换  
        int count = 1;//只为了计数  
        for(int i=1; i<hashMap.size(); i++){  
            swap = false;  
            for(int j=1; j<hashMap.size()-i; j++){  
                if(hashMap.get(j)>hashMap.get(j+1)){//需要发生交换j 和 j+1  
                    hashMap.put(0, hashMap.get(j));  
                    hashMap.put(j, hashMap.get(j+1));  
                    hashMap.put(j+1, hashMap.get(0));  
                    swap = true;  
                    contrastCount++;//发生一次对比  
                    swapCount++;//发生一次交换  
                    swapCount++;//发生一次交换  
                    swapCount++;//发生一次交换  
                }  
                contrastCount++;//跳出if还有一次对比  
            }  
            print(hashMap, count++);  
            if(!swap)  
                break;  
        }     
        //排序结束时间  
        long end = System.currentTimeMillis();  
        System.out.println("结果为：");  
        print(hashMap, 0);//输出排序结束的序列  
        hashMap.clear();//清空  
        System.out.print("一共发生了 "+contrastCount+" 次对比\t");  
        System.out.print("一共发生了 "+swapCount+" 次交换\t");  
        System.out.println("执行时间为"+(end-start)+"毫秒");  
    }  
    /** 
     * 打印已排序好的元素 
     * @param hashMap 已排序的表 
     * @param j 第j趟排序 
     */  
    private static void print(HashMap<Integer, Integer> hashMap, int j){  
        if(j != 0)  
            System.out.print("第 "+j+" 趟：\t");  
        for(int i=1; i<hashMap.size(); i++){//从第一个一直输出到最后一个  
            System.out.print(hashMap.get(i)+"\t");  
        }  
        System.out.println();  
    }  
}

快速排序

import java.util.HashMap;  
  
/** 
 * 快速排序 
 * @author HHF 
 * 2014年3月19日 
 */  
public class QuickSort {  
  
    private static int contrastCount = 0;//对比次数  
    private static int swapCount = 0;//交换次数  
  
    public static void main(String[] args) {  
        System.out.println("快速排序：\n  任取一个数作为分界线，比它小的放到左边，比它大的放在其右边，然后分别对左右进行递归,时间复杂度O(nLgn),空间复杂度O(n)，不稳定排序");        
        HashMap<Integer,Integer> hashMap = new HashMap<Integer,Integer>();  
        init(hashMap);//初始化       
        System.out.println("初始序列为：");  
        print(hashMap, 0, 0);//打印  
        System.out.println("开始快速排序：");        
        //排序开始时间  
        long start = System.currentTimeMillis();  
          
        quick(hashMap, 1, hashMap.size()-1);//排序  
          
        //排序结束时间  
        long end = System.currentTimeMillis();  
        System.out.println("结果为：");  
        print(hashMap, 0, 0);//输出排序结束的序列  
        hashMap.clear();//清空  
        System.out.print("一共发生了 "+contrastCount+" 次对比\t");  
        System.out.print("一共发生了 "+swapCount+" 次交换\t");  
        System.out.println("执行时间为"+(end-start)+"毫秒");  
        System.out.println("(注：此输出序列为代码执行过程的序列， 即先左边递归 再 右边递归， 而教科书上的递归序列往往是左右同时进行的结果，特此说明)");  
    }  
    /** 
     * 初始化函数 
     * @param hashMap 
     */  
    private static void init(HashMap<Integer, Integer> hashMap) {  
        hashMap.put(0, null);//第一位置空  
        hashMap.put(1, 10);  
        hashMap.put(2, 5);  
        hashMap.put(3, 11);  
        hashMap.put(4, 12);  
        hashMap.put(5, 13);  
        hashMap.put(6, 4);  
        hashMap.put(7, 1);  
        hashMap.put(8, 5);  
        hashMap.put(9, 8);  
        hashMap.put(10, 6);  
        hashMap.put(11, 4);  
        hashMap.put(12, 8);       
    }  
    /** 
     * 进行快速排序 
     * @param hashMap 待排序的表 
     * @param low 
     * @param high 
     */  
    static int count = 1;  
    private static void quick(HashMap<Integer, Integer> hashMap, int low, int high){  
        if(low<high){//跳出递归的条件  
            int k = quickOnePass(hashMap, low, high);//开始一趟排序  
            print(hashMap, count++, hashMap.get(k));  
            quick(hashMap, low, k-1);//对左边的序列递归排序  
            quick(hashMap, k+1, high);//对右边的序列递归排序  
        }  
    }  
    /** 
     * 进行快速排序 
     * @param hashMap 待排序的表 
     * @param low  
     * @param high 
     */  
    private static int quickOnePass(HashMap<Integer, Integer> hashMap, int low, int high){      
        hashMap.put(0, hashMap.get(low));//选择一个分界值 此时第low位元素内的值已经无所谓被覆盖了  
        swapCount++;//发生一次交换  
        while(low<high){//左右两边还有数据为检查时  
            while(low<high && hashMap.get(0)<hashMap.get(high)){//先开始从右往左走 直到有不对的数据 或者 到头了  
                high--;  
                contrastCount++;//发生一次对比  
            }  
            if(low<high){//如果停下来是因为不对的数据 而不是 到头了  
                hashMap.put(low++, hashMap.get(high));  
                swapCount++;//发生一次交换  
            }  
            while(low<high && hashMap.get(0)>hashMap.get(low)){//开始从左往右走 直到有不对的数据 或者 到头了            
                low++;  
                contrastCount++;//发生一次对比  
            }  
            if(low<high){//如果停下来是因为不对的数据 而不是 到头了  
                hashMap.put(high--, hashMap.get(low));  
                swapCount++;//发生一次交换  
            }  
        }  
        hashMap.put(low, hashMap.get(0));  
        swapCount++;//发生一次交换  
        return low;  
    }  
    /** 
     * 打印已排序好的元素 
     * @param hashMap 已排序的表 
     * @param j 第j趟排序 
     * @param k 第k个元素被选中为分界线 
     */  
    private static void print(HashMap<Integer, Integer> hashMap, int j, int k){  
        if(j != 0)  
            System.out.print("第 "+j+" 趟：(分界线为"+k+")\t");  
        for(int i=1; i<hashMap.size(); i++){//从第一个一直输出到最后一个  
            System.out.print(hashMap.get(i)+"\t");  
        }  
        System.out.println();  
    }  
}

直接选择排序

import java.util.HashMap;  
  
/** 
 * 选择排序 
 * @author HHF 
 * 2014年3月19日 
 */  
public class SelectionSort {  
  
    private static int contrastCount = 0;//对比次数  
    private static int swapCount = 0;//交换次数  
  
    public static void main(String[] args) {  
        System.out.println("选择排序：\n  每次选择最小的，然后与对应的位置处元素交换,时间复杂度O(n^2),空间复杂度O(1)，不稳定排序");         
        HashMap<Integer,Integer> hashMap = new HashMap<Integer,Integer>();  
        init(hashMap);//初始化       
        System.out.println("初始序列为：");  
        print(hashMap, 0, 0);//打印  
        select(hashMap);//排序  
    }  
    /** 
     * 初始化函数 
     * @param hashMap 
     */  
    private static void init(HashMap<Integer, Integer> hashMap) {  
        hashMap.put(0, null);//第一位置空  
        hashMap.put(1, 10);  
        hashMap.put(2, 5);  
        hashMap.put(3, 11);  
        hashMap.put(4, 12);  
        hashMap.put(5, 13);  
        hashMap.put(6, 4);  
        hashMap.put(7, 1);  
        hashMap.put(8, 5);  
        hashMap.put(9, 8);  
        hashMap.put(10, 6);  
        hashMap.put(11, 4);  
        hashMap.put(12, 8);       
    }  
    /** 
     * 进行选择排序 
     * @param hashMap 待排序的表 
     */  
    private static void select(HashMap<Integer, Integer> hashMap){  
        System.out.println("开始选择排序：");        
        //排序开始时间  
        long start = System.currentTimeMillis();  
        int count = 1;//只为统计执行次数  
        for(int i=hashMap.size()-1; i>1; i--){//需要循环查询的次数 最后一个元素不用考虑  
            int k = i;//记录本次查找序列最大值的下标 初始为该数应该要放的位置  
            for(int j=1; j<i; j++){//  
                if(hashMap.get(k)<hashMap.get(j)){  
                    k=j;//记录当前最大的数的下标  
                    contrastCount++;//发生一次对比  
                }  
            }  
            //此时k中保存了i位置应该放的数的下标 于是发生交换  
            if(i != k ){  
                hashMap.put(0, hashMap.get(k));  
                hashMap.put(k, hashMap.get(i));  
                hashMap.put(i, hashMap.get(0));  
                swapCount++;//发生一次交换  
                swapCount++;//发生一次交换  
                swapCount++;//发生一次交换  
            }  
            print(hashMap, count++, i);//输出排序结束的序列  
        }          
        //排序结束时间  
        long end = System.currentTimeMillis();  
        System.out.println("结果为：");  
        print(hashMap, 0, 0);//输出排序结束的序列  
        hashMap.clear();//清空  
        System.out.print("一共发生了 "+contrastCount+" 次对比\t");  
        System.out.print("一共发生了 "+swapCount+" 次交换\t");  
        System.out.println("执行时间为"+(end-start)+"毫秒");  
    }  
    /** 
     * 打印已排序好的元素 
     * @param hashMap 已排序的表 
     * @param j 第j趟排序 
     * @param d 被选到的数 
     */  
    private static void print(HashMap<Integer, Integer> hashMap, int j, int d){  
        if(j != 0)  
            System.out.print("第 "+j+" 趟：\t");  
        for(int i=1; i<hashMap.size(); i++){//从第一个一直输出到最后一个  
            System.out.print(hashMap.get(i)+"\t");  
        }  
        System.out.println();  
    }  
}

堆排序

import java.util.HashMap;  
  
/** 
 * 堆排序——极大堆 
 * @author HHF 
 * 2014年3月19日 
 */  
public class HeapSort {  
  
    private static int contrastCount = 0;//对比次数  
    private static int swapCount = 0;//交换次数  
    private static int printCount = 1;//执行打印次数  
    public static void main(String[] args) {  
        System.out.println("堆排序：\n  首先建立一个堆（方法是首先把序列排成二叉树，然后从下往上，从右往左使得每一个小子树中的父节点大于子节点，然后从上往下，从左往右记录堆入序列）,"  
                + "\n  然后把堆的根节点和最底下 的孩子节点交换，整理堆，再重复交换，整理，时间复杂度O(nlgn),空间复杂度O(1)，不稳定排序");          
        HashMap<Integer,Integer> hashMap = new HashMap<Integer,Integer>();  
        init(hashMap);//初始化       
        System.out.println("初始序列为：");  
        print(hashMap, 0);//打印  
        heap(hashMap);//排序  
    }  
    /** 
     * 初始化函数 
     * @param hashMap 
     */  
    private static void init(HashMap<Integer, Integer> hashMap) {  
        hashMap.put(0, null);//第一位置空  
        hashMap.put(1, 10);  
        hashMap.put(2, 5);  
        hashMap.put(3, 11);  
        hashMap.put(4, 12);  
        hashMap.put(5, 13);  
        hashMap.put(6, 4);  
        hashMap.put(7, 1);  
        hashMap.put(8, 5);  
        hashMap.put(9, 8);  
        hashMap.put(10, 6);  
        hashMap.put(11, 4);  
        hashMap.put(12, 8);       
    }  
    /** 
     * 进行堆排序 
     * @param hashMap 待排序的表 
     */  
    private static void heap(HashMap<Integer, Integer> hashMap){  
        System.out.println("开始建堆：");          
        //排序开始时间87    
        long start = System.currentTimeMillis();  
        for(int i=(hashMap.size()-1)/2; i>=1; i--){//开始建堆  
            sift(hashMap, i, hashMap.size()-1);//把所有的节点调好位置即可以  
        }         
        System.out.println("建堆成功");  
        for(int j=hashMap.size()-1; j>=1; j--){//每次都把第一个元素与最后一个未排序的交换 然后再调整第一个节点即可  
            hashMap.put(0, hashMap.get(1));  
            hashMap.put(1, hashMap.get(j));  
            hashMap.put(j, hashMap.get(0));  
            sift(hashMap, 1, j-1);//剩下要排序的数位为j-1  
            swapCount++;//发生一次交换  
            swapCount++;//发生一次交换  
            swapCount++;//发生一次交换  
        }  
        //排序结束时间  
        long end = System.currentTimeMillis();  
        System.out.println("结果为：");  
        print(hashMap, 0);//输出排序结束的序列  
        hashMap.clear();//清空  
        System.out.print("一共发生了 "+contrastCount+" 次对比\t");  
        System.out.print("一共发生了 "+swapCount+" 次交换\t");  
        System.out.println("执行时间为"+(end-start)+"毫秒");  
    }  
    /** 
     * 把第i位的元素移动到合适位置 与其子孩子的最大值比较 如果有发生交换 则继续往下比较 
     * @param hashMap 
     * @param i 待移动的数下标 
     * @param n 表示要查找的范围 从1到n个 
     */  
    private static void sift(HashMap<Integer, Integer> hashMap, int i, int n){  
        int j = 2*i;//j为i的左孩子  
        hashMap.put(0, hashMap.get(i));//当前被待排序的数  
        while(j<=n){//如果有左孩子的  
            if(hashMap.containsKey(j+1) && hashMap.get(j)<hashMap.get(j+1)){//保证j为最大的孩子  
                j++;  
            }  
            contrastCount++;//发生一次对比  
            if(hashMap.get(0)<hashMap.get(j)){//如果是孩子比较大  
                hashMap.put(i, hashMap.get(j));//交换  
                i=j;//转移根节点下标  
                j*=2;//转移孩子节点下标  
                swapCount++;//发生一次交换  
            }else//如果是根比较大  
                break;  
            contrastCount++;//发生一次对比  
        }  
        hashMap.put(i, hashMap.get(0));//i为当前的合适位置  
        swapCount++;//发生一次交换  
        print(hashMap, printCount++);//输出排序结束的序列  
                  
    }  
  
    /** 
     * 打印已排序好的元素 
     * @param hashMap 已排序的表 
     * @param j 第j趟排序 
     */  
    private static void print(HashMap<Integer, Integer> hashMap, int j){  
        if(j != 0)  
            System.out.print("第 "+j+" 趟：\t");  
        for(int i=1; i<hashMap.size(); i++){//从第一个一直输出到最后一个  
            System.out.print(hashMap.get(i)+"\t");  
        }  
        System.out.println();  
    }  
}

归并排序

import java.util.HashMap;  
  
/** 
 * 归并排序 
 * @author HHF 
 * 2014年3月19日 
 */  
public class MergeSort {  
  
    private static int contrastCount = 0;//对比次数  
    private static int swapCount = 0;//交换次数  
    private static int printCount = 1;//只为统计执行次数  
  
    public static void main(String[] args) {  
        System.out.println("归并尔排序：\n  先将数据分为n组，然后没两组开始合并，相邻两个合并为一个新的有序队列，重复合并直到整个队列有序,时间复杂度O(nlgn),空间复杂度O(n)，稳定排序");          
        HashMap<Integer,Integer> hashMap = new HashMap<Integer,Integer>();//未排序  
        HashMap<Integer,Integer> hashMapNew = new HashMap<Integer,Integer>();//已排序  
        hashMapNew.put(0, null);//第一位置空  
        init(hashMap);//初始化       
        System.out.println("初始序列为：");  
        print(hashMap, 0);//打印  
        System.out.println("开始归并尔排序：");  
        //排序开始时间  
        long start = System.currentTimeMillis();          
        merge(hashMap, hashMapNew, 1, hashMap.size()-1);//排序  
        //排序结束时间  
        long end = System.currentTimeMillis();  
        System.out.println("结果为：");  
        print(hashMapNew, 0);//输出排序结束的序列  
        hashMap.clear();//清空  
        System.out.print("一共发生了 "+contrastCount+" 次对比\t");  
        System.out.print("一共发生了 "+swapCount+" 次交换\t");  
        System.out.println("执行时间为"+(end-start)+"毫秒");  
        System.out.println("(注：此输出序列为代码执行过程的序列， 即先左边递归 再 右边递归， 而教科书上的递归序列往往是左右同时进行的结果，特此说明)");  
    }  
    /** 
     * 初始化函数 
     * @param hashMap 
     */  
    private static void init(HashMap<Integer, Integer> hashMap) {  
        hashMap.put(0, null);//第一位置空  
        hashMap.put(1, 10);  
        hashMap.put(2, 5);  
        hashMap.put(3, 11);  
        hashMap.put(4, 12);  
        hashMap.put(5, 13);  
        hashMap.put(6, 4);  
        hashMap.put(7, 1);  
        hashMap.put(8, 5);  
        hashMap.put(9, 8);  
        hashMap.put(10, 6);  
        hashMap.put(11, 4);  
        hashMap.put(12, 8);       
    }  
    /** 
     * 进行归并尔排序 
     * @param hashMap 待排序的表 
     * @param hashMapNew 已排序的表 
     */  
    private static void merge(HashMap<Integer, Integer> hashMap, HashMap<Integer, Integer> hashMapNew, int low, int high){  
        if(low == high){  
            hashMapNew.put(low, hashMap.get(low));  
            swapCount++;//发生一次交换  
        }else{  
            int meddle = (int)((low+high)/2);//将这一序列数均分的中间值  
            merge(hashMap, hashMapNew, low, meddle);//继续对左边的序列递归  
            merge(hashMap, hashMapNew, meddle+1, high);//对右边的序列递归  
            mergeSort(hashMap, hashMapNew, low, meddle, high);//把相邻的序列组合起来  
            for(int i=low; i<=high; i++){//将已经排好序的hashMapNew【low，high】覆盖hashMap【low，high】以便进入下一次的递归归并  
                hashMap.put(i, hashMapNew.get(i));  
                swapCount++;//发生一次交换  
            }  
        }   
    }  
    /** 
     * 进行归并尔排序 把【low，meddle】和【meddle+1，high】和并为一个有序的hashMapNew【low,high】 
     * @param hashMap 待排序的表       
     * @param hashMapNew 已排序的表  
     * @param low 低位 
     * @param meddle 中位  
     * @param high 高位 
     */  
    private static void mergeSort(HashMap<Integer, Integer> hashMap, HashMap<Integer, Integer> hashMapNew, int low, int meddle, int high){  
        int k = low;  
        int j = meddle+1;  
        while(low<=meddle && j<=high){//两个序列组合成一个序列 从小到达的顺序  
            if(hashMap.get(low) < hashMap.get(j)){  
                hashMapNew.put(k++, hashMap.get(low++));//放入合适的位置  
            }else{  
                hashMapNew.put(k++, hashMap.get(j++));//放入合适的位置  
            }             
            contrastCount++;//发生一次对比  
            swapCount++;//发生一次交换  
        }  
        //如果有一方多出来了 则直接赋值  
        while(low<=meddle){  
            hashMapNew.put(k++, hashMap.get(low++));//放入合适的位置  
            swapCount++;//发生一次交换  
        }  
        while(j<=high){  
            hashMapNew.put(k++, hashMap.get(j++));//放入合适的位置  
            swapCount++;//发生一次交换  
        }  
        print(hashMapNew, printCount++);  
    }  
    /** 
     * 打印已排序好的元素 
     * @param hashMap 已排序的表 
     * @param j 第j趟排序 
     */  
    private static void print(HashMap<Integer, Integer> hashMap, int j){  
        if(j != 0)  
            System.out.print("第 "+j+" 趟：\t");  
        for(int i=1; i<hashMap.size(); i++){//从第一个一直输出到最后一个  
            System.out.print(hashMap.get(i)+"\t");  
        }  
        System.out.println();  
    }  
}

最低位优先基数排序

/** 
 * 最低位优先基数排序 
 * @author HHF 
 * 
 */  
public class LSDSort {  
  
    private static int contrastCount = 0;//对比次数  
    private static int swapCount = 0;//交换次数  
    private static int printCount = 1;//只为统计执行次数  
  
    public static void main(String[] args) {  
        System.out.println("最低位优先基数排序：\n  按个位、十位、百位排序，不需要比较，只需要对数求余然后保存到相应下标的二维数组内，然后依次读取，每一进制重复依次 ,时间复杂度O(d（n+rd）),空间复杂度O(n+rd)，稳定排序");          
        int[] data = { 173, 22, 93, 43, 55, 14, 28, 65, 39, 81, 33, 100 };  
        System.out.println("初始序列为：");  
        print(data, 0);//打印  
        LSD(data, 3);  
    }  
      
    public static void LSD(int[] number, int d) {// d表示最大的数有多少位  
        int k = 0;//number的小标  
        int n = 1;//当比较十位的时候 n=10  比较百位的时候 n=100 用来吧高位降低方便求余数   
        int m = 1;//正在比较number中数据的倒数第几位  
        int[][] temp = new int[10][number.length];// 数组的第一维表示可能的余数0-9 二维依次记录该余数相同的数  
        int[] order = new int[10];// 数组orderp[i]用来表示该位的余数是i的数的个数  
        //排序开始时间  
        long start = System.currentTimeMillis();  
        while (m <= d) {//d=5则比较五次  
            for (int i = 0; i < number.length; i++) {//把number中的数按余数插入到temp中去  
                int lsd = ((number[i] / n) % 10);//求得该数的余数  
                temp[lsd][order[lsd]] = number[i];//保存到相应的地方  
                order[lsd]++;//该余数有几个  
                swapCount++;//发生一次交换  
            }  
            for (int i = 0; i < 10; i++) {//将temp中的数据按顺序提取出来  
                if (order[i] != 0)//如果该余数没有数据则不需要考虑  
                    for (int j = 0; j < order[i]; j++) {//有给余数的数一共有多少个  
                        number[k] = temp[i][j];//一一赋值  
                        k++;  
                        swapCount++;//发生一次交换  
                    }  
                order[i] = 0;//置零，以便下一次使用  
            }  
            n *= 10;//进制+1 往前走  
            k = 0;//从头开始  
            m++;//进制+1  
            print(number, printCount++);  
        }  
        //排序结束时间  
        long end = System.currentTimeMillis();  
        System.out.println("结果为：");  
        print(number, 0);//输出排序结束的序列  
        System.out.print("一共发生了 "+contrastCount+" 次对比\t");  
        System.out.print("一共发生了 "+swapCount+" 次交换\t");  
        System.out.println("执行时间为"+(end-start)+"毫秒");  
    }  
    /** 
     * 打印已排序好的元素 
     * @param data 已排序的表 
     * @param j 第j趟排序 
     */  
    private static void print(int[] data, int j){  
        if(j != 0)  
            System.out.print("第 "+j+" 趟：\t");  
        for (int i = 0; i < data.length; i++) {  
            System.out.print(data[i] + " ");  
        }  
        System.out.println();  
    }  
}
项目推荐



DC3是基于Spring Cloud的开源可分布式物联网(IOT)平台,用于快速开发、部署物联设备接入项目,是一整套物联系统解决方案。

pnoker
关注
专栏目录
常用的8中排序算法【性能比较、算法原理、Python实现】
qq_25041667的博客
09-04 553
常用的8中排序算法【性能比较、算法原理、Python实现】性能比较插入排序直接插入排序希尔排序选择排序直接选择排序堆排序交换排序冒泡排序快速排序归并排序基数排序 性能比较 往往评价一个排序算法的好坏往往可以从下边几个方面入手： （1）时间复杂度：即从序列的初始状态到经过排序算法的变换移位等操作变到最终排序好的结果状态的过程所花费的时间度量。 （2）空间复杂度：就是从序列的初始状态经过排序移位变换的...
JAVA 8种排序介绍及实现
05-07
该文档是针对比较经典的8中算法，从原理、设计到代码实现方面做了详细描述。通俗易懂，比较适合初学者入门、也适合专业者巩固基础。
使用Java实现八种基本排序
w13707470416的博客
01-03 90
插入排序、选择排序、冒泡排序、希尔排序、堆排序、快速排序、归并排序、基数排序 import java.util.ArrayList; import java.util.List; /** * 排序算法主类 * * @author eric */ class SortArray { /* * 【插入排序】 * 基本思想： 在要排序的一组数中，假设前面(n-1) [n&a...
java从小到大排序函数_Java8函数之旅 (五) -- Java8中的排序
weixin_30832021的博客
02-13 810
前言对数据进行排序是平常经常会用到的操作之一，使用Jav8排序可以减少你在排序这方面的代码量，优化你的代码。测试用例代码定义个实体类User，拥有姓名name,年龄age,积分credits三个属性,定义一个包含User的集合，用于排序，下面是代码/* 这里偷个懒，用lombok注解生成实体类getset等一些基本方法 */@Data@AllArgsConstructor@NoArgsConstr...
8中常见的排序算法
03-24 1163
#include #include #include //冒泡排序 void boblesort(int * arr,int n); //插入排序 void insertsort2(int *arr,int n); //希尔排序 void shellsort2(int *arr,int n); //选择排序 void selectsort(int *arr,int n); //归并排序 v
Java实现按中文首字母排序的具体实例
09-04
在Java编程中，排序是常见的任务之一，尤其在处理数据集合时。对于中文字符串的排序，由于涉及到汉字的拼音和顺序，与英文排序有所不同。本文将详细解释如何使用Java实现按中文首字母排序。 首先，Java标准库提供了...
java 中List按照date排序的实现
08-30
Java 中List按照date排序的实现是Java开发中一个常见的需求，特别是在处理日期类型的数据时SORT。今天，我们将介绍如何使用Java中的Collections类和Comparator接口对List按照date排序。 首先，让我们先了解一下 ...
8种常用排序方法java类实现
07-04
本篇文章将详细探讨标题为“8种常用排序方法Java类实现”的主题，主要基于描述中的内容，即8种业务中常见的排序方法在Java语言中的实现。 1. **冒泡排序（Bubble Sort）**：冒泡排序是一种简单直观的排序算法，通过...
Java实现几种常见排序算法代码
09-05
【Java实现几种常见排序算法代码】的描述中提到了排序的重要性以及分类，下面将详细讲解这些排序算法。 1. **排序算法的意义与稳定度** - 排序是计算机科学中的基本操作，它使得数据组织有序，便于查找、分析和...
java实现List中对象排序的方法
09-03
本文将深入探讨如何使用Java实现List中对象的排序，特别是基于对象的属性进行排序。我们将以一个简单的例子来阐述，这个例子中有一个名为`News`的类，包含`id`、`title`和`hits`（点击数）等属性，我们将根据`hits`...
数据结构 之 8中常用排序
Anxdada -- 我等风来也等你
12-06 403
#include <bits/stdc++.h> using namespace std; const int maxn = 20; int a[maxn], b[maxn], n; int cnt; //比较次数 void PrintSequence(int *s) { for (int i = 1 ; i <= n ; i++) { printf("%d%c", s[i]
八大排序算法
jianghui009的博客
01-30 2189
所谓排序，就是将一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。常用的排序算法大致有8种：插入排序（直接插入排序、希尔排序）、选择排序（简单选择排序、堆排序）、交换排序（冒泡排序、快速排序）、归并排序、基数排序。 一、直接插入排序 算法思想：把要排序的数组分为了两个部分，一部分是排序好的元素，另一部分是待插入的元素，如果选择的元素比已排序好的元素小，则交换，直到全部元素都比较过为止。 排序过程： 代码实现： public
常见的8中排序算法
jialiang的博客
07-15 226
包含冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，基数排序，堆排序 声明：下面的代码只是一个最基础的实现，没有经过严格的测试。 /** * 排序 */ public class Sort { public static void main(String[] args) { int[] arr=new int[8000000]; for (int i = 0; i < arr.length; i++) { arr[i
java8排序
Chery Qi的博客
09-01 143
@Data public class StudentInfo implements Comparable<StudentInfo> { //名称 private String name; //性别 true男 false女 private Boolean gender; //年龄 private Integer age; //身高 private Double height; //出生日期 private Loca.
Java8集合List 对数字排序、筛选、求和、求最大值、平均值
悟能的师兄的专栏
05-22 1万+
List过滤指定元素排序 其实很简单，可是CSDN或者其他网站上的作者都喜欢装逼，对Double、或者Integer的处理基本都是无。
物联网IOT与Java结合之MQTT协议:EMQT
最新发布
qq_39246466的博客
11-16 3233
物联网IOT与Java结合之MQTT协议:EMQT
Java基本语法练习...【Pnoker】
Pnoker
02-15 1195
1.编写程序，求100以内的全部素数实验源码：public class FirstClass { public static void main(String[] args) { int iTemp; //临时标记变量 System.out.print("100以内的素数为："); for(int i = 2; i <= 100; i++)
Java常用实现八种排序算法与代码实现
热门推荐
java_atguigu的博客
04-02 1万+
一、交换排序 所谓交换，就是序列中任意两个元素进行比较，根据比较结果来交换各自在序列中的位置，以此达到排序的目的。 1. 冒泡排序 冒泡排序是一种简单的交换排序算法，以升序排序为例，其核心思想是： 从第一个元素开始，比较相邻的两个元素。如果第一个比第二个大，则进行交换。 轮到下一组相邻元素，执行同样的比较操作，再找下一组，直到没有相邻元素可比较为止，此时最后的元素应是最大的数。 除了每次排序得到的最后一个元素，对剩余元素重复以上步骤，直到没有任何一对元素需要比较为止。
剖析八种经典排序算法
染尘
04-29 1万+
排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素(或记录)的任意序列，重新排列成一个关键字有序的序列。 我整理了以前自己所写的一些排序算法结合网上的一些资料，共介绍8种常用的排序算法，希望对大家能有所帮助。八种排序算法分别是： 1.冒泡排序； 2.选择排序； 3.插入排序； 4.快速排序； 5.归并排序； 6.希尔排序； 7.二叉排序； 8.基
Java实现常见排序算法整理
在这个Java实现中，`InsertSort`类实现了`SortUtil.Sort`接口，并提供了`sort`方法来执行排序。内部使用了两个嵌套循环，外层循环从第二个元素开始遍历数组，内层循环则用于将当前元素与前面已排序的元素进行比较并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值