排序算法设计与实现

已于 2023-05-03 09:48:58 修改
阅读量244 收藏 1
点赞数
文章标签： 数据结构 算法 java
于 2023-05-02 20:14:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/INGNIGHT/article/details/130466483
版权

目录

1.选择排序

2.快速排序

3.归并排序

4.插入排序

5.堆排序

6.冒泡排序

7.希尔排序

1.选择排序

public class SelectionSort {

    private SelectionSort(){}

    public static <E extends Comparable> void sort(E[] arr){

        for(int i = 0; i < arr.length; i ++){

            // 选择 arr[i...n) 中的最小值
            int minIndex = i;
            for(int j = i; j < arr.length; j ++){
                if(arr[j].compareTo(arr[minIndex]) < 0)
                    minIndex = j;
            }

            swap(arr, i, minIndex);
        }
    }

    private static <E> void swap(E[] arr, int i, int j){

        E t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

2.快速排序

import java.util.Arrays;
import java.util.Random;

public class QuickSort {

    private QuickSort(){}

    public static <E extends Comparable<E>> void sort(E[] arr){

        Random rnd = new Random();
        sort(arr, 0, arr.length - 1, rnd);
    }

    private static <E extends Comparable<E>> void sort(E[] arr, int l, int r, Random rnd){

        if(l >= r) return;

        int p = partition(arr, l, r, rnd);
        sort(arr, l, p - 1, rnd);
        sort(arr, p + 1, r, rnd);
    }

    private static <E extends Comparable<E>> int partition(E[] arr, int l, int r, Random rnd){

        // 生成 [l, r] 之间的随机索引
        int p = l + rnd.nextInt(r - l + 1);
        swap(arr, l, p);

        // arr[l+1...j] < v ; arr[j+1...i] >= v
        int j = l;
        for(int i = l + 1; i <= r; i ++)
            if(arr[i].compareTo(arr[l]) < 0){
                j ++;
                swap(arr, i, j);
            }

        swap(arr, l, j);
        return j;
    }

    public static <E extends Comparable<E>> void sort2ways(E[] arr){

        Random rnd = new Random();
        sort2ways(arr, 0, arr.length - 1, rnd);
    }

    private static <E extends Comparable<E>> void sort2ways(E[] arr, int l, int r, Random rnd){

        if(l >= r) return;

        int p = partition2ways(arr, l, r, rnd);
        sort2ways(arr, l, p - 1, rnd);
        sort2ways(arr, p + 1, r, rnd);
    }

    private static <E extends Comparable<E>> int partition2ways(E[] arr, int l, int r, Random rnd){

        // 生成 [l, r] 之间的随机索引
        int p = l + rnd.nextInt(r - l + 1);
        swap(arr, l, p);

        // arr[l+1...i-1] <= v; arr[j+1...r] >= v
        int i = l + 1, j = r;
        while(true){

            while(i <= j && arr[i].compareTo(arr[l]) < 0)
                i ++;

            while(j >= i && arr[j].compareTo(arr[l]) > 0)
                j --;

            if(i >= j) break;

            swap(arr, i, j);

            i ++;
            j --;
        }

        swap(arr, l, j);
        return j;
    }

    public static <E extends Comparable<E>> void sort3ways(E[] arr){

        Random rnd = new Random();
        sort3ways(arr, 0, arr.length - 1, rnd);
    }

    private static <E extends Comparable<E>> void sort3ways(E[] arr, int l, int r, Random rnd){

        if(l >= r) return;


        /** 三路快速排序的 partition 过程 **/

        // 生成 [l, r] 之间的随机索引
        int p = l + rnd.nextInt(r - l + 1);
        swap(arr, l, p);

        // arr[l + 1, lt] < v, arr[lt + 1, i - 1] == v, arr[gt, r] > v
        int lt = l, i = l + 1, gt = r + 1;
        while(i < gt){

            if(arr[i].compareTo(arr[l]) < 0){
                lt ++;
                swap(arr, i, lt);
                i ++;
            }
            else if(arr[i].compareTo(arr[l]) > 0){
                gt --;
                swap(arr, i, gt);
            }
            else{ // arr[i] == v
                i ++;
            }
        }

        swap(arr, l, lt);

        /** 三路快速排序的 partition 过程结束 **/

        // 递归调用
        sort3ways(arr, l, lt - 1, rnd);
        sort3ways(arr, gt, r, rnd);
    }

    private static <E> void swap(E[] arr, int i, int j){

        E t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    public static void main(String[] args){

        int n = 1000000;

        Integer[] arr = ArrayGenerator.generateRandomArray(n, n);
        Integer[] arr2 = Arrays.copyOf(arr, arr.length);
        Integer[] arr3 = Arrays.copyOf(arr, arr.length);

        System.out.println("Random Array");
        SortingHelper.sortTest("QuickSort", arr);
        SortingHelper.sortTest("QuickSort2Ways", arr2);
        SortingHelper.sortTest("QuickSort3Ways", arr3);
        System.out.println();


        arr = ArrayGenerator.generateOrderedArray(n);
        arr2 = Arrays.copyOf(arr, arr.length);
        arr3 = Arrays.copyOf(arr, arr.length);

        System.out.println("Ordered Array");
        SortingHelper.sortTest("QuickSort", arr);
        SortingHelper.sortTest("QuickSort2Ways", arr2);
        SortingHelper.sortTest("QuickSort3Ways", arr3);
        System.out.println();


        arr = ArrayGenerator.generateRandomArray(n, 1);
        arr2 = Arrays.copyOf(arr, arr.length);
        arr3 = Arrays.copyOf(arr, arr.length);

        System.out.println("Same Value Array");
//        SortingHelper.sortTest("QuickSort", arr);
        SortingHelper.sortTest("QuickSort2Ways", arr2);
        SortingHelper.sortTest("QuickSort3Ways", arr3);
        System.out.println();
    }
}

3.归并排序

import java.util.Arrays;


public class MergeSort {

    private MergeSort(){}

    public static <E extends Comparable> void sort(E[] arr){

        E[] temp = Arrays.copyOf(arr, arr.length);
        sort(arr, 0, arr.length - 1, temp);
    }

    private static <E extends Comparable> void sort(E[] arr, int l, int r, E[] temp){

        if (l >= r) return;

        int mid = l + (r - l) / 2;
        sort(arr, l, mid, temp);
        sort(arr, mid + 1, r, temp);

        if(arr[mid].compareTo(arr[mid + 1]) > 0)
            merge(arr, l, mid, r, temp);
    }

    public static <E extends Comparable> void sortBU(E[] arr){

        E[] temp = Arrays.copyOf(arr, arr.length);

        int n = arr.length;

        // 使用插入排序优化
        // 遍历一遍，对所有 arr[i, i + 15] 的区间，使用插入排序法
        for(int i = 0; i < n; i += 16)
            InsertionSort.sort(arr, i, Math.min(n - 1, i + 15));

        // 遍历合并的区间长度
        // 注意，sz 从 16 开始
        for(int sz = 16; sz < n; sz += sz){

            // 遍历合并的两个区间的起始位置 i
            // 合并 [i, i + sz - 1] 和 [i + sz, i + sz + sz - 1]
            for(int i = 0; i + sz < n; i += sz + sz)
                if(arr[i + sz - 1].compareTo(arr[i + sz]) > 0)
                    merge(arr, i, i + sz - 1, Math.min(i + sz + sz - 1, n - 1), temp);
        }
    }

    private static <E extends Comparable> void merge(E[] arr, int l, int mid, int r, E[] aux){

        System.arraycopy(arr, l, aux, l, r - l + 1);

        int i = l, j = mid + 1;

        // 每轮循环为 arr[k] 赋值
        for(int k = l; k <= r; k ++){

            if(i > mid){
                arr[k] = aux[j]; j ++;
            }
            else if(j > r){
                arr[k] = aux[i]; i ++;
            }
            else if(aux[i].compareTo(aux[j]) <= 0){
                arr[k] = aux[i]; i ++;
            }
            else{
                arr[k] = aux[j]; j ++;
            }
        }
    }

    public static void main(String[] args){

        int n = 10000000;

        Integer[] arr = ArrayGenerator.generateRandomArray(n, n);
        Integer[] arr2 = Arrays.copyOf(arr, arr.length);

        SortingHelper.sortTest("MergeSort", arr);
        SortingHelper.sortTest("MergeSortBU", arr2);
    }
}

4.插入排序

import java.util.Arrays;

public class InsertionSort {

    private InsertionSort(){}

    public static <E extends Comparable<E>> void sort(E[] arr){

        for(int i = 0; i < arr.length; i ++){

            // 将 arr[i] 插入到合适的位置
            E t = arr[i];
            int j;
            for(j = i; j - 1 >= 0 && t.compareTo(arr[j - 1]) < 0; j --){
                arr[j] = arr[j - 1];
            }
            arr[j] = t;
        }
    }

    public static <E extends Comparable<E>> void sort(E[] arr, int l, int r){

        for(int i = l; i <= r; i ++){

            // 将 arr[i] 插入到合适的位置
            E t = arr[i];
            int j;
            for(j = i; j - 1 >= l && t.compareTo(arr[j - 1]) < 0; j --){
                arr[j] = arr[j - 1];
            }
            arr[j] = t;
        }
    }
}

5.堆排序

​
import java.util.Arrays;


public class HeapSort {

    private HeapSort(){}

    public static <E extends Comparable<E>> void sort(E[] data){

        if(data.length <= 1) return;

        for(int i = (data.length - 2) / 2 ; i >= 0 ; i --)
            siftDown(data, i, data.length);

        for(int i = data.length - 1; i >= 0; i --){
            swap(data, 0, i);
            siftDown(data, 0, i);
        }
    }

    // 对 data[0, n) 所形成的最大堆中，索引 k 的元素，执行 siftDown
    private static <E extends Comparable<E>>void siftDown(E[] data, int k, int n){

        while(2 * k + 1 < n){
            int j = 2 * k + 1; // 在此轮循环中,data[k]和data[j]交换位置
            if( j + 1 < n && data[j + 1].compareTo(data[j]) > 0 )
                j ++;
            // data[j] 是 leftChild 和 rightChild 中的最大值

            if(data[k].compareTo(data[j]) >= 0 )
                break;

            swap(data, k, j);
            k = j;
        }
    }

    private static <E> void swap(E[] arr, int i, int j){

        E t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    public static void main(String[] args) {

        int n = 1000000;

        Integer[] arr = ArrayGenerator.generateRandomArray(n, n);
        Integer[] arr2 = Arrays.copyOf(arr, arr.length);
        Integer[] arr3 = Arrays.copyOf(arr, arr.length);
        Integer[] arr4 = Arrays.copyOf(arr, arr.length);
        Integer[] arr5 = Arrays.copyOf(arr, arr.length);

        SortingHelper.sortTest("MergeSort", arr);
        SortingHelper.sortTest("QuickSort2Ways", arr2);
        SortingHelper.sortTest("QuickSort3Ways", arr3);
        SortingHelper.sortTest("HeapSort", arr4);
    }
}

​

6.冒泡排序

import java.util.Arrays;

public class BubbleSort {

    private BubbleSort(){}

    public static <E extends Comparable<E>> void sort(E[] data){

        for(int i = 0; i + 1 < data.length; i ++){

            // arr[0, i) 已排好序
            // 通过冒泡在 arr[i] 位置放上合适的元素
            for(int j = data.length - 1; j > i; j --)
                if(data[j - 1].compareTo(data[j]) > 0)
                    swap(data, j - 1, j);
        }
    }

    public static <E extends Comparable<E>> void sort2(E[] data){

        for(int i = 0; i + 1 < data.length; i ++){

            // arr[0, i) 已排好序
            // 通过冒泡在 arr[i] 位置放上合适的元素
            boolean isSwapped = false;
            for(int j = data.length - 1; j > i; j --)
                if(data[j - 1].compareTo(data[j]) > 0){
                    swap(data, j - 1, j);
                    isSwapped = true;
                }

            if(!isSwapped) break;
        }
    }

    public static <E extends Comparable<E>> void sort3(E[] data){

        for(int i = 0; i + 1 < data.length; ){

            // arr[0, i) 已排好序
            // 通过冒泡在 arr[i] 位置放上合适的元素
            int lastSwappedIndex = data.length - 1;
            for(int j = data.length - 1; j > i; j --)
                if(data[j - 1].compareTo(data[j]) > 0){
                    swap(data, j - 1, j);
                    lastSwappedIndex = j - 1;
                }

            i = lastSwappedIndex + 1;
        }
    }

    private static <E> void swap(E[] arr, int i, int j){

        E t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    public static void main(String[] args) {

        int n = 100000;

        Integer[] arr = ArrayGenerator.generateRandomArray(n, n);
        Integer[] arr2 = Arrays.copyOf(arr, arr.length);
        Integer[] arr3 = Arrays.copyOf(arr, arr.length);

        System.out.println("Random Array");
        SortingHelper.sortTest("BubbleSort", arr);
        SortingHelper.sortTest("BubbleSort2", arr2);
        SortingHelper.sortTest("BubbleSort3", arr3);
        System.out.println();


        arr = ArrayGenerator.generateOrderedArray(n);
        arr2 = Arrays.copyOf(arr, arr.length);
        arr3 = Arrays.copyOf(arr, arr.length);

        System.out.println("Ordered Array");
        SortingHelper.sortTest("BubbleSort", arr);
        SortingHelper.sortTest("BubbleSort2", arr2);
        SortingHelper.sortTest("BubbleSort3", arr3);
    }
}

7.希尔排序

import java.util.Arrays;

public class ShellSort {

    private ShellSort(){}

    public static <E extends Comparable<E>> void sort(E[] data){

        int h = data.length / 2;
        while(h >= 1){

            for(int i = h; i < data.length; i ++){
                E t = data[i];
                int j;
                for(j = i; j - h >= 0 && t.compareTo(data[j - h]) < 0; j -= h)
                    data[j] = data[j - h];
                data[j] = t;
            }

            h /= 2;
        }
    }

    public static void main(String[] args) {

        int n = 1000000;

        Integer[] arr = ArrayGenerator.generateRandomArray(n, n);
        Integer[] arr2 = Arrays.copyOf(arr, arr.length);

        SortingHelper.sortTest("ShellSort", arr);
        SortingHelper.sortTest("MergeSort", arr2);
    }
}

 

INGNIGHT
关注
数据结构之报告排序设计
10-02
数据结构之报告排序设计
排序算法设计
laocooon的博客
03-29 840
//作者:文道 Q523857886 #define _CRT_SECURE_NO_WARNINGS #include <iostream> using namespace std; //7种排序 void insert(int a[],int n); void shel(int a[], int n); void select(int a[], int n); void bubble(int a[], int n); void quick(int a[], int lo...
经典排序算法的设计与实现
FanBrother的博客
12-21 1414
理解技巧： 代码中遇到while(){}循环时，先考虑跳过循环的情况（即不满足判断条件的情况），以达到简化代码的目的。这样反而能帮助理解while(){}循环的作用。关注变量在程序中是否发生变化（或者说有没有被赋值）：没有发生，则说明此变量是用来保存重要数据的；发生了，则留心发生了几次变化，分别在哪行执行的。使用索引是为了遍历。%取最后一位的数字，/取第一位上的数字。
查找与排序算法的设计和实现（实现插入、选择等各种排序算法）
weixin_52416700的博客
12-19 1492
主要运用： 1．在顺序表上进行顺序查找及在有序顺序表上进行二分查找的算法。 2．二叉排序树的定义和有关操作，理解对二叉排序树进行操作的递归算法； 3．各种排序算法思想、时间和空间复杂度分析，能根据实际需要选择合适的排序方法。 实现功能： 1、实现顺序表的顺序查找和二分查找或建立一个二叉排序树并进行查找操作。 2、实现插入、选择等各种排序算 主要代码： #include <iostream> #include <malloc.h> using namespace
排序算法分析与设计
大学摄影爱好者
07-31 491
        1.我们在实际的数据查询和搜索应用中，当寻找最小数或者最大数，或者中间的第K小的数时，首先的问题是对这个杂乱的数据进行排序，然后就可以快速定位到需要搜寻到的具体的数。那么怎么排序，如何进行快速的排序，是本文的研究和分析重点。其中我们从时间复杂度和空间复杂度进行推理和证明。       2.1首先映入眼帘的是插入排序：其排序的思想和方法实现较之前学习的冒泡和选择排序更加的容易理解...
快速排序算法设计与实现.zip
最新发布
07-28
快速排序算法设计与实现
基于python的归并排序算法设计与实现
05-28
基于python的归并排序算法设计与实现
基于python的希尔排序算法设计与实现
05-28
基于python的希尔排序算法设计与实现
基于python的快速排序算法设计与实现
05-28
基于python的快速排序算法设计与实现
基于python的选择排序算法设计与实现
05-28
基于python的选择排序算法设计与实现
快速排序算法的设计与实现
ZiQqing的博客
08-12 279
#include<iostream> using namespace std; void quickSort(int array[],int low,int high){ int pivot,p_pos,i,t; if(low<high){ p_pos=low; pivot=array[p_pos];//将第1个设置为枢纽 for(i=low+1;i<=high;i++){ if(array[i]<pivot){//判断排序顺序，该顺序为由小到大
排序算法和实现
weixin_30770783的博客
11-05 86
最近在看排序算法，看着写着吧，代码是用的c++，我运行没有问题，有问题的话请指正。 一、快速排序 基本思想就是，先选择队列中的一个数，比它小的在左边，比它大的在右边，然后再对它左右的序列递归排序。 代码解释：swap用来交换2个数，Partion用来随机选择一个位置，其左边的数都小于它，右边的数都大于它，并返回这个数的位置，quickSort用来递归排序。 Partion：先用随机数选择个...
排序算法_快速排序（算法设计与C代码实现）
Lanyan9的博客
02-10 644
快速排序算法 快速排序算法简单来说就是在用一种“二分”的思想去挪数字，先找一个数，然后所有比它大的数放其右边，所有比它小的数放其左边，重复此过程直到排序完成。 目录快速排序算法一、问题描述二、问题分析三、代码实现四、运行结果五、算法解析六、BUG记录 一、问题描述        将一个数组中的数字进行排序处理，并返回一个排好序的新数组。 二、问题分析 算法：排序算法_快速排序 步骤： （1）需要先找一个数作为基准数，那么这个基准数如何设定
快速排序与冒泡排序算法的设计与实现
qq_38669394的博客
05-11 465
大家可以先建个项目，运行一下下面的代码，看一下效果。 快速排序算法 package com.handofgod; public class QuickSource { public static void quick_sort(int [] arr, int s, int length) { if (s < length) ...
排序算法的实现
Cecilia3333的博客
05-27 246
冒泡排序重复的走访过要排序的数列。一次比较两个元素，如果他们的顺序错误，就把他们交换过来。走访数列的工作是重复的进行，直到没有再需要交换的元素，即该序列已经排序完成。                            void Swap(int* a,int* b){ int tmp = *a; *a = *b; *b = tmp; } void BubbleSort...
交换排序算法的设计与实现——冒泡排序
qq_45015192的博客
05-05 178
@TOC交换排序算法的设计与实现——冒泡排序 输入：第一行是待排序数据元素的个数； 第二行是待排序的数据元素。 输出：第一行输出第一趟冒泡排序的结果。 ———————————————————— #include<stdio.h> int main(){ int a[1000]; int n,i,temp; scanf("%d",&n); for(i=0;i<n;i++){...
1014: 交换排序算法的设计与实现——冒泡排序
chen10151015的博客
05-12 390
题目描述 编程实现冒泡排序，按照非递减排序，测试数据为整数。 输入 第一行是待排序数据元素的个数； 第二行是待排序的数据元素。 输出 第一行输出第一趟冒泡排序的结果。 样例输入 10 50 36 41 19 23 4 20 18 12 22 样例输出 36 41 19 23 4 20 18 12 22 50 #include<stdio.h> #include<malloc.h> #define MaxSize 1000 #include<iostream> usin
排序算法原理及实现
Swayzzu的博客
08-29 248
稳定性： 例：原序列中假设（3,1）和（3,7）的顺序是（3,1）（3,7），如果排完序，这两个顺序没变，还是（3,1）（3,7），就说明是稳定的，如果变了，就说明不稳定。 冒泡排序方法：从第一个数开始，每次只对比两个数，如果后面的比前面的小则交换位置，否则不换位置，拿较大的数继续往后比对，一直跑到最后。 两种循环实现冒泡排序： 选择排序方法：第一步从序列中选出最小的和第一个换位置；第二步从剩余的数中选出最小的和第二个换位置；依次进行。（不稳定：升序，选择最大的数的时候会不稳定。） .
有向图拓扑排序算法设计与实现
"这篇文档是关于大数据结构课程设计的一个项目，重点是实现有向图的拓扑排序算法。作者通过VC++编程环境，利用邻接表来存储有向无环图（DAG），并设计了相应的算法进行拓扑排序，以解决依赖关系中的执行顺序问题。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值