七大排序算法

最新推荐文章于 2024-06-01 18:20:50 发布
最新推荐文章于 2024-06-01 18:20:50 发布
阅读量107 收藏
点赞数 2
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wwweeeeeeeeeee/article/details/117534758
版权

选择排序

package PaiXu;

import java.util.Random;

/**
 * 选择排序
 */
public class XuanZe {

	public static void main(String[] args) {
		int[] arr=new int[20000];
		for(int i=0;i<arr.length;i++){
			arr[i]=new Random().nextInt(100000);
			System.out.print(arr[i]+" ");
		}
		System.out.println();
		System.out.println("============================");
		long before = System.currentTimeMillis();
		bianLi(sort(arr));
		long after=System.currentTimeMillis();
		System.out.println();
		System.out.println("排序花费时间"+(after-before)+"毫秒");

	}

	public static int[] sort(int[] arr){
		for(int i=0;i<arr.length-1;i++){
			int minIndex=i;
			for(int j=i+1;j<arr.length;j++){
				if(arr[j]<arr[minIndex]){
					minIndex=j;
				}
			}
			int flag=arr[i];
			arr[i]=arr[minIndex];
			arr[minIndex]=flag;
		}
		return arr;
	}
	
	/**
	 * 遍历数组
	 * @param arr
	 */
	public static void bianLi(int[] arr){
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}
	}

}

冒泡排序

package PaiXu;

/**
 * 冒泡排序
 */
public class MaoPao {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int [] arr=sort(new int[]{2,5,41,3,7,4,6,52,34,1,564,84});
		bianLi(arr);
	}

	public static int[] sort(int[] arr){
		for(int i=0;i<arr.length-1;i++){
			for(int j=0;j<arr.length-i-1;j++){
				if(arr[j]>arr[j+1]){
					int flag=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=flag;
				}
			}
		}
		return arr;
	}
	
	/**
	 * 遍历数组
	 * @param arr
	 */
	public static void bianLi(int[] arr){
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}
	}

}

插入排序

package PaiXu;

/**
 * @author xwm
 * @email 2825902051@qq.com
 * @date 2021/5/18 0018
 * @time 10:46
 */

import java.util.Random;

/**
 * 插入排序
 * 2,3,5,1,7,4,9,6
 */
public class ChaRu {
    public static void main(String[] args) {
        int[] arr=new int[10000];
        Random random=new Random();
        for(int i=0;i<arr.length;i++){
            arr[i]=random.nextInt(100000);
            System.out.print(arr[i]+" ");
        }

        System.out.println("\n排序后:");
        long before = System.currentTimeMillis();
        bianLi(sort(arr));
        System.out.println("\n排序花费时长"+(System.currentTimeMillis()-before));
    }

    public static int[] sort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j>0;j--){
                if(arr[j]<arr[j-1]){
                    int flag=arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=flag;
                }
            }
        }
        return arr;
    }


    /**
     * 遍历arr数组
     * @param arr
     */
    public static void bianLi(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

快速排序

package PaiXu;

/**
 * @author xwm
 * @email 2825902051@qq.com
 * @date 2021/5/18 0018
 * @time 17:16
 */

/**
 * 快速排序
 */
public class KuaiSu {

    public static void main(String[] args) {
        int[] arr=new int[1000];
        for(int i=0;i<1000;i++){
            arr[i]=(int)(Math.random()*100000);
        }
        sort(arr);
        bianLi(arr);
    }

    public static void sort(int [] arr){
        int header=0;
        int rear=arr.length-1;
        sort(arr,header,rear);
    }

    public static void sort(int[] arr, int header, int rear) {
        if(header>=rear){
            return;
        }
        int divi=divide(arr,header,rear);

        sort(arr,header,divi-1);
        sort(arr,divi+1,rear);
    }

    public static int divide(int[] arr, int header, int rear) {
        int divid=arr[header];
        int min=header;
        int max=rear+1;
        while (true){
            while (arr[--max]>divid){
                if(max==header){
                    break;
                }
            }
            while (arr[++min]<divid){
                if(min==rear){
                    break;
                }
            }
            if(min>=max){
                break;
            }
            else {
                int flag=arr[max];
                arr[max]=arr[min];
                arr[min]=flag;
            }
        }
        int flag=arr[max];
        arr[max]=arr[header];
        arr[header]=flag;
        return max;
    }

    /**
     * 遍历arr数组
     * @param arr
     */
    public static void bianLi(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

归并排序

package PaiXu;

/**
 * @author xwm
 * @email 2825902051@qq.com
 * @date 2021/5/18 0018
 * @time 17:16
 */

/**
 * 归并排序
 */
public class GuiBin {
    private static int[] copy;
    public static void main(String[] args) {
       int[] arr=new int[]{4,3,2,8,6,5,9,1,10,654,233,26,149,30,14,68,7,100};
       sort(arr);
       bianLi(arr);
    }

    public static void sort(int[] arr){
        int pre=0;
        int rear=arr.length-1;
        copy=new int[arr.length];
        sort(arr,pre,rear);
    }

    public static void sort(int[] arr, int pre, int rear) {
        //递归中止条件
        if(pre>=rear){
            return;
        }

        int mid=pre+(rear-pre)/2;
        sort(arr,pre,mid);
        sort(arr,mid+1,rear);

       guiBin(arr,pre,mid,rear);
    }

    public static void guiBin(int[] arr, int pre, int mid, int rear) {
        int copyPre=pre;
        int preIndex=pre;
        int midIndex=mid+1;
        while(preIndex<=mid && midIndex<=rear){
            if(arr[preIndex]>arr[midIndex]){
                copy[copyPre++]=arr[midIndex++];
            }
            else{
                copy[copyPre++]=arr[preIndex++];
            }
        }
        while (preIndex<=mid){
            copy[copyPre++]=arr[preIndex++];
        }
        while (midIndex<=rear){
            copy[copyPre++]=arr[midIndex++];
        }
        for(int i=0;i<=rear;i++){
            arr[i]=copy[i];
        }
    }

    /**
     * 遍历arr数组
     * @param arr
     */
    public static void bianLi(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

希尔排序

package PaiXu;

/**
 * @author xwm
 * @email 2825902051@qq.com
 * @date 2021/5/18 0018
 * @time 12:25
 */

/**
 * 希尔排序
 */
public class XiEr {
    public static void main(String[] args) {
        bianLi(sort(new int[]{2,3,5,1,7,4,9,6,211,3,4,6,2,8,12}));
    }

    public static int[] sort(int[] arr){
        int l=1;
        while(l<arr.length/2){
            l=l*2+1;
        }
        while(l>=1){
            for(int i=l;i<arr.length;i++){
                int j=i;
                while (j>=l){
                    if(arr[j-l]>arr[j]){
                        int flag=arr[j-l];
                        arr[j-l]=arr[j];
                        arr[j]=flag;

                        j=j-l;
                    }
                    else {
                        break;
                    }
                }
            }
            l=l/2;
        }
        return arr;

    }
    /**
     * 遍历arr数组
     * @param arr
     */
    public static void bianLi(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

堆排序

import java.util.ArrayList;

/**
 * @author xwm
 * @email 2825902051@qq.com
 * @date 2021/6/8 0008
 * @time 18:51
 */
public class ErChaDui<T extends Comparable<T>> {
    private ArrayList<T> list;
    public ErChaDui(int size) {
        list=new ArrayList(size);
    }
    public ErChaDui(){
        list=new ArrayList();
    }

    public ArrayList<T> getList(){
        return list;
    }
    public int size(){
        return list.size();
    }





    public void add(T t){
       list.add(t);
       this.up();
    }

    public T remove(){
        if(list.size()==0){
            return null;
        }
        swap(0,list.size()-1);
        T t=list.remove(list.size()-1);
        down();
        return t;
    }
    private void swap(int aIndex,int bIndex){
        T t= (T) list.get(aIndex);
        list.set(aIndex,list.get(bIndex));
        list.set(bIndex,t);
    }

    //上浮
    private void up() {
        if(list.size()==0){
            return;
        }
        int index=list.size()-1;
       while (index>0){
           if(list.get(index).compareTo(list.get(index-1))>0){
               if(list.get(index).compareTo(list.get((index-1)/2))>0){
                   swap(index,(index-1)/2);
                   index=(index-1)/2;
                   continue;
               }
               break;
           }
           else {
               if(list.get((index-1)/2).compareTo(list.get(index-1))<0){
                   swap(index-1,(index-1)/2);
                   index=(index-1)/2;
                   continue;
               }
               break;
           }
       }
    }

    //下沉
    public void down(){
        int index=0;
        while ((index*2+2)<=list.size()-1){
            if(list.get(index*2+1).compareTo(list.get(index*2+2))>0){
                if(list.get(index).compareTo(list.get(index*2+1))<0){
                    swap(index,index*2+1);
                    index=index*2+1;
                    continue;
                }
                break;
            }
            else {
                if(list.get(index).compareTo(list.get(index*2+2))<0){
                    swap(index,index*2+2);
                    index=index*2+2;
                    continue;
                }
                break;
            }
        }
    }
    public void list(){
        for (T t : list) {
            System.out.print(t+" ");
        }
    }
    public static void main(String[] args) {
        ErChaDui arr=new ErChaDui();
        arr.add(4);
        arr.add(1);
        arr.add(2);
        arr.add(5);
        arr.add(3);
        Comparable remove = arr.remove();
        while (remove!=null){
            System.out.println(remove);
            remove=arr.remove();
        }
    }


}

测试类

package PaiXu;

/**
 * @author xwm
 * @email 2825902051@qq.com
 * @date 2021/5/18 0018
 * @time 16:08
 */
public class Test {
    public static void main(String[] args) {
        long before=System.currentTimeMillis();
        XiEr.sort(getArr());
        long after=System.currentTimeMillis();
        System.out.println("希尔排序花费时长："+(after-before)+"ms");

        /*long before=System.currentTimeMillis();
        ChaRu.sort(getArr());
        long after=System.currentTimeMillis();
        System.out.println("插入排序花费时长："+(after-before)+"ms");*/

        /*long before=System.currentTimeMillis();
        GuiBin.sort(getArr());
        long after=System.currentTimeMillis();
        System.out.println("归并排序花费时长："+(after-before)+"ms");*/

        /*long before=System.currentTimeMillis();
        KuaiSu.sort(getArr());
        long after=System.currentTimeMillis();
        System.out.println("快速排序花费时长："+(after-before)+"ms");*/
    }
    public static int[] getArr(){
        int[] arr=new int[100000];
        for(int i=99999;i>=0;i--){
            arr[i]=99999-i;
        }
        return arr;
    }
}
小呆萌熊
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
六种常见的排序算法
qq_46721967的博客
07-22 7185
常见的六种排序算法
六大排序算法：冒泡排序、插入排序、希尔排序、选择排序、递归排序、快速排序
a2610033的博客
11-23 1726
六大排序算法的浅显理解和代码实现
【常见的六大排序算法】插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
最新发布
2301_81044829的博客
06-01 2187
在实现排序前，我们要先知道什么是排序。排序：简单的来说就是把一串数据按照一定的方式依次排序。例如：可以按照数字的大小升序或降序排列，或者按照英文字母的先后顺序排列等。使用这一系列的方式，就可以将一串无序状态下的数据排列成有序的数据。
六大排序算法精讲（SelectSort、BubbleSort、InsertSort、MergeSort、QuickSort、HeapSort）
sjl20021006的博客
12-25 2083
一、前言 最近在看算法公开课，听了很多老师讲了不少很有用的东西，但是只听不练很快就忘了，所以我还是选择以博客的方式巩固自己的学习。 二、排序算法概述 今天主要讲的是比较经典的六大排序算法：选择排序、冒泡排序、插入排序、归并排序、快速排序和堆排序，除此之外还有一个比较重点的基数排序，但是因为它是不基于比较的排序，所以用法不是很广泛，所以我也只讲解它的实现原理，不多做阐述，并且，在讲解之余，我也会穿插一些其他内容。 三、选择排序 选择排序是最基础的一...
C++实现五种常见排序算法
weixin_39318565的博客
06-20 5264
排序算法在工作和面试中都经常用到这里是常见的几种算法的C++实现
六大常见排序算法（插入、堆排、希尔、选择、冒泡、快速）
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
09-04 2222
六大排序算法，有图有真相！！！
常见的七大排序算法Java实现.zip
07-30
本压缩包"常见的七大排序算法Java实现.zip"包含了七种经典的排序算法在Java语言中的实现。尽管文件列表中并未明确列出每种排序算法的名称，但根据常规，这七大排序算法可能包括冒泡排序、插入排序、选择排序、快速...
七大经典排序算法总结详解
12-29
以上七大排序算法各有特点，选择哪种取决于具体的应用场景。例如，如果数据基本有序，插入排序可能更合适；对于大规模数据，快速排序或归并排序是更好的选择。理解这些排序算法，不仅有助于编程实践，也有助于提升...
挑战七大排序算法-04堆排序
01-07
堆排序 1.原理 2.实现 3.性能分析 堆排序 1.原理 基本原理也是选择排序，只是不再使用遍历的方式查找无序区间的最大数，而是通过堆来选择无序区间的最大数 升序：大顶堆；降序：小顶堆 堆排序的基本思路： a.将无需...
算法的六种常见排序
weixin_48439150的博客
07-28 643
1 . 冒泡排序（ Bubble Sort ) 在遍历数组时判断 当前位置的 数组大小（a[ j ]）是否比下一位（a[ j + 1 ]）大，如果是，则将 a[ j ] 与a[ j+ 1 ]数值交换，即把大的数往后放，就像是冒泡一样，大的数一直后移，直到数组有序。 在此进行了优化，添加了flag判断本次循环是否进行了交换，如未进行交换则说明排序完毕，跳出循环，减少了可能出现的已经排好序但循环没有结束，继续运行的情况； 当前数组 ：6 1 5 3 4 内循环第一遍 ...
数据结构之常见六大排序算法
weixin_45338443的博客
07-13 430
排序算法是一种将一组元素按照特定顺序排列的算法。常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。
六大排序算法：冒泡、插入、希尔、选择、堆排序、快速排序（附源码）
qq_51216031的博客
02-29 1252
向下调整建堆：倒着往上调整，而叶子节点是不需要向下调整的，所以调整位置从最后一个节点的父亲节点开始向上，逐个进行向下调整我们的数据序列在物理结构上是一个数组，逻辑上是一个二叉树，从最后一个节点的父亲节点开始，依次向前，对数组的每一个数据进行向下调整，这样就保证了每一个节点都进行了向下调整建堆因此，比较重要的是向下调整的逻辑：
六大排序算法
YY799198522的博客
03-08 740
排序算法可以分为内部排序和外部排序。内部排序指的是数据的排序全部在内存中完成，而外部排序指的是排序数据量很大，内存中一次不能全部容纳，需要依靠外部存储来完成排序。
六大排序算法总结
L_smartworld的博客
05-06 495
１.冒泡排序 图解冒泡 　　我们以[8,2,5,9,7]这组数字来做示例，上图来战： 　　我们从左往右依次冒泡，将小的往右移动 　　首先比较第一个数和第二个数的大小，我们发现2比8要小，那么保持原位，不做改动。位置还是8,2,5,9,7。 　　指针往右移动一格，接着比较： 　　比较第二个数和第三个数的大小，发现2比5要小，所以位置交换，交换后数组更新为：[8,5,2,9,...
六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
热门推荐
HanMeng的博客
07-24 57万+
文章目录：1. 插入排序2.希尔排序 1. 插入排序 步骤： 1.从第一个元素开始，该元素可以认为已经被排序 2.取下一个元素tem，从已排序的元素序列从后往前扫描 3.如果该元素大于tem，则将该元素移到下一位 4.重复步骤3，直到找到已排序元素中小于等于tem的元素 5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置 6.重复步骤2~5 动图演示如下： 思路：   在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个
七大排序算法详解与实现
"这篇文档包含了在DOS界面下实现的七大排序算法的源代码，包括插入排序、快速排序、冒泡排序、选择排序、基数排序、归并排序以及头排序。用户可以查看每种排序算法的执行过程。" 七大排序算法是计算机科学中基本且...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小呆萌熊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值