排序＜数组洗牌/升序降序EX冒泡排序示例

乘风破浪的

已于 2022-10-24 11:29:24 修改

阅读量196

点赞数

分类专栏：数组文章标签： java 算法数据结构 1024程序员节

于 2022-10-23 23:11:08 首次发布

本文链接：https://blog.csdn.net/Zzhu0417/article/details/127480414

版权

数组专栏收录该内容

6 篇文章 0 订阅

订阅专栏

这个博客展示了如何在Java中进行数组操作，包括使用Random生成随机数填充数组，实现升序、降序排序以及洗牌（乱序）算法。示例代码分别使用了内置排序、冒泡排序以及随机交换元素的方法来实现各种排序效果。

摘要由CSDN通过智能技术生成

数组洗牌：

程序输出：数组元素成员/最大值/最小值/乱序洗牌

import java.util.Arrays;
import java.util.Random;
//排序
public class Arr3 {
    //   数组洗牌
    public static void main(String[] args) {
//        声明数组 及成员个数
        int[] nums=new int[7];
//        声明随机对象
        Random rand=  new Random();
//        给数组赋值随机整数并敲定范围
        for(int i =0;i<nums.length;i++){
            nums[i] =rand.nextInt(1,49);
        }
//        使用Arrays工具类，输出数组
//        System.out.println(nums);
        System.out.println(Arrays.toString(nums));
        System.out.println("----------------------------------");
//        求数组元素的最大值
        int max =nums[0];
        for (int i = 1;i < nums.length;i++){
        if(max<nums[i]){
            max=nums[i];
        }
        }
        System.out.printf("数组：%s中，最大值：%d.%n",Arrays.toString(nums),max);
//        求数组元素的最小值
        int min =nums[0];
        for (int i = 1;i >nums.length;i++){
        if(min>nums[i]){
            min=nums[i];
        }
        }
        System.out.printf("数组：%s中，最小值：%d。%n",Arrays.toString(nums),min);
//        乱序（洗牌算法）
        for (int i = 0;i<nums.length*10;i++) {
        int a = rand.nextInt(nums.length);
        int b = rand.nextInt(nums.length);
        if (a==b){
            i--;
            continue;
        }
        //        交换数组
            int t=nums[a];
            nums[a]=nums[b];
            nums[b]=t;
        }
        System.out.printf("洗牌：%s%n",Arrays.toString(nums));
            System.out.println("----------------------------------");

    }
}

升序降序：

排序前/内置排序/排序升序/排序降序/排序洗牌乱序

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

//排序
public class ArrSort {
//    升序降序
    public static void main(String[] args) {
/*
        Integer integer1 = new Integer(100);   以 int 型变量作为参数创建 Integer 对象
        Integer integer2 = new Integer("100"); 以 String 型变量作为参数创建 Integer 对象
*/
        Integer[] integ =new Integer[7];
        Random rand =new Random();
        for (int i = 0; i < integ.length; i++) {
            integ[i]=rand.nextInt(1,51);
        }
        System.out.printf("排序前：%s%n", Arrays.toString(integ));
        System.out.println("------------------------------------");
//        升序（内置排序机制：默认升序，可以排任何内容）
        Arrays.sort(integ);
        System.out.printf("升序排序后：%s%n", Arrays.toString(integ));
        System.out.println("------------------------------------");
//        使用排序接口；lambda 表达式，可以灵活排序，但必须是泛型对象数组
        Arrays.sort(integ,(a,b) -> a-b);
        System.out.printf("升序排序后：%s%n", Arrays.toString(integ));
        System.out.println("------------------------------------");
//        降序
        Arrays.sort(integ,(a,b) -> b-a);
        System.out.printf("降序排序后：%s%n", Arrays.toString(integ));
        System.out.println("------------------------------------");
//        洗牌
        Arrays.sort(integ,(a,b) -> Math.random()> .5 ? 1:-1);
        System.out.printf("洗牌乱序排序后：%s%n", Arrays.toString(integ));
    }
}

冒泡排序案例：

冒泡排序/冒泡排序/冒泡降序/冒泡洗牌乱序

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

//升序降序
public class EX {
    //    冒泡排序
    public static void main(String[] args) {
        int[] n = new int[7];
        Random rand = new Random();
        for (int i = 0; i < n.length; i++) {
            n[i] = rand.nextInt(1, 51);
        }
        System.out.printf("排序前：%s%n", Arrays.toString(n));
//        冒泡升序
        for (int i = 0; i < n.length; i++) {
            for (int j = 0; j < n.length - i - 1; j++) {
                //            数据交换
                if (n[j] > n[j + 1]) {
                    int temp = n[j];
                    n[j] = n[j + 1];
                    n[j + 1] = temp;
                }
            }
        }
        System.out.printf("冒泡升序为：%s%n", Arrays.toString(n));
//        冒泡降序
        for (int i = 0; i < n.length; i++) {
            for (int j = 0; j < n.length - i - 1; j++) {
                //            数据交换
                if (n[j] < n[j + 1]) {
                    int temp = n[j];
                    n[j] = n[j + 1];
                    n[j + 1] = temp;
                }
            }
        }
        System.out.printf("冒泡降序为：%s%n", Arrays.toString(n));
//        乱序洗牌
        for (int i = 0; i < n.length * n.length; i++) {
            int a = rand.nextInt(n.length);
            int b = rand.nextInt(n.length);
            if (a == b) {
                --i;
                continue;
            }
            int temp = n[a];
            n[a] = n[b];
            n[b] = temp;
        }
        System.out.printf("冒泡乱序排序：%s%n", Arrays.toString(n));
    }
}