数组排序

最新推荐文章于 2024-08-24 22:01:16 发布
最新推荐文章于 2024-08-24 22:01:16 发布
阅读量142 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57073604/article/details/116541763
版权

数组

  • 数组的出现，是为了我们方便地去操作多个数据
  • 数组下标越界异常：ArrayIndexOutofBoundsExcetion
数组概念

  • 数组是存储同一种数据类型多个元素的集合，也可以看成是一个容器。

  • 数组既可以存储基本数据类型，也可以存储引用数据类型。

数组的定义格式：数据类型【】 数组名，数据类型 数组名【】

数组遍历

package com.xiao;

import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
            int[] arr = {10,20,30,40,50};
            //遍历数组
        // int length = arr.length;//获取数组的元素的个数
       // System.out.println(length);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }
}

反向遍历

package com.xiao;

public class Demo {
    public static void main(String[] args) {
        int[] arr = {10,20,30,40,50};
        for (int i = arr.length -1; i >= 0; i--) {
            System.out.print(arr[i]);

        }
    }
}

获取数组中的最大值或者最小值

package com.xiao;

public class Demo {
    public static void main(String[] args) {
        int[] arr={10,2,3,4,5,6};
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i]<max){
                max = arr[i]
            }
        }
        System.out.println(max);
    }
}

最小值

class de{
    public static void main(String[] args) {
        int[] arr={10,80,90,2,3,4,5};
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i]<max){
                max=arr[i];
            }
        }
        System.out.println("数组中的最xiao值是："+max);

    }
}

反转数组中的元素（收尾元素互调）

package com.xiao;

public class Demo09 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,2,2,2,3,44};
        for (int i = 0; i < arr.length/2; i++) {
            int t = arr[i];
            arr[i]=arr[arr.length-1-i];
            arr[arr.length-1-i] = t;
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

数组排序

冒泡排序

排序原理：数组元素量量比较，交换位置，大元素往后放，那么经过一轮比较后，最大的元素，就会出现在最大的索引处。

package com.xiao;

import java.util.Arrays;

public class Demo09 {
    public static void main(String[] args) {
        int[] arr = {24,69,80,57,13};
        for (int y = 0; y < 4; y++) {
            for (int i = 0; i < arr.length-1; i++) {
                if (arr[i] >arr[i+1]){
                    int t = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

选择排序

排序原理：从0索引处开始，依次和后面的元素进行比较，小的元素往前放，经过一轮比较厚，最小的元素就出现在了最小索引处

package com.xiao;

import java.util.Arrays;

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = {24,93,44,22,21};
        int x=0;
            for (int i = 0; i < arr.length; i++) {
                if (arr[x] >arr[i]){
                    int t = arr[x];
                    arr[x] = arr[i];
                    arr[i] = t;
                }
            }
        
        System.out.println(Arrays.toString(arr));
    }
}

插入排序

排序原理：算法思路：直接插入排序，是一种最简单的排序方法，他的基本操作是讲一个记录插入到一个长度为m的有序列表中，使之仍保持有序

package com.xiao;

import java.util.Arrays;

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = {3,2,1,0,10,20,30,5,4};
        for (int i = 1; i < arr.length; i++) {
            int j = i;
            while (j>0&&arr[j]<arr[j-1]){
                int t = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = t;
                j--;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

希尔排序

  • 希尔排序又称缩小增量排序

  • 基本思想：先将原标按增量ht分组，每个子文件按照直接插入法排序。同样，用下一个增量ht/2将文件再分成子文件，在直接插入法排序。知道ht=1时，整个文件排好序。

  • 关键：选择合适的增量。

  • 希尔排序算法9-3:可以通过三重循环来实现。

package com.xiao;

import java.util.Arrays;

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = {46,55,13,42,17,94,4,70};
        shellSort (arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void shellSort(int[] arr) {
        int h=4;

        for (int i = h;i < arr.length;i++){
         for (int j = i; j >h - 1; j-=h) {
             if (arr[j] < arr[j-h]){


                }
            }
        }
    }
    public static void swapValue(int[] arr,int i,int j){
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

快速排序

  • 分治法：比大小，再分区

1、从数组中取出一个数，作为基准数。

2、分区：将比这个数大或等于的数全放到她的右边，小雨他的数全放到左边

3、在对左右区间重复第二部，直到个区间只有一个数

  • 挖坑填数
  1. 将基数挖出行成第一个坑
  2. 由后向前找比他小的数，找到后挖出此数天到前一个坑中。
  3. 由前向后找比他大或者等于的数，找到后也挖出此数填到前一个坑中
  4. 再重复执行2，3辆步骤。
package com.xiao;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Demo03 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {10,3,5,6,1,0,100,40,50,8,-1,-3,-2};
        //调用工具类，进行快速排序，传入数组，传入其实位置，传入结束位置
        QuickSorUtils.quickSort(arr,0,arr.length-1);
        //输出排序后的结果
        System.out.println(Arrays.toString(arr));
    }
}


package com.xiao;

public class QuickSorUtils {
    public static void quickSort(int[] arr,int start,int end){
        //找出分左右两区的缩阴位置，然后对左右两区进行递归调用
        if (start<end){
            int index = getIndex(arr,start,end);
            quickSort(arr,start,index-1);
            quickSort(arr,index+1,end);
        }
    }
    //将基准数坑挖出形成第一个坑。
    //由后向钱找比他小的数，找到后挖出此数填到前一个坑中。
    //由前向后找比他大或者等于的数，找到后挖出此数填到前一个坑中。
    //再重复2，3步骤
    private static int getIndex(int[] arr, int start, int end) {
        int i =start;
        int j = end;
        int x= arr[i];
        while (i<j){
            while (i<j && arr[j] >= x){
                j--;
            }
            if (i<j){
                arr[i] = arr[j];
                i++;
            }

            //由前向后找比他大或者等于的数，找到后挖出此数填到前一个坑中。

            while (i<j && arr[i] < x){
                i++;
            }
            if (i<j){
                arr[j] = arr[i];
                i--;
            }
        }
        arr[i] = x;
        return i;
    }
}

归并排序

  • 归并排序（Merge Sort）就是李通归并的思想实现排序的方法。

  • 它的原理是假设初始化序列由n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n/2个长度为2或1的序子序列，再两两归并…如此重复，直至得到一个长度为n的有序序列位置，这种排序方法称为2路归并排序。

package com.xiao;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

import java.util.Arrays;

public class Demo04 {
    public static void main(String[] args) {
        //原始待排序数组
        int[] arr ={10,30,2,1,0,8,7,5,19,29};
        //我们先给一个左右两边是有序的一个数组，先来进行归并操作
       // int[] arr = {4,5,7,8,1,2,3,6};
        //拆分
            chaifen(arr,0,arr.length-1);


        //归并
      //  guibing(arr,0,3,arr.length-1);

        //输出原来数组
       System.out.println(Arrays.toString(arr));
    }

    private static void chaifen(int[] arr, int startIndex, int enIndex) {
        //计算中间索引
        int centerTndex=(startIndex+enIndex)/2;
        if (startIndex<enIndex){
            chaifen(arr,startIndex,centerTndex);
            chaifen(arr,centerTndex+1,enIndex);
            guibing(arr,startIndex,centerTndex,enIndex);
        }
    }

    private static void guibing(int[] arr, int startIndex, int centerIndex, int endIndex) {
        //定义一个临时数组
        int[] tempArr = new int[endIndex - startIndex +1];
        //定义左边数组的起始索引
        int i = startIndex;
        //定义右边数组的起始所有
        int j = centerIndex+1;
        //定义临时数组的起始索引
        int index = 0;
        //比较左右两个数组的元素大小，往临时数组中方
        while (i<=centerIndex && j<=endIndex){
            if (arr[i] <= arr[j]){
                tempArr[index] = arr[i];
                i++;
            }else {
                tempArr[index] = arr[j];
                j++;
            }
            index++;
        }
        //处理剩余元素
        while (i <= centerIndex){
            tempArr[index] = arr[i];
            i++;
            index++;
        }
        while (j <= endIndex){
            tempArr[index] = arr[j];
            j++;
            index++;
        }
      // System.out.println(Arrays.toString(arr));
        //将临时数组中的元素取到原数组中
        for (int i1 = 0; i1 < tempArr.length; i1++) {
            arr[i1+startIndex] = tempArr[i1];
        }
    }
}

基数排序

  • 基数排序不同于之前所介绍的各类排序。
  • 前边介绍的排序方法或多或少的是通过是使用比较和移动记录来实现排序。
  • 而基数排序的实现不需要进行对关键字的比较。
  • 只需要对关键字进行“分配”与“收集”两种操作即可完成。
package com.xiao;

import java.util.Arrays;

public class Demo05 {
    public static void main(String[] args) {
        //基数排序，通过分配在收集的方式进行排序
        int[] arr = {2,1,5,31,444,23,33,47,10,903,124,987,100};
        //群定排序轮次
        //获取数组中的最大值
        int max = getmax(arr);
        //基数排序
        sortArray(arr);

        //输出排序过后的数组
        System.out.println(Arrays.toString(arr));
    }

    private static void sortArray(int[] arr) {
        //定义二维数组，放10个桶
        int[][] tempArr = new int[10][arr.length];
        //定义统计数组
        int[] couts = new int[10];
        int max = getmax(arr);
        int len = String.valueOf(max).length();
        for (int i = 0,n=1;i < len; i++, n*=10) {
            for (int j = 0; j < arr.length; j++) {

                //获取每个位上的数字
                int ys = arr[j]/n%10;
                tempArr[ys][couts[ys]++] = arr[j];
            }
            //取出桶中的元素
            int index = 0;
            for (int k = 0; k < couts.length; k++) {
                if (couts[k] != 0){
                    for (int h = 0; h < couts[k]; h++) {
                        //从桶中取出元素放回原数组
                        arr[index] = tempArr[k][h];
                        index++;
                    }
                    couts[k] = 0;//清除上一次统计的个数
                }
            }
        }
    }

    private static int getmax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max){
                max = arr[i];
            }
        }
        return max;
    }
}

堆排序

  • 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序。
堆排序的基本思想是：
  1. 将待排序序列构成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。
  2. 将其与末尾元素进行交换，此时末尾就为最大值。
  3. 然后将剩余n-1元素重新构造成一个堆，这样会得到n个元素的次小值。
  4. 如此反复执行，便能得到一个有序序列。
package com.xiao;

import java.util.Arrays;

public class Demo06 {
    public static void main(String[] args) {
        // 定义一个数组
        int[] arr = {1,0,6,7,2,3,4};
        //调整成大顶堆的方法
        int startIndex = (arr.length -1)/2;
        //循环开始调
        for (int i = startIndex;i >= 0;i--){
            toMaxHeap(arr,arr.length,i);
        }
        System.out.println(Arrays.toString(arr));
        //经过上面的操作，已经把数组编程一个大顶堆，把跟元素和最后一个元素进行调换
        for (int i = arr.length-1;i>0;i--){
            //进行调换
            int t = arr[0];
            arr[0] = arr[i];
            arr[i] = t;
            //换完之后，我们再把剩余元素调成大顶堆
            toMaxHeap(arr,i,0);
        }
        System.out.println(Arrays.toString(arr));
    }



    //要排序的数组
    //调整的元素个数
    //从哪里开始调整
    private static void toMaxHeap(int[] arr, int size, int index) {
        //获取左右字节的索引
        int leftNodeIndex = index*2+1;
        int rightNodeIndex = index*2+2;
        //查找最大节点所对应的索引
        int maxIndex = index;
        if (leftNodeIndex < size&&arr[leftNodeIndex] > arr[maxIndex]){
            maxIndex = leftNodeIndex;
        }
        if (rightNodeIndex<size&&arr[rightNodeIndex]>arr[maxIndex]){
            maxIndex = rightNodeIndex;
        }
        //调换位置
        if (maxIndex != index){
            int t = arr[maxIndex];
            arr[maxIndex] = arr[index];
            arr[index] = t;
            //调换完之后，可能会影响到下面的子数，不是大顶堆，我们还需要再次调换
            toMaxHeap(arr,size,maxIndex);
        }
    }
}
期待aaaa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数组的排序
weixin_45122172的博客
09-20 177
数组的排序 （1）冒泡排序 （2）直接选择排序 冒泡排序 希望数组最终是{1,2,3,4,8}或{8,4,3,2,1}，现在要实现从小到大 通过相邻元素比较，如果相邻元素的顺序不符合要求，那么就交换。 经过几轮之后，实现最终的排序。每一轮都会有一个已经到达正确位置的元素退出比较。 例如：int[] arr = {4,2,1,8,3}; 希望数组最终是{1,2,3,4,8}或{8,4,3,2,1}，现在要实现从小到大 第一轮： 第1次：arr[0]和arr[1]比较，4和2比较，不符合要求，交换
数组的值大小排序
A31208的博客
03-23 2759
let values = [1,2,3,6,4,8]; //小到大排序,如果需要由大到小,把返回的-1和1反过来就可以了 let compare = (x,y) =&gt; { if(x &lt; y){ return -1 }else if(x &gt; y){ return 1; }else{ return 0; ...
JS使用递归简单实现--数组的全排列
weixin_42662753的博客
10-22 837
JS使用递归简单实现--数组的全排列
初学Numpy
JUST CODE IT
07-17 280
此博客用来记录刚开始学习numpy的一些基本语法 数组创建 有几种方法可以创建数组 例如，可以使用该array函数从常规的Python列表或者元组创建数组，数组的类型是从序列中元素的类型推导出来的 import numpy as np arr = np.array([2, 3, 4]) print(arr) # [2 3 4] print(arr.dtype) # int32 arr1...
最常用的数组排序方法
weixin_46185369的博客
11-21 511
整理了一下最常用的数组排序方法，话不多说，直接上代码 1、sort() 方法是最强大的数组方法之一 // 从小到大排序 let arr = [4,3,2,1,0] let newArr = arr.sort((a,b)=>a-b) console.log(newArr); // [0,1,2,3,4] // 从大到小排序 let arr = [0,1,2,3,4] let newArr = arr.sort((a,b)=>b-a) console.lo
易语言文本数组排序
08-16
在编程领域，数组排序是一个常见的任务，特别是在处理数据时。易语言是一种中文编程语言，它提供了丰富的库函数和结构来简化编程过程。本篇将详细讲解如何在易语言中实现文本数组的排序。 首先，我们需要了解易语言...
Perl基本数组排序方法介绍
09-21
### Perl基本数组排序方法介绍 #### 一、概述 Perl是一种功能强大的脚本语言，广泛应用于文本处理、系统管理及Web开发等领域。其中数组排序是Perl编程中的常见需求之一。本文将详细介绍Perl中基本数组排序的方法，...
C#实现对二维数组排序的方法
09-03
总结来说，本文介绍的C#实现二维数组排序的方法，通过将二维数组转换为`DataTable`并利用其内置的排序功能，提供了一种灵活且高效的解决方案。这种方法不仅适用于各种数据类型，而且保持了原始数组的引用，使得排序...
使用ＳＣＬ编写的数组排序程序
03-24
标题“使用SCl编写的数组排序程序”揭示了本文档的核心内容，即使用一种名为“SCl”的编程语言或库来实现数组的排序功能。SCl可能是一个特定的编程语言，或者是一个支持数组操作的软件工具。数组排序是计算机科学中...
易语言自定义数据类型数组排序
07-23
本话题聚焦于“易语言自定义数据类型数组排序”，将深入探讨如何在易语言中创建、操作自定义数据类型数组，并实现各种排序算法，如根据产地、类别和售价等属性进行排序。 自定义数据类型在易语言中允许我们定义包含...
数组从小到大排序
Zj_refuseDDL的博客
09-06 2431
利用一些简单的算法进行数组的一个排序
对数组元素排序 sort() 方法
新前端小白的博客
08-23 1371
sort() 方法 sort() 方法用于对数组的元素进行排序。 语法：arrayObject.sort(sortby) 返回值：对数组的引用。请注意，数组在原数组上进行排序，不生成副本。 如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序 var arr = new Array(6) arr[0] = "George" arr[1] = "John" arr[2] = "Tho...
用数组实现基准排序
lb891014的专栏
04-19 628
基准排序的 原理：以第i为基准，
数组排序sort()方法详解
老电影故事的博客
04-19 6043
sort() 方法用原地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的。 一、sort()方法基本介绍 1.语法 arr.sort([compareFunction]) 2.参数 compareFunction可选 用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。 a,b 两个将要被比较的元素。 如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列
定义一个方法，实现对一维数组的从小到大排序
热门推荐
Liyuan的博客
03-15 1万+
package task_3_9; /** * 定义一个方法，实现对一维数组的从小到大排序 * */ public class Task04 { public static void main(String[] args) { int[] arr = {3,5,55,2,666,39}; //调用排序方法 arrSort(arr); for(int e:arr) { ...
阿里云服务器 篇七：服务器热备份/定时备份
最新发布
生活在别处
08-24 52
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

期待aaaa

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

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

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

打赏作者

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

抵扣说明：

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

余额充值