数据结构之排序算法

于 2022-07-12 15:28:38 发布
阅读量69 收藏
点赞数
分类专栏： Java 文章标签： 排序算法 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xz_4321/article/details/125661133
版权

排序分为内部排序，外部排序。
内部排序分为：
冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，基数排序。

外部排序：主要是内存+外部存储文件方式的排序

1.冒泡排序

冒泡排序基本思想：通过对待排序序列从前往后，从下标0开始依次比较相邻元素的大小，如果是从小到大排序，则将较大值放在后面，即较大值放在索引较大的元素位置，反之如果是从大到小排序，将较大值放在索引较小的元素位置即可。

package Sort;

import javax.jws.soap.SOAPBinding;
import java.lang.reflect.Array;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

/**
 * @auther SQ
 */
public class bubbleSort {
    public static void main(String[] args) {

        //int arr[] = {3, 9, -1, 10, 20};
        //System.out.println("原本数组：" + Arrays.toString(arr));
        // 冒泡排序  时间复杂度 O(n*n)
        // 冒泡排序的优化
        int num = 80000;
        int arr[] = new int[num];
        for (int i = 0; i < num; i++) {
            arr[i] = (int) (Math.random() * num); //记得加上括号
        }

        Date date = new Date();
        SimpleDateFormat sd = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");
        String sTime = sd.format(date);
        System.out.println("开始时间：" + sTime);

        // 冒泡排序
        BubbleSort(arr);

        Date date1 = new Date();
        String eTime = sd.format(date1);
        System.out.println("结束时间："+eTime);

    }


    public static void BubbleSort(int[] arr) {
        boolean flag = false;
        int temp = 0;
        int t = -1;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    t = i;
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
            //System.out.println("第" + (i + 1) + "趟排序后的数组");
            //System.out.println(Arrays.toString(arr));

            // 冒泡排序的优化
            if (!flag) { // 如果内层循环没有执行过一次的话，就跳出该循环
                //System.out.printf("flag=%s,t=%d", flag, t);
                //System.out.println();
                break;
            } else {
                //System.out.printf("flag=%s,t=%d", flag, t);
                //System.out.println();
                flag = false;
            }
        }

    }
}


开始时间：2022-07-07 15:59:39
结束时间：2022-07-07 15:59:52

2.选择排序

选择排序基本思路：
在一组数中选择最小的放在第一个位置，在剩下的元素中在选择最小的放在第二个位置，直到遍历完成。

package Sort;

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

/**
 * @auther SQ
 */
@SuppressWarnings("all")
public class SelectSort {
    public static void main(String[] args) {
        //int arr[] = {101, 34, 119, 1};
        int num = 80000;
        int arr[] = new int[num];
        for (int i = 0; i < num; i++) {
            arr[i] =(int) (Math.random() * num);
        }

        //System.out.println("排序前=" + Arrays.toString(arr));
        Date date = new Date();
        SimpleDateFormat sd = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");
        String sTime = sd.format(date);
        System.out.println("开始时间：" + sTime);

        //选择排序
        selectsort(arr);

        Date date1 = new Date();
        String eTime = sd.format(date1);
        System.out.println("结束时间："+eTime);
    }


    public static void selectsort(int[] arr) {
        // 选择排序
        for (int i = 0; i < arr.length; i++) {
            // 假定第一个为最小值
            int min = arr[i];
            int minIndex = i;

            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {
                    min = arr[j];
                    minIndex = j;
                }
            }
            arr[minIndex] = arr[i];
            arr[i] = min;
            //System.out.println("第" + (i + 1) + "轮排序" + Arrays.toString(arr));
        }
    }
}


开始时间：2022-07-07 16:05:28
结束时间：2022-07-07 16:05:33

3.插入排序

插入排序的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始有序表只含有一个元素，无序表中有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它跟有序表的第一个元素比较，比较之后如果大于有序表的第一个元素，将其放置在有序表的后面位置，无序表减1，使之成为新的有序表。（从小向后排列）

package Sort;

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

/**
 * @auther SQ
 */
@SuppressWarnings("all")
public class InsertSort {
    public static void main(String[] args) {
        int num = 80000;
        int arr[] = new int[num];
        for (int i = 0; i < num; i++) {
            arr[i] =(int) (Math.random() * num);
        }

        //System.out.println("排序前=" + Arrays.toString(arr));
        Date date = new Date();
        SimpleDateFormat sd = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");
        String sTime = sd.format(date);
        System.out.println("开始时间：" + sTime);

        //选择排序
        insertsort(arr);

        Date date1 = new Date();
        String eTime = sd.format(date1);
        System.out.println("结束时间："+eTime);
    }


    public static void insertsort(int[] arr) {
        //插入排序
        for (int i = 0; i < arr.length - 1; i++) {
            int insertVal = arr[i + 1];
            int insertIndex = i;

            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex]; // 大的值向后移一位
                insertIndex--;
            }
            arr[insertIndex + 1] = insertVal;
        }

    }
}


开始时间：2022-07-07 17:25:23
结束时间：2022-07-07 17:25:24

4. 快速排序

package Sort;

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

/**
 * @auther SQ
 */
public class quickSort {
    public static void main(String[] args) {
       // int[] arr = {1, 5, -1, -3, 0, 2, -9, 20, -100};

        //        //System.out.println((int) Math.floor(5 / 2.0));
//        shellsort(arr);
//        System.out.println("排序后="+Arrays.toString(arr));

        int num = 8000000;
        int arr[] = new int[num];
        for (int i = 0; i < num; i++) {
            arr[i] =(int) (Math.random() * num);
        }

        //System.out.println("排序前=" + Arrays.toString(arr));
        Date date = new Date();
        SimpleDateFormat sd = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");
        String sTime = sd.format(date);
        System.out.println("开始时间：" + sTime);

        //选择排序
        quicksort(arr, 0, arr.length - 1);
        //System.out.println(Arrays.toString(arr));

        Date date1 = new Date();
        String eTime = sd.format(date1);
        System.out.println("结束时间：" + eTime);



    }


    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 = 0; //临时变量，作为交换时使用
        //while循环的目的是让比pivot 值小放到左边
        //比pivot 值大放到右边
        while( l < r) {
            //在pivot的左边一直找,找到大于等于pivot值,才退出
            while( arr[l] < pivot) {
                l += 1;
            }
            //在pivot的右边一直找,找到小于等于pivot值,才退出
            while(arr[r] > pivot) {
                r -= 1;
            }
            //如果l >= r说明pivot 的左右两的值，已经按照左边全部是
            //小于等于pivot值，右边全部是大于等于pivot值
            if( l >= r) {
                break;
            }

            //交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;

            //如果交换完后，发现这个arr[l] == pivot值 相等 r--， 前移
            if(arr[l] == pivot) {
                r -= 1;
            }
            //如果交换完后，发现这个arr[r] == pivot值 相等 l++， 后移
            if(arr[r] == pivot) {
                l += 1;
            }
        }

        // 如果 l == r, 必须l++, r--, 否则为出现栈溢出
        if (l == r) {
            l += 1;
            r -= 1;
        }
        //向左递归
        if(left < r) {
            quicksort(arr, left, r);
        }
        //向右递归
        if(right > l) {
            quicksort(arr, l, right);
        }
    }
}

排序算法对比

算法执行时间时间复杂度算法思路比较
冒泡排序大约13sO(n*n)外层循环执行n次，内层循环也执行n次，且内层两两元素比较
选择排序大约4sO(n*n)外层循环执行n次，内层循环执行n-1次，且找到最值内层寻找结束
插入排序大约1sO(n*n)外层循环执行n次，内层循环进行无序表中取出的元素，与有序列表进行对比
xz_4321
关注
专栏目录
排序——最全的七大排序算法知识汇总
ZhangHahaaha的博客
05-10 528
目录概念什么是排序稳定性排序的分类总览1.插入排序直接插入排序原理代码实现性能分析折半插入排序希尔排序原理代码实现性能分析2.选择排序直接选择排序原理代码实现性能分析堆排序原理代码实现性能分析3.交换排序冒泡排序原理代码实现性能分析快速排序（重要）原理代码实现性能分析4.归并排序归并排序原理代码实现性能分析5.排序总结 概念 排序：一串记录，按照其中的某个或者某些关键字的大小，递增或者递减排列起来的操作。通常意义上的排序都是指原地排序。 什么是排序稳定性 排序稳定性：两个相等的数据，如果经过排序后，排序算法
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
快速排序
puber~
05-30 232
package com.atguigu.sort; import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Date; public class QuickSort { public static void main(String[] args) { int[] arr = {-9,78,0,23,-567,70, -1,900, 4561}; quickSort(arr, 0,..
【JavaDS】排序——快排 & 归并
m0_56975154的博客
03-18 779
上接【JavaDS】排序——快速排序 快排的另一种 partition 方法 通过算法的设计将序列分成如图所示的三个区间 [ from, s ) 元素 <= pivot [ s, i ) 元素 >= pivot [ i, to ) 待比较元素 遍历 [ from, to ) 比较 ...
归并排序 以及面试题
我思故我在
10-22 169
归并排序时间复杂度：O（N*logN） 解法1：递归 思路：递归拆分每次分成两个，分到不能再分，分别排序有序然后再合并 /** * 归并排序 * @param arr */ public static void mergeSort1(int[] arr ){ //判断 是否需要排序 if(arr.length<2){ return; } proess(arr,0,arr.length-1); } /** * 递归分左右并且合并 * @para
归并排序&快速排序(Java)
chenyao的博客~
04-20 267
1.归并排序 1.1递推公式 归并排序分解图 递推公式： merge_sort(p…r) = merge(merge_sort(p…q), merge_sort(q+1…r)) 终止条件： p >= r 不用再继续分解 1.2代码实现 /** * 归并排序 * * @param value */ public static void mergeSort(int[] value) { mergeSort(value, 0, v
数据结构学习笔记排序算法：基数排序
最新发布
09-17
数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数...
数据结构课设排序算法的可视化演示（QT+C++）
12-06
数据结构是计算机科学中的核心课程...总的来说，"数据结构课设排序算法的可视化演示（QT+C++）"是一个综合性的项目，它涵盖了数据结构、算法、编程和可视化等多个方面，对于提升计算机科学学生的综合素质具有重要意义。
数据结构值排序算法.zip
01-15
排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法，分支限界...
java 快排
Kong的博客
04-19 372
通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则分别对这两部分继续进行排序，直到整个序列有序。 　　把整个序列看做一个数组，把第零个位置看做中轴，和最后一个比，如果比它小交换，比它大不做任何处理；交换
java快排
cloud_m的博客
03-14 351
 import java.util.Scanner; public class Demo1 {      public static void main(String args[]){       Scanner sc = new Scanner(System.in);       int k = sc.nextInt();       int[] arr1 = new int
Java 快排
jy123456_123的博客
06-22 1017
什么是快速排序？快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。算法原理单单看以上解释还是有些模糊，可以通过实例来理解它，下面通过一组数据来进行排序过程的解析：原数组：{3，7...
Java 快排
乐酱的博客
08-02 83
import java.util.Random; public class QuickSort { public static int partition(int[] arr, int low, int high) { int pivot = arr[low]; while (low < high) { while (low < high && arr[high] >= pivot) {
Java快排
caitou3562的博客
06-04 226
思路： 挖坑填数，原理视频链接 public static void quickSort(int[] data, int start, int end) { if (data == null || start >= end) return; int i = start, j = end; //左边第一元素做界点，左边有坑 int pivotKey = data[start]; while (i < j) { //左边有坑，
快排实现
baidu_39458769的博客
10-23 370
public static void quickSort(int[] arr, int left, int right) { //如果数组只有一个元素，就不用排序了，直接返回 if (left &gt;= right) return; int[] index = partion(arr, left, right); ...
java之快排
weixin_44491898的博客
03-12 400
快速排序的基本思想： 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则分别对这两部分继续进行排序，直到整个序列有序。 　　把整个序列看做一个数组，把第零个位置看做中轴，和最后一个比，如果比它小交换，比它大不做任何处理；交换了以后再和小的那端比，比它小不交换，比他大交换。这样循环往复，一趟排序完成，左边就是比中轴小的，右边就是比中轴大的，然后再用分治法，分别...
Java实现数据结构与排序算法精要
"本书以Java语言为背景，深入讲解数据结构和排序算法，内容精炼，适合学习或复习。书中涵盖了线性表、栈、队列以及多种排序算法，如选择排序、堆排序、冒泡排序、快速排序、插入排序、Shell排序、归并排序、桶式排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值