各种排序算法合集

最新推荐文章于 2021-01-28 17:26:36 发布
最新推荐文章于 2021-01-28 17:26:36 发布
阅读量104 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abc3224302/article/details/95251512
版权

https://github.com/hustcc/JS-Sorting-Algorithm

十大经典排序算法 概览截图

插入

 

希尓（分组插入）

 

选择

 

快速排序

public class QuickSort {

   public static void quickSort(int [] arr,int left,int right) {

      int pivot=0;

      if(left<right) {

         pivot=partition(arr,left,right);

         quickSort(arr,left,pivot-1);

         quickSort(arr,pivot+1,right);
      }
   }

   private static int partition(int[] arr,int left,int right) {

      int key=arr[left];

      while(left<right) {

         while(left<right && arr[right]>=key) {
            right--;
         }

         arr[left]=arr[right];

         while(left<right && arr[left]<=key) {
            left++;
         }

         arr[right]=arr[left];
      }

      arr[left]=key;
      return left;
   }

  

   public static void main(String[] args) {

      int arr[]= {65,58,95,10,57,62,13,106,78,23,85};

      System.out.println("排序前："+Arrays.toString(arr));
     
      quickSort(arr,0,arr.length-1);

      System.out.println("排序后："+Arrays.toString(arr));
   }
}

堆排序

https://www.jianshu.com/p/0d383d294a80

https://www.cnblogs.com/chengxiao/p/6129630.html

package sortdemo;

import java.util.Arrays;

/**
 * Created by chengxiao on 2016/12/17.
 * 堆排序demo
 */
public class HeapSort {
    public static void main(String []args){
        int []arr = {9,8,7,6,5,4,3,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int []arr){
        //1.构建大顶堆
        for(int i=arr.length/2-1;i>=0;i--){
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr,i,arr.length);
        }
        //2.调整堆结构+交换堆顶元素与末尾元素
        for(int j=arr.length-1;j>0;j--){
            swap(arr,0,j);//将堆顶元素与末尾元素进行交换
            adjustHeap(arr,0,j);//重新对堆进行调整
        }

    }

    /**
     * 调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
     * @param arr
     * @param i
     * @param length
     */
    public static void adjustHeap(int []arr,int i,int length){
        int temp = arr[i];//先取出当前元素i
        for(int k=i*2+1;k<length;k=k*2+1){//从i结点的左子结点开始，也就是2i+1处开始
            if(k+1<length && arr[k]<arr[k+1]){//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                arr[i] = arr[k];
                i = k;
            }else{
                break;
            }
        }
        arr[i] = temp;//将temp值放到最终的位置
    }

    /**
     * 交换元素
     * @param arr
     * @param a
     * @param b
     */
    public static void swap(int []arr,int a ,int b){
        int temp=arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

 

桶排序

一句话总结：划分多个范围相同的区间，每个子区间自排序，最后合并。

桶排序是计数排序的扩展版本，计数排序可以看成每个桶只存储相同元素，而桶排序每个桶存储一定范围的元素，通过映射函数，将待排序数组中的元素映射到各个对应的桶中，对每个桶中的元素进行排序，最后将非空桶中的元素逐个放入原序列中。

桶排序需要尽量保证元素分散均匀，否则当所有数据集中在同一个桶中时，桶排序失效。

public static void bucketSort(int[] arr){
    
    // 计算最大值与最小值
    int max = Integer.MIN_VALUE;
    int min = Integer.MAX_VALUE;
    for(int i = 0; i < arr.length; i++){
        max = Math.max(max, arr[i]);
        min = Math.min(min, arr[i]);
    }
    
    // 计算桶的数量
    int bucketNum = (max - min) / arr.length + 1;
    ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
    for(int i = 0; i < bucketNum; i++){
        bucketArr.add(new ArrayList<Integer>());
    }
    
    // 将每个元素放入桶
    for(int i = 0; i < arr.length; i++){
        int num = (arr[i] - min) / (arr.length);
        bucketArr.get(num).add(arr[i]);
    }
    
    // 对每个桶进行排序
    for(int i = 0; i < bucketArr.size(); i++){
        Collections.sort(bucketArr.get(i));
    }
    
    // 将桶中的元素赋值到原序列
	int index = 0;
	for(int i = 0; i < bucketArr.size(); i++){
		for(int j = 0; j < bucketArr.get(i).size(); j++){
			arr[index++] = bucketArr.get(i).get(j);
		}
	}  
}

冒泡

背包算法

https://blog.csdn.net/lanyu_01/article/details/79815801

 

https://blog.csdn.net/na_beginning/article/details/62884939?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase

 

参考链接：

http://www.cnblogs.com/fengty90/p/3768845.html
http://blog.csdn.net/mu399/article/details/7722810
http://blog.csdn.net/xiaowei_cqu/article/details/8191808
http://blog.csdn.net/insistgogo/article/details/11176693
背包问题是动态规划算法的一个典型实例，首先介绍动态规划算法：

一、0—1背包
思路分析：
0-1背包问题主要涉及到两个问题的求解

a)求解背包所含物品的最大值：

利用动态规划求最优值的方法。假设用dp[N][V]来存储中间状态值,dp[i][j]表示前i件物品能装入容量为j的背包中的物品价值总和的最大值(注意是最大值),则我们最终只需求知dp[i=N][j=V]的值，即为题目所求。
现在考虑动态规划数组dp[i][j]的状态转移方程：
假设我们已经求出前i-1件物品装入容量j的背包的价值总和最大值为dp[i-1][j],固定容量j的值不变，则对第i件物品的装法讨论如下：
首先第i件物品的重量weight[i]必须小于等于容量j才行，即
1、若weight[i]>j,则第i件物品肯定不能装入容量为j的背包，此时dp[i][j]=dp[i-1][j]
2、若weight[i]<=j,则首先明确的是这件物品是可以装入容量为j的背包的，那么如果我们将该物品装入，则有
dp[i][j]=dp[i-1][j-weight[i]]+value[i]
随之而来的问题是我们要判断第i件物品装到容量为j的背包后,背包内的总价值是否是最大？其实很好判断，即如果装了第i件物品后的总价值dp[i-1][j-weight[i]]+value[i]>没装之前的总价值最大值dp[i-1][j]，则肯是最大的；反之则说明第i件物品不必装入容量为j的背包(装了之后总价值反而变小，那么肯定就不需要装嘛)
故，状态转移方程如下：
dp[i][j] = (dp[i-1][j] > (dp[i-1][j-weight[i]]+value[i]))? dp[i-1][j]:(dp[i-1][j-weight[i]]+value[i])
注意：这里的前i件物品是给定次序的

b)求出背包中装入物品的编号

这里我们采用逆推的思路来处理，如果对于dp[i][j]>dp[i-1][j]，则说明第i个物品肯定被放入了背包，此时我们再考察dp[i-1][j-weight[i]]的编号就可以了。
 

/**
     * 0-1背包问题
     * @param V 背包容量
     * @param N 物品种类
     * @param weight 物品重量
     * @param value 物品价值
     * @return
     */
    public static String ZeroOnePack(int V,int N,int[] weight,int[] value){

        //初始化动态规划数组
        int[][] dp = new int[N+1][V+1];
        //为了便于理解,将dp[i][0]和dp[0][j]均置为0，从1开始计算
        for(int i=1;i<N+1;i++){
            for(int j=1;j<V+1;j++){
                //如果第i件物品的重量大于背包容量j,则不装入背包
                //由于weight和value数组下标都是从0开始,故注意第i个物品的重量为weight[i-1],价值为value[i-1]
                if(weight[i-1] > j)
                    dp[i][j] = dp[i-1][j];
                else
                    dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-weight[i-1]]+value[i-1]);
            }
        }
        //则容量为V的背包能够装入物品的最大值为
        int maxValue = dp[N][V];
        //逆推找出装入背包的所有商品的编号
        int j=V;
        String numStr="";
        for(int i=N;i>0;i--){
            //若果dp[i][j]>dp[i-1][j],这说明第i件物品是放入背包的
            if(dp[i][j]>dp[i-1][j]){
                numStr = i+" "+numStr;
                j=j-weight[i-1];
            }
            if(j==0)
                break;
        }
        return numStr;  
    }

0-1背包的优化解法：

/**
     * 0-1背包的优化解法
     * 思路：
     * 只用一个一维数组记录状态，dp[i]表示容量为i的背包所能装入物品的最大价值
     * 用逆序来实现
     */
    public static int ZeroOnePack2(int V,int N,int[] weight,int[] value){
        //动态规划
        int[] dp = new int[V+1];
        for(int i=1;i<N+1;i++){
            //逆序实现
            for(int j=V;j>=weight[i-1];j--){
                dp[j] = Math.max(dp[j-weight[i-1]]+value[i-1],dp[j]);
            }
        }
        return dp[V];       
    }

 


二、多重背包

/**
     * 第三类背包：多重背包
     * 
     * @param args
     */
    public static int manyPack(int V,int N,int[] weight,int[] value,int[] num){
        //初始化动态规划数组
        int[][] dp = new int[N+1][V+1];
        //为了便于理解,将dp[i][0]和dp[0][j]均置为0，从1开始计算
        for(int i=1;i<N+1;i++){
            for(int j=1;j<V+1;j++){
                //如果第i件物品的重量大于背包容量j,则不装入背包
                //由于weight和value数组下标都是从0开始,故注意第i个物品的重量为weight[i-1],价值为value[i-1]
                if(weight[i-1] > j)
                    dp[i][j] = dp[i-1][j];
                else{
                    //考虑物品的件数限制
                    int maxV = Math.min(num[i-1],j/weight[i-1]);
                    for(int k=0;k<maxV+1;k++){
                        dp[i][j]=Math.max(dp[i-1][j],dp[i-1][j-k*weight[i-1]]+k*value[i-1]);
                    }
                }
            }
        }
        /*//则容量为V的背包能够装入物品的最大值为
        int maxValue = dp[N][V];
        int j=V;
        String numStr="";
        for(int i=N;i>0;i--){
            //若果dp[i][j]>dp[i-1][j],这说明第i件物品是放入背包的
            while(dp[i][j]>dp[i-1][j]){
                numStr = i+" "+numStr;
                j=j-weight[i-1];
            }
            if(j==0)
                break;
        }*/
        return dp[N][V];
    }

 

 

三、完全背包

/**
     * 第二类背包：完全背包
     * 思路分析：
     * 01背包问题是在前一个子问题（i-1种物品）的基础上来解决当前问题（i种物品），
     * 向i-1种物品时的背包添加第i种物品；而完全背包问题是在解决当前问题（i种物品）
     * 向i种物品时的背包添加第i种物品。
     * 推公式计算时，f[i][y] = max{f[i-1][y], (f[i][y-weight[i]]+value[i])}，
     * 注意这里当考虑放入一个物品 i 时应当考虑还可能继续放入 i，
     * 因此这里是f[i][y-weight[i]]+value[i], 而不是f[i-1][y-weight[i]]+value[i]。
     * @param V
     * @param N
     * @param weight
     * @param value
     * @return
     */
    public static String completePack(int V,int N,int[] weight,int[] value){
        //初始化动态规划数组
        int[][] dp = new int[N+1][V+1];
        //为了便于理解,将dp[i][0]和dp[0][j]均置为0，从1开始计算
        for(int i=1;i<N+1;i++){
            for(int j=1;j<V+1;j++){
                //如果第i件物品的重量大于背包容量j,则不装入背包
                //由于weight和value数组下标都是从0开始,故注意第i个物品的重量为weight[i-1],价值为value[i-1]
                if(weight[i-1] > j)
                    dp[i][j] = dp[i-1][j];
                else
                    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-weight[i-1]]+value[i-1]);
            }
        }
        //则容量为V的背包能够装入物品的最大值为
        int maxValue = dp[N][V];
        int j=V;
        String numStr="";
        for(int i=N;i>0;i--){
            //若果dp[i][j]>dp[i-1][j],这说明第i件物品是放入背包的
            while(dp[i][j]>dp[i-1][j]){
                numStr = i+" "+numStr;
                j=j-weight[i-1];
            }
            if(j==0)
                break;
        }
        return numStr;
    }
    /**
     * 完全背包的第二种解法
     * 思路：
     * 只用一个一维数组记录状态，dp[i]表示容量为i的背包所能装入物品的最大价值
     * 用顺序来实现
     */
    public static int completePack2(int V,int N,int[] weight,int[] value){

        //动态规划
        int[] dp = new int[V+1];
        for(int i=1;i<N+1;i++){
            //顺序实现
            for(int j=weight[i-1];j<V+1;j++){
                dp[j] = Math.max(dp[j-weight[i-1]]+value[i-1],dp[j]);
            }
        }
        return dp[V];
    }

二叉树遍历（前序、中序、后序）-Java实现

https://www.cnblogs.com/zhi-leaf/p/10813048.html

tiny_sxj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常见排序算法汇总
夜槿笙歌的博客
04-17 8205
整理一下之前学习的各种排序算法
排序算法合集
Juwenile的博客
01-04 740
排序算法 文章目录排序算法一：直接插入排序（一）：算法思想（二）：代码（三）：性能分析二：折半插入排序算法(一)：算法思想：(二)：代码(三)：性能分析三：希尔排序（一）：算法思想（二)：代码(三)：性能分析四：冒泡排序(一)：算法思想(二)：代码(三)：性能分析 一：直接插入排序 （一）：算法思想 每一趟将一个待排序的关键字按照其值的大小插入到已经排序好的部分的适当位置，直到所有的待排关键字都被插入到有序序列中为止 （二）：代码 void InsertSort(int A[],int numsize){
十大排序算法合集
peachzy的博客
01-28 321
参考此处 一、快排： 1、算法思想： 选择一个基准元素，将比基准元素小的元素放在其前面，比基准元素大的元素放在其后面，然后在将小于基准值元素的子数列和大于基准元素的子数列按原来的方法排序，直到整个序列有序; 2、应用场景： a.求数组中第k小的数 将数组中某一个元素m作为划分依据,即m=arr[0]。若m前面的元素个数大于k，则第k小的数一定在m前面的元素中，这时我们只需要继续在m前面的元素中找第k小的数；若m前面的元素小于k，则第k小的数一定在m后面的元素中，这时我们只需要在m后面的元素中找第k小的数；.
PHP 各种排序算法实现代码
01-20
php // 功能: PHP实现各种排序算法 // Author: windlike // Datetime: 2007-06-09 // 冒泡排序 function BubbleSort($arr){ $num = count($arr); for($i=1;$i<$num;$i++){ for($j=$num-1;$j>=$i;$j–){ if($arr[$...
各种排序算法比较1
08-03
示例 1：输出：[1,2,3,5]示例 2：输出：[0,0,1,1,2,5]解题思路：比较多种排序算法，最终只有堆排序，快排，归并排序符合时间复杂度要求* No
各种排序算法的详细分析
03-22
此为一个利用Java语言编写的排序分析程序，程序中统计了各种排序算法（冒泡排序、选择排序、插入排序、希尔排序、快速排序、堆排序、归并排序、基数排序）的分析，ppt中包含各种排序算法的分析，附上动画演示（来自...
数据结构：史上最全排序算法合集
热门推荐
小那猿同学的博客
10-29 2万+
收录总结了计数排序，选择排序，冒泡排序，基数排序以待更新
史上最强排序算法合集
shzhqmeng的博客
05-23 4345
/************************************************************************* > File Name: sort_v2.cpp > Author: ma6174 > Mail: [email protected] > Created Time: 一 5/22 19:29:07 2017 *****
经典排序算法合集
ShuaiWangCSDN的博客
03-26 376
1. 经典排序算法—归并排序Merge sort 原理,采用递归把原始数组不断二分，分成若干子数组,对每一个子数组进行排序,此步算法复杂度为2*T（n/2） 继续把子数组与子数组合并,合并后仍然有序,直到全部合并完,形成有序的数组。--算法复杂度为O（n） 总的算法复杂度 T（n）=2*T（n/2）+O（n） 采用递归树方法，计算后，合并排序的算法复杂度为O（n log n） 举例:
排序算法大合集
我去
12-22 165
#include<stdlib.h> #include<unistd.h> #include<stdio.h> #include<unistd.h> #include<sys/wait.h> #include<time.h>#define MAX 10000 int check(int a[],int n){ for (int i=0;i<n-1;i++) if (a[i]>
各种排序算法大合集
A_scholar的博客
10-28 538
各种算法的比较： 快速排序： 希尔(Shell)排序： 要点 希尔(Shell)排序又称为缩小增量排序，它是一种插入排序。它是直接插入排序算法的一种威力加强版。 希尔排序的基本思想是： 把记录按步长 gap 分组，对每组记录采用直接插入排序方法进行排序。 随着步长逐渐减小，所分成的组包含的记录越来越多，当步长的值减小到 1 时，整个数据合成为一组，构成一组有序记录，则完成排序。 我们来通过演示...
常用排序算法合集1
小男孩
09-07 295
这里我将常用的十种排序算法进行归纳，并且提供代码的实现。 本篇文章实现的有冒泡，选择，插入，希尔，归并，话不多说，详情请查看源码： package day01; import java.util.Random; public class AlgTest { static Random r=new Random(); static int[] array=new int[10]; p...
各种排序算法的复杂度
最新发布
09-14
各种排序算法的复杂度取决于输入数据的规模（n）和算法的执行步骤数（T）。以下是一些常见排序算法及其平均和最差情况下的时间复杂度： 1. 冒泡排序（Bubble Sort）： - 平均复杂度：O(n^2) - 最差情况：O(n^2) ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值