Sorting algorithm

最新推荐文章于 2021-07-07 11:06:51 发布
最新推荐文章于 2021-07-07 11:06:51 发布
阅读量134 收藏
点赞数 1
分类专栏： 笔记 文章标签： 数据结构 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43618933/article/details/106298888
版权

排序算法

1. 冒泡排序
2. 选择排序
3. 插入排序
4. 希尔排序
5. 快速排序
6. 归并排序
7. 基数排序
8. 堆排序

冒泡排序

BubbleSort.java
package com.Taking.sort;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * Demo class
 * 冒泡排序
 *
 * @author Taking
 * @date 2020/5/20
 */
public class BubbleSort {
    public static void main(String[] args) {
        System.out.println("------------------------");
        System.out.println("*******冒泡排序算法*******");
        startTime();
        bubbleSort(randomArray());
        endTime();
        System.out.println("------------------------");
    }

    /**
     * 产生长度为100000的随机数组
     */
    public static int[] randomArray() {
        int[] arr = new int[100000];
        for (int i = 0; i < arr.length; i++) {
            //随机产生数据
            arr[i] = (int) (Math.random() * 100000);
        }
        return arr;
    }

    /**
     * 算法开始时时间
     */
    public static void startTime() {
        //开始时间
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String start = simpleDateFormat.format(date1);
        System.out.println("开始时间为：" + start);
    }

    /**
     * 算法结束时时间
     */
    public static void endTime() {
        //结束时间
        Date date2 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String end = simpleDateFormat.format(date2);
        System.out.println("结束时间为：" + end);
    }

    /**
     * 冒泡排序
     * O(n^2)
     * @param arr
     */
    public static void bubbleSort(int[] arr) {
        //临时变量
        int temp = 0;
        //标志
        boolean flag = false;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //如果逆序，交换位置
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            //无逆序，跳出循环
            if (!flag) {
                break;
            } else {
                flag = false;
            }
        }
    }
}

选择排序

SelectSort.java
package com.Taking.sort;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * Demo class
 * 选择排序
 *
 * @author Taking
 * @date 2020/5/20
 */
public class SelectSort {
    public static void main(String[] args) {
        System.out.println("------------------------");
        System.out.println("*******选择排序算法*******");
        startTime();
        selectSort(randomArray());
        endTime();
        System.out.println("------------------------");
    }

    /**
     * 产生长度为100000的随机数组
     */
    public static int[] randomArray() {
        int[] arr = new int[100000];
        for (int i = 0; i < arr.length; i++) {
            //随机产生数据
            arr[i] = (int) (Math.random() * 100000);
        }
        return arr;
    }

    /**
     * 算法开始时时间
     */
    public static void startTime() {
        //开始时间
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String start = simpleDateFormat.format(date1);
        System.out.println("开始时间为：" + start);
    }

    /**
     * 算法结束时时间
     */
    public static void endTime() {
        //结束时间
        Date date2 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String end = simpleDateFormat.format(date2);
        System.out.println("结束时间为：" + end);
    }

    /**
     * 选择排序
     * O(n^2)
     * @param arr
     */
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            //假设最小值的坐标为i
            int minIndex = i;
            //假设最小值为arr[i]
            int min = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                //若arr[j]小于min，则把下标赋值给minIndex，把值赋给min
                if (min > arr[j]) {
                    minIndex = j;
                    min = arr[j];
                }
            }
            //一趟比较结束，交换位置，确定最小数的位置
            arr[minIndex] = arr[i];
            arr[i] = min;
        }
    }
}

插入排序

InsertSort.java
package com.Taking.sort;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * Demo class
 * 插入排序
 *
 * @author Taking
 * @date 2020/5/20
 */
public class InsertSort {
    public static void main(String[] args) {
        System.out.println("------------------------");
        System.out.println("*******插入排序算法*******");
        startTime();
        insertSort(randomArray());
        endTime();
        System.out.println("------------------------");
    }

    /**
     * 产生长度为100000的随机数组
     */
    public static int[] randomArray() {
        int[] arr = new int[100000];
        for (int i = 0; i < arr.length; i++) {
            //随机产生数据
            arr[i] = (int) (Math.random() * 100000);
        }
        return arr;
    }

    /**
     * 算法开始时时间
     */
    public static void startTime() {
        //开始时间
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String start = simpleDateFormat.format(date1);
        System.out.println("开始时间为：" + start);
    }

    /**
     * 算法结束时时间
     */
    public static void endTime() {
        //结束时间
        Date date2 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String end = simpleDateFormat.format(date2);
        System.out.println("结束时间为：" + end);
    }

    /**
     * 插入排序
     * O(n^2)
     * @param arr
     */
    public static void insertSort(int[] arr) {
        // 定义待插入的变量，插入位置的索引
        int insertVal = 0;
        int insertIndex = 0;
        for(int i=0;i<arr.length-1;i++){
            //待插入的数赋值
            insertVal = arr[i+1];
            //与待插入的位置的数进行比较
            insertIndex = i;
            //进行判断：索引越界或者找到位置，跳出循环
            while(insertIndex>=0 && insertVal<arr[insertIndex]){
                arr[insertIndex+1] = arr[insertIndex];
                insertIndex--;
            }
            if(insertIndex+1 != i){
                arr[insertIndex+1] = insertVal;
            }
        }
    }
}

希尔排序

ShellSort.java
package com.Taking.sort;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * Demo class
 * 希尔排序
 * 
 * @author Taking
 * @date 2020/5/21
 */
public class ShellSort {
    public static void main(String[] args) {
        shellSort(randomArray());
        shellSort2(randomArray());
    }

    /**
     * 产生长度为100000的随机数组
     */
    public static int[] randomArray() {
        int[] arr = new int[100000];
        for (int i = 0; i < arr.length; i++) {
            //随机产生数据
            arr[i] = (int) (Math.random() * 100000);
        }
        return arr;
    }

    /**
     * 算法开始时时间
     */
    public static void startTime() {
        //开始时间
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String start = simpleDateFormat.format(date1);
        System.out.println("开始时间为：" + start);
    }

    /**
     * 算法结束时时间
     */
    public static void endTime() {
        //结束时间
        Date date2 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String end = simpleDateFormat.format(date2);
        System.out.println("结束时间为：" + end);
    }

    /**
     * 希尔排序
     * O(n^2*log(n))
     * @param arr
     */
    public static void shellSort(int[] arr) {
        System.out.println("------------------------");
        System.out.println("*******希尔排序算法(交换)*******");
        startTime();
        //临时变量
        int temp = 0;
        int count = 0;
        for(int gap = arr.length/2 ; gap>0 ; gap/=2){
            for(int i=gap; i<arr.length ; i++){
                for(int j=i-gap;j>=0;j-=gap){
                    if(arr[j]>arr[j+gap]){
                        temp = arr[j];
                        arr[j] =arr[j+gap];
                        arr[j+gap] = temp;
                    }
                }
            }
        }
        endTime();
        System.out.println("------------------------");
    }

    /**
     * 希尔排序
     * O(n*log(n))
     * @param arr
     */
    public static void shellSort2(int[] arr) {
        System.out.println("------------------------");
        System.out.println("*******希尔排序算法(移位)*******");
        startTime();
        //临时变量
        int temp=0;
        //分组
        for(int gap=arr.length/2;gap>0;gap/=2){
            for(int i=gap;i<arr.length;i++){
                int j=i;
                temp = arr[j];
                if(arr[j-gap]>arr[j]){

                    while(j-gap>=0 && temp < arr[j-gap]){
                        arr[j] = arr[j-gap];
                        j-=gap;
                    }
                    arr[j]=temp;
                }
            }
        }
        endTime();
        System.out.println("------------------------");
    }
}

快速排序

QuickSort.java
package com.Taking.sort;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * Demo class
 * 快速排序
 * 
 * @author Taking
 * @date 2020/5/21
 */
public class QuickSort {
    public static void main(String[] args) {
        System.out.println("------------------------");
        System.out.println("*******快速排序算法*******");
        startTime();
        quickSort(randomArray(), 0, randomArray().length - 1);
        endTime();
        System.out.println("------------------------");
    }

    /**
     * 产生长度为100000的随机数组
     */
    public static int[] randomArray() {
        int[] arr = new int[100000];
        for (int i = 0; i < arr.length; i++) {
            //随机产生数据
            arr[i] = (int) (Math.random() * 100000);
        }
        return arr;
    }

    /**
     * 算法开始时时间
     */
    public static void startTime() {
        //开始时间
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String start = simpleDateFormat.format(date1);
        System.out.println("开始时间为：" + start);
    }

    /**
     * 算法结束时时间
     */
    public static void endTime() {
        //结束时间
        Date date2 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String end = simpleDateFormat.format(date2);
        System.out.println("结束时间为：" + end);
    }

    /**
     * 快速排序
     * O(n^log(n))
     * @param arr
     * @param left
     * @param right
     */
    public static void quickSort(int[] arr, int left, int right) {
        //定义两个索引
        int l = left;
        int r = right;
        //中值赋值给pivot
        int pivot = arr[(left + right) / 2];
        int temp = pivot;
        while (l < r) {
            //中轴左边的数值小于中轴值，则右移，大于中轴值，跳出循环
            while (arr[l] < pivot) {
                l++;
            }
            //中轴右边的数值大于中轴值，则左移，小于中轴值，跳出循环
            while (arr[r] > pivot) {
                r--;
            }
            //将左边比中轴值大的数与右边比中轴值小的数交换位置
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            //如果l>=r跳出循环
            if (l >= r) {
                break;
            }
            //如果左边存在等于中轴值的数，则r左移
            if (arr[l] == pivot) {
                r--;
            }
            //如果右边存在等于中轴值的数，则l右移
            if (arr[r] == pivot) {
                l++;
            }
        }
        //防止栈溢出
        if (l == r) {
            l++;
            r--;
        }
        //向左递归
        if (left < r) {
            quickSort(arr, left, r);
        }
        //向右递归
        if (right > l) {
            quickSort(arr, l, right);
        }
    }

}

归并排序

MergeSort.java
package com.Taking.sort;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * Demo class
 * 归并排序
 * 
 * @author Taking
 * @date 2020/5/21
 */
public class MergeSort {
    public static void main(String[] args) {
        System.out.println("------------------------");
        System.out.println("*******归并排序算法*******");
        startTime();
        mergeSort(randomArray(),0,randomArray().length-1,new int[randomArray().length]);
        endTime();
        System.out.println("------------------------");
    }

    /**
     * 产生长度为100000的随机数组
     */
    public static int[] randomArray() {
        int[] arr = new int[100000];
        for (int i = 0; i < arr.length; i++) {
            //随机产生数据
            arr[i] = (int) (Math.random() * 100000);
        }
        return arr;
    }

    /**
     * 算法开始时时间
     */
    public static void startTime() {
        //开始时间
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String start = simpleDateFormat.format(date1);
        System.out.println("开始时间为：" + start);
    }

    /**
     * 算法结束时时间
     */
    public static void endTime() {
        //结束时间
        Date date2 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String end = simpleDateFormat.format(date2);
        System.out.println("结束时间为：" + end);
    }

    /**
     * 归并排序
     * O(n^log(n))
     * @param arr
     * @param left
     * @param right
     * @param temp
     */
    public static void mergeSort(int[] arr,int left,int right,int[] temp) {
        if(left<right){
            //确定中值索引
            int mid = (left+right)/2;
            //左递归
            mergeSort(arr,left,mid,temp);
            //右递归
            mergeSort(arr,mid+1,right,temp);
            //合并
            merge(arr,left,mid,right,temp);
        }
    }

    /**
     * 合并过程
     * @param arr
     * @param left
     * @param mid
     * @param right
     * @param temp  临时数组
     */
    public static void merge(int[] arr,int left,int mid,int right,int[] temp){
        //分成左右两组
        //左索引
        int i=left;
        //右索引
        int j=mid+1;
        //临时数组索引
        int t = 0;
        //比较左右两组数的大小
        while(i<=mid && j<=right){
            //如果左边小，存入临时数组，左索引右移，临时数组索引右移
            if(arr[i]<=arr[j]){
                temp[t] = arr[i];
                t++;
                i++;
            }else{
                //如果右边小，存入临时数组，右索引右移，临时数组索引右移
                temp[t] = arr[j];
                t++;
                j++;
            }
        }
        //如果右组都已存入临时数组，则将左组剩下的值依次存入临时数组
        while(i<=mid){
            temp[t] = arr[i];
            t++;
            i++;
        }
        //如果左组都已存入临时数组，则将右组剩下的值依次存入临时数组
        while(j<=right){
            temp[t] = arr[j];
            t++;
            j++;
        }
        //将临时数组置0，将临时数组的值赋值给原数组
        t=0;
        //定义原数组索引
        int tl = left;
        while(tl<=right){
            arr[tl] = temp[t];
            tl++;
            t++;
        }
    }
}

基数排序

RadixSort.java
package com.Taking.sort;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * Demo class
 * 基数排序
 * 
 * @author Taking
 * @date 2020/5/22
 */
public class RadixSort {
    public static void main(String[] args) {
        System.out.println("------------------------");
        System.out.println("*******基数排序算法*******");
        startTime();
        radixSort(randomArray());
        endTime();
        System.out.println("------------------------");
    }

    /**
     * 产生长度为100000的随机数组
     */
    public static int[] randomArray() {
        int[] arr = new int[100000];
        //若数组过大会出现：Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        for (int i = 0; i < arr.length; i++) {
            //随机产生数据
            arr[i] = (int) (Math.random() * 100000);
        }
        return arr;
    }

    /**
     * 算法开始时时间
     */
    public static void startTime() {
        //开始时间
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String start = simpleDateFormat.format(date1);
        System.out.println("开始时间为：" + start);
    }

    /**
     * 算法结束时时间
     */
    public static void endTime() {
        //结束时间
        Date date2 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String end = simpleDateFormat.format(date2);
        System.out.println("结束时间为：" + end);
    }

    /**
     * 基数排序
     * O(d(n+r))
     * @param arr
     */
    public static void radixSort(int[] arr) {
        //定义一个二维数组，[桶的个数，桶中存放的数据]
        int[][] bucket = new int[10][arr.length];
        //定义一个一维数组，用于计数存放某个桶中的元素个数
        int[] bucketElementCounts = new int[10];
        //确定元素中最高位
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        int length = (max + "").length();
        //有几位数，就循环几次
        for (int i = 0, n = 1; i < length; i++, n *= 10) {
            //确定相应位数值，并存放到对应桶中
            for (int j = 0; j < arr.length; j++) {
                int digitOfElement = arr[j] / n % 10;
                //存放桶中，然后计数+1
                bucket[digitOfElement][bucketElementCounts[digitOfElement]++] = arr[j];
            }
            //定义一个原数组的索引
            int index = 0;
            //遍历二维数组，按顺序存放到原数组
            for (int j = 0; j < bucket.length; j++) {
                if (bucketElementCounts[j] != 0) {
                    for (int k = 0; k < bucketElementCounts[j]; k++) {
                        arr[index++] = bucket[j][k];
                    }
                }
                //将每个桶的计数值清零，方便下一次计数
                bucketElementCounts[j] = 0;
            }
        }
    }
}

堆排序

HeapSort.java
package com.Taking.sort;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * Demo class
 * 堆排序
 * 
 * @author Taking
 * @date 2020/5/22
 */
public class HeapSort {
    public static void main(String[] args) {
        System.out.println("------------------------");
        System.out.println("*******堆排序算法*******");
        startTime();
        heapSort(randomArray());
        endTime();
        System.out.println("------------------------");
    }

    /**
     * 产生长度为100000的随机数组
     */
    public static int[] randomArray() {
        int[] arr = new int[100000];
        for (int i = 0; i < arr.length; i++) {
            //随机产生数据
            arr[i] = (int) (Math.random() * 100000);
        }
        return arr;
    }

    /**
     * 算法开始时时间
     */
    public static void startTime() {
        //开始时间
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String start = simpleDateFormat.format(date1);
        System.out.println("开始时间为：" + start);
    }

    /**
     * 算法结束时时间
     */
    public static void endTime() {
        //结束时间
        Date date2 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String end = simpleDateFormat.format(date2);
        System.out.println("结束时间为：" + end);
    }

    /**
     * 构造大顶堆
     *
     * @param arr
     * @param i
     * @param length
     */
    public static void constructLargeHeap(int[] arr, int i, int length) {
        //将非子叶点的值赋值给临时变量temp
        int temp = arr[i];
        //比较左右孩子节点大小，将值大的与其父节点比较
        //定义孩子节点索引k
        for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {
            //左孩子节点小于右孩子节点，将索引k右移
            if (k + 1 < length && arr[k] < arr[k + 1]) {
                k++;
            }
            //大于互换位置
            if (arr[k] > temp) {
                arr[i] = arr[k];
                i = k;
            } else {
                //小于则跳出循环
                break;
            }
            //将非叶子节点的值与最大值的值的位置交换
            arr[i] = temp;
        }
    }

    /**
     * 堆排序
     * O(n^log(n))
     * @param arr
     */
    public static void heapSort(int[] arr) {
        //定义临时变量
        int temp = 0;
        //构造大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            constructLargeHeap(arr, i, arr.length);
        }
        //将堆顶数与堆末尾的数进行交换，使得最大值在数组最后
        for (int j = arr.length - 1; j >= 0; j--) {
            temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            //交换完，再对最大值前面的子数组构造大顶堆
            constructLargeHeap(arr, 0, j);
        }
    }
}
算法速度测试(针对随机数组)
运行环境：Intel® Core™ i5-7300HQ CPU @ 2.50GHz 2.5GHz RAM:8.00GB
排序算法\数量级1000005000001000000500000010000000
冒泡排序20s400s1600s- -- -
选择排序5s96s400s- -- -
插入排序1s26s100s- -- -
希尔排序(交换|移位)12s~14s|<1s240s|1s913s|1s- -- -
快速排序<1s<1s<=1s1s2s
归并排序<1s<=1s<=1s1~2s2~3s
基数排序<1s<1s<=1s1s1s
堆排序<1s<1s<=1s1~2s3s
Taking1998
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Robsort Sorting Algorithm-开源
04-27
罗伯特（Robertsort）使用罗伯特·汤普森（Robert Thompson）开发的GNU公共许可证排序算法。 Robsort使用随机数生成对整数数组进行排序。 它被称为世界上效率最低的排序算法。
排序算法--SortingAlgorithm
Extraor
07-12 345
/// <summary> /// 排序算法 /// </summary> public class SortingAlgorithm { /// <summary> /// [01][稳定] 冒泡排序 /// 1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。 /// 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是...
DataStructuresAlgorithms之01-SortingAlgorithm排序算法
编程人生
07-07 149
Author: lyangly Date : 2021-07-07 09:57:51 Email : [email protected] Tags : 数据结构与算法，排序算法； 文章目录算法之排序1. 排序算法分类2. 排序算法复杂度3. 比较排序算法3.1 冒泡排序3.2 快速排序3.3 插入排序3.4 希尔排序3.5 简单选择排序3.6 堆排序3.7 归并排序4 非比较排序算法4.1 计数排序4.2 桶排序4.3 基数排序 算法之排序 1. 排序算法分类 比较类排序：通过比较来决定元素间的相对.
排序算法（Sorting algorithm）（一）
夏沫的杂物间
05-21 672
写在前面： 本文章旨在总结备份、方便以后查询，由于是个人总结，如有不对，欢迎指正；另外，内容大部分来自网络、书籍、和各类手册，如若侵权请告知，马上删帖致歉。 来源： https://zh.wikipedia.org/wiki/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95 https://github.com/hustcc/JS-Sorting-Algorithm https://www.cnblogs.com/sunshineliulu/category/11392.
排序算法 Sorting Algorithm（一）
JeffLee的博客
09-10 1208
练习下算法规范描述问题和伪代码表示 Input: sequence ⟨a1, a2, …, an⟩of numbers. Output: permutation ⟨a’1, a’2, …, a’n⟩Such that a’1≤a’2≤…≤a’n. Example: Input: 8 2 4 9 3 6 Output: 2 3 4 6 8 9 插入排...
Sorting Algorithm
weixin_30653097的博客
02-01 153
sorting 应该是最容易被考到的东西，自己老是学了背，背了忘。为了方便复习，这里进行总结 1. Bubble Sort 定义：每两个两个比较，每扫完一次，当前扫过的最大值放在了末尾。 for i = (n-1) to 1 for j = 0 to i-1 if(A[j] > A[j+1]) swap 　　...
Sorting-Algorithm-Comparison
03-29
Sorting-Algorithm-Comparison
Sorting-Algorithm-Visualization
03-26
排序算法可视化用Python进行的排序算法可视化用库制作排序算法的类型气泡排序待添加插入排序合并排序桶分类快速排序堆排序计数排序安装pygame pip install pygame运行程序只需运行visualization.py python ...
Sorting_Algorithm_Visualizer
02-14
排序算法可视化工具 描述 除了康威的生活游戏外，算法可视化器也是我一直想要创建的东西。 对于这个项目，我决定创建/可视化五个最常见的排序算法（气泡排序，插入排序，合并排序，快速排序和选择排序）。...
js-sorting-algorithm
07-09
javascript、sorting、algorithm
Sorting-Algorithm 排序算法
qq_43363200的博客
01-11 125
文章目录Bubble SortSelect SortInsert Sort Bubble Sort /* Bubble Sort */ #include <iostream> using namespace std; #define LEN 10 void bubbleSort(int *); int main() { int arr[LEN]; for (int i ...
Sorting Algorithm(2)
儒雅，勤思，博学
05-27 209
在轮子越来越多，越来方便调用的今天，基础算法的实现也被淡忘，虽然工作中不太需要自己造基础轮子，但其背后的思想对提高编程水平还是很有指导意义，特此记录。 创建随机数组 import numpy as np array = np.random.randint(0, 100, 1000) 冒泡排序 def bubble_sort(input_array): arr...
Sorting Algorithm-Heap Sort
Dufre
09-03 644
Heap Sort-堆排序 Algorithm： 堆排序就是利用堆（假设是大顶堆）进行排序的方法。它的基本思想是，将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根结点。将它移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素的次大值。如此反复执行，便能得到一个有序序列了。 Ex：大顶堆定义
关于排序算法的一点知识——实例和伪代码
热门推荐
RYP_S 的专栏
07-15 1万+
1.插入排序 将待排序的数据分成两个区域：有序区和无序区，每次将一个无序区中的数据按其大小插入到有序区中的适当位置，直到所有无序区中的数据都插入完成为止。
1306. Sorting Algorithm
[Q]4EchoNStef
12-14 845
1306. Sorting Algorithm Description One of the fundamental problems of computer science is ordering a list of items. There're a plethora of solutions to this problem, known as sorting algorithms.
linux sort 算法_十大算法排序(Sorting Algorithm) Study notes
weixin_36437103的博客
02-17 274
(自己手打的python实现代码以及整理的各路大神总结的知识点)自用学习笔记，由于基于北美cs学习，文章大量中英混杂(谨慎食用)十大排序算法:插入排序1)Insertion Sort 简单插入排序：2)Shell sort(希尔排序):突破n^2交换排序3)Bubble sort:两两比较4)Quicksort选择排序5)Selection Sort选择排序:选出最小的6)Heap sort (堆...
Sort algorithm 10
GeorgeDiDi的博客
02-11 1330
10个经典排序算法
sorting algorithm排序算法
Eric_918的专栏
12-25 546
<br /><br />Sorting algorithm排序算法<br />Sort() 对所有元素排序<br />Stable_sort() 对所有元素排序，并保持相等元素间的相对次序<br />Partial_sort() 排序，至到有N个元素就位<br />Partitial_sort_copy() 排序，至到有N个元素就位，结果复制于它处<br />Nth_element() 根据第N个位置进行排序<br />Partition() 改变元素次序，使符合某规则者移到前面<br />Stable_p
Develop a NetBeans application that illustrates the applicability of one sorting algorithm on a collection of 10 items. The algorithm should sort the items in descending order. The algorithm must work based on the principle of one of the four sorting algorithms studied during the semester. The collection of 10 items is defined and populated in the application code. You can decide the type and values of items stored in the collection. The algorithm must be implemented as part of a class called MyArrayList that extends the ArrayList class functionality with your sorting algorithm. [20 marks] 5. Extend the application implemented for Question 4 above to be able to measure the efficiency of the implemented sorting algorithm in term of number of comparisons performed by the algorithm. The application should display the total number of comparisons performed by the algorithm for a given collection of items. [10 marks] 6. In an Excel graph, plot the number of comparisons measured by the sorting algorithm when three different sizes of collection are considered. Submit your Excel file on Moodle. [20 marks]
最新发布
06-04
Additionally, you want me to extend the application to measure the efficiency of the implemented sorting algorithm in terms of the number of comparisons performed by the algorithm, and to plot the ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值