Java数组练习冒泡排序

已于 2022-08-17 11:53:49 修改
阅读量1.8k 收藏 15
点赞数 5
文章标签： java 算法 数据结构
于 2022-08-11 19:27:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52459644/article/details/126291453
版权

1、有10个数字要求分别用选择法和冒泡法从大到小输出

选择法：

public class Task011 {

    public static void main(String[] args) {
        /*
        * 有10个数字要求分别用选择法和冒泡法从大到小输出
        * */
        //先用选择发从大到小输出
        //初始化一个长度为10的数组
        int[] array = {10,32,53,54,65,7,76,43,34,88};

        for (int i=0;i<array.length;i++){
            //假设第一个数为最大值
             int max = array[i];
             int a = i; //记录下标
            for (int j=i;j< array.length;j++){
                if (array[j]>max){
                    max = array[j];
                    a = j;
                }
            }
            System.out.print(max+" ");
            int temp = array[i];
            array[i] = array[a];
            array[a] = temp;
        }
        System.out.println();
    }
}

冒泡法：

public class Task012 {

    public static void main(String[] args) {
        /*
        * 有10个数字要求分别用选择法和冒泡法从大到小输出
        * */
        //用选择发从大到小输出
        //初始化一个长度为10的数组
        int[] array = {10,32,53,54,65,7,76,43,34,88};

        for (int i=0;i<array.length-1;i++){
            for (int j=0;j<array.length-1-i;j++){
                if (array[j]<array[j+1]){
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }

        //输出数组
        for (int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

}

2、求一个3*3矩阵对角线元素之和

<提示>程序分析：利用双重for循环控制输入二维数组，再将a[i][i]累加后输出。

public class Task02 {

    public static void main(String[] args) {
        /*
        *   求一个3*3矩阵对角线元素之和
        * <提示>程序分析：利用双重for循环控制输入二维数组，再将a[i][i]累加后输出。
        * */

        //创建一个Scanner类对象
        Scanner sc = new Scanner(System.in);
        //创建一个3*3的二维数组
        int[][] array = new int[3][3];

        //用户输入数据
        for (int i=0;i< array.length;i++){
            System.out.println("------------请输入第"+(i+1)+"行数据------------");
            for (int j=0;j<array[i].length;j++){
                System.out.println("第"+(j+1)+"个");
                array[i][j] = sc.nextInt();
            }
        }
        //输出二维数组且三行三列，并且获取对角线的数
        //获取的数进行相加
        int nums = 0;
        for (int i=0;i<array.length;i++){
            for (int j=0;j< array.length;j++){
                if (i==j||i+j==2){
                    nums += array[i][j];
                }
                System.out.print(array[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("对角线累加之和为："+nums);
    }
}

3、有一个已经按升序排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。

<提示>程序分析：首先判断此数第一次小于数组中哪个元素，然后将此数插入，插入后此元素之后的数，依次后移一个位置。

public class Task03 {

    public static void main(String[] args) {
        /*
        * 有一个已经按升序排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
        * <提示>程序分析：首先判断此数第一次小于数组中哪个元素，然后将此数插入，插入后此元素之后的数，依次后移一个位置。
        * */

        //创建一个Scanner类对象
        Scanner sc = new Scanner(System.in);

        //创建一个已经升序好的数组并输出
        int[] array = {11,23,54,64,75,89,93,99};
        System.out.println(Arrays.toString(array));

        //首先创建一个比原来的大一的数组，并将元素赋值到新的数组中
        int[] newArray = Arrays.copyOf(array,array.length+1);

        //用户输入要插入数组中的数字
        System.out.println("请输入你要插入的数字：");
        int insertNum = sc.nextInt();

        //获取要插入位置的下标值
        int getLocation = newArray.length-1;
        for (int i=0;i<newArray.length;i++){
            if (insertNum<newArray[i]){
                getLocation = i;
                break;
            }
        }

        //将获取下标后面的值依次往后移（注意：要从后向前移动）
        for (int i=newArray.length-1;i>getLocation;i--){
            newArray[i] = newArray[i-1];
        }

        //最后将要插入的值赋予对应的位置并输出
        newArray[getLocation] = insertNum;
        System.out.println(Arrays.toString(newArray));

    }

}

4、输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

public class Task04 {

    public static void main(String[] args) {
        /*
        * 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
        * */

        //创建一个Scanner类对象
        Scanner sc = new Scanner(System.in);

        //创建一个数组
        int[] array = new int[6];
        //输入数组的值
        for (int i=0;i< array.length;i++){
            //用户输入值
            System.out.println("请输入数组的值：");
            array[i] = sc.nextInt();
        }
        //交换前的数组为
        System.out.println("输出交换前的数组：");
        System.out.println(Arrays.toString(array));

        //获取最大值，先假设第一个数为最大值
        int max = array[0];
        int subscriptMax = 0; //记录下标
        for (int i=1;i<array.length;i++){
            if (array[i]>max){
                max = array[i];
                subscriptMax = i;
            }
        }

        //最大值与第一个交换
        array[subscriptMax] = array[0];
        array[0] = max;

        //获取最小值，先假设第一个数为最小值
        int min = array[0];
        int subscriptMin = 0; //记录下标
        for (int i=1;i< array.length;i++){
            if (array[i]<min) {
                min = array[i];
                subscriptMin = i;
            }
        }

        //最小值与最后一个数交换
        array[subscriptMin] = array[array.length-1];
        array[array.length-1] = min;

        //输出交换后的数组
        System.out.println("输出交换后的数组：");
        System.out.println(Arrays.toString(array));
    }
}

5、有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数

public class Task05 {

    public static void main(String[] args) {
        /*
        * 有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
        * */

        //创建一个Scanner类对象
        Scanner sc = new Scanner(System.in);
        //获取用户有几个整数
        System.out.println("请输入有几个整数：");
        int n = sc.nextInt();
        System.out.println("请输入你要向后移动多少位置：");
        int m = sc.nextInt();
        //创建一个数组来存储这n个整数
        int[] array = new int[n];

        //初始化数组
        for (int i=0;i< array.length;i++){
            System.out.println("请输入第"+(i+1)+"个整数:");
            array[i] = sc.nextInt();
        }
        //输出移动前的数组
        System.out.println("移动前的数组：");
        System.out.println(Arrays.toString(array));

        //移动数组
        for (int i=1;i<=m;i++){    //外层循环代表移动几个
            int temp = array[array.length-1];
            for (int j= array.length-1;j>=0;j--){    //内层循环来移动一个
                if (j==0){
                    array[j] = temp;
                }else {
                    array[j] = array[j-1];
                }
            }
        }

        //输出移动后的数组
        System.out.println("移动后的数组：");
        System.out.println(Arrays.toString(array));

    }

}

6、定义一个4行4列的二维数组，逐个从键盘输入值，然后将第1行和第4行的数据进行交换，将第2行和第3行的数据进行交换

public class Task06 {

    public static void main(String[] args) {
        /*
        * 定义一个4行4列的二维数组，逐个从键盘输入值，然后将第1行和第4行的数据进行交换，将第2行和第3行的数据进行交换
        * */
        //创建一个Scanner类对象
        Scanner sc = new Scanner(System.in);
        //声明一个4行4列的二维数组并赋值
        int[][] array = new int[4][4];
        for (int i=0;i<array.length;i++){
            System.out.println("--------------请输入第"+(i+1)+"行数据--------------");
            for (int j=0;j< array[i].length;j++){
                System.out.println("第"+(i+1)+"行，第"+(j+1)+"个数:");
                array[i][j] = sc.nextInt();
            }
        }
        //输出交换前的数组
        System.out.println("交换前的数组:");
        for (int i=0;i<array.length;i++){
            for (int j=0;j< array.length;j++){
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }

        //交换数据
        for (int i=0;i< array.length/2;i++){
            for (int j=0;j< array[i].length;j++){
                int temp = array[i][j];
                array[i][j] = array[3-i][j];
                array[3-i][j] = temp;
            }
        }

        //输出交换后的数组
        System.out.println("交换后的数组:");
        for (int i=0;i<array.length;i++){
            for (int j=0;j< array.length;j++){
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }

    }

}

7、定义一个4行4列的二维数组，逐个从键盘输入值，将对角线的值清0

public class Task07 {

    public static void main(String[] args) {
        /*
        * 定义一个4行4列的二维数组，逐个从键盘输入值，将对角线的值清0
        * */
        //创建一个Scanner类对象
        Scanner sc = new Scanner(System.in);
        //声明一个4行4列的二维数组并赋值
        int[][] array = new int[4][4];
        for (int i=0;i<array.length;i++){
            System.out.println("--------------请输入第"+(i+1)+"行数据--------------");
            for (int j=0;j< array[i].length;j++){
                System.out.println("第"+(i+1)+"行，第"+(j+1)+"个数:");
                array[i][j] = sc.nextInt();
            }
        }

        //输出最初的数组
        System.out.println("最初的数组:");
        for (int i=0;i<array.length;i++){
            for (int j=0;j< array[i].length;j++){
                System.out.print(array[i][j]+"\t");
            }
            System.out.println();
        }

        //清理数据
        for (int i=0;i< array.length;i++){
            for (int j=0;j< array[i].length;j++){
                if (i==j||i+j==3){
                    array[i][j] = 0;
                }
            }
        }

        //输出清理后的数组
        System.out.println("清理后的数组:");
        for (int i=0;i<array.length;i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + "\t");
            }
            System.out.println();
        }

    }

}

8、定义一个N*N二维数组，从键盘上输入值，找出每行中最大值组成一个一维数组并输出；

public class Task08 {

    public static void main(String[] args) {
        /*
        * 定义一个N*N二维数组，从键盘上输入值，找出每行中最大值组成一个一维数组并输出；
        * */

        //创建一个Scanner类对象
        Scanner sc = new Scanner(System.in);
        //请输入你n*n的数组n为多少
        System.out.println("请输入你n*n的数组n为多少:");
        int n = sc.nextInt();
        //声明一个n行n列的二维数组并赋值
        int[][] array = new int[n][n];
        for (int i=0;i<array.length;i++){
            System.out.println("--------------请输入第"+(i+1)+"行数据--------------");
            for (int j=0;j< array[i].length;j++){
                System.out.println("第"+(i+1)+"行，第"+(j+1)+"个数:");
                array[i][j] = sc.nextInt();
            }
        }

        //输出最初的数组
        System.out.println("最初的数组:");
        for (int i=0;i<array.length;i++){
            for (int j=0;j< array[i].length;j++){
                System.out.print(array[i][j]+"\t");
            }
            System.out.println();
        }

        //声明一个数组用来存储每一行取出来的最大值
        int[] maxArray = new int[n];
        for (int i=0;i< array.length;i++){
            //假设每一行的第一个数为最大值
            int max = array[i][0];
            for (int j=0;j< array[i].length;j++){
                if (array[i][j]>max){
                    max = array[i][j];
                }
            }
            maxArray[i] = max;
        }

        //输出取出的最大值
        System.out.println("每一行的最大值为：");
        System.out.println(Arrays.toString(maxArray));
    }
}

BoyFriend1005
关注
  • 5
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
采用冒泡排序法将10个整数按照从小到大的顺序排列.java
02-28
采用冒泡排序法将10个整数按照从小到大的顺序排列.java
JAVA：从键盘连续接收10个数，然后从大到小进行排序
weixin_58545658的博客
05-05 3801
JAVA：从键盘连续接收10个数，然后从大到小进行排序
JAVA使用冒泡排序法，对录入的10个整数按由小到大的顺序排序。
dmhacherlee的博客
02-08 6084
使用冒泡排序法，对录入的10个整数按由小到大的顺序排序。
C语言：创建一个含有10个元素的数组，乱序输入元素后升序输出（冒泡排序）（vs）
m0_74131264的博客
10-29 2336
学习“冒泡排序”
java题目内容：创建一维数组存放10个整数，对数组元素按照从大到小排序，并将排序结果输出。
l5j12138的博客
03-23 3090
10个整型数据，用空格隔开。按照从大到小的顺序输出。
c语言从键盘输入十个整数，冒泡法从大到小排序
wlj_czy的博客
11-01 1万+
#include <studio.h> int main(){ int i,j,t,a[10]; printf(“请输入十个整数”); for(i=0;i<10;i++) { scanf(“%d”,&a[i]);} for(i=0;i<10;i++){ for(j=i+1;j<10;j++){ if(a[i]<a[j]){ t=a[i];
[Java]输入10个整数，按照从小到大进行排序 [冒泡排序]
热门推荐
茂利的漫长生活
05-13 1万+
import java.util.Scanner; //输入10个整数，按照从小到大进行排序 public class HomeWork01 { public static void main(String[] args) { // 获取键盘数值 Scanner s = new Scanner(System.in); // 创建一个长度为10的整型数组 int array[] = new int[5]; // for循环输入数组 for (int i = 0; i <.
java冒泡排序
zhanghaiqi626的博客
08-19 861
冒泡排序
运用冒泡法将10个整数进行升序排序
weixin_45789625的博客
03-18 5441
#include <stdio.h> int main() { int i, j, t, a[10]; printf("\nInput 10 number :\n"); for (i = 0; i < 10; i++) scanf_s("%d",&a[i]); //输入需排序的5个数放在数组a中 for (i = 0; i < 9; i++) /* ...
用java实现编程：产生0~10的8个随机整数，并利用冒泡排序法将其升序排序后输出
ChengX1202的博客
10-21 2065
java练习：产生0~10的8个随机整数，并利用冒泡排序法将其升序排序后输出（java程序语言设计课后习题5.5）
java实现数组冒泡排序
09-23
java实现数组从小到大排序，输出为数组。可以直接拿来用，注释清楚，可读性强，适用于基础练习，课堂作业等
java算法题数组从小到大冒泡排序
03-02
初级练习
[Java算法-排序]冒泡排序.java
09-07
该资源包括实用练习，让读者可以练习在Java中实现冒泡排序，并提供解决方案以帮助读者检查自己的工作并深入理解所学内容。 无论您是Java编程的初学者还是有经验的程序员，该资源都将为您提供有价值的指导和支持，...
冒泡排序折半查找练习
05-10
产生2000个随机数，从小到大冒泡排序，折半查找，确定下标对应内容。
Java排序算法练习：1.快速排序 2.归并排序 3.插入排序 4.冒泡排序 5.选择排序 6.堆排序
08-08
idea项目：一个主类选择调用6个排序类，记录了学习排序算法的过程，可以自己更改优化,每一种排序是一个类，有需要可以copy走，可重用性强
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 1001
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 947
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Spring Cloud——LoadBalancer
最新发布
????
05-01 512
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 970
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
java冒泡排序算法练习
08-15
冒泡排序是一种简单的排序算法，它重复地遍历待排序的元素，比较相邻的两个元素，并按照大小进行交换，直到整个序列有序为止。以下是使用 Java 实现冒泡排序算法的示例代码： ```java public class BubbleSort { public static void main(String[] args) { int[] array = {5, 2, 8, 12, 1}; System.out.println("排序前的数组:"); printArray(array); bubbleSort(array); System.out.println("排序后的数组:"); printArray(array); } public static void bubbleSort(int[] array) { int n = array.length; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - i - 1; j++) { if (array[j] > array[j + 1]) { // 交换元素 int temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; } } } } public static void printArray(int[] array) { for (int i = 0; i < array.length; i++) { System.out.print(array[i] + " "); } System.out.println(); } } ``` 上述代码中，我们定义了一个 `bubbleSort` 方法来实现冒泡排序。通过双重循环遍历数组，比较相邻的两个元素，如果前一个元素比后一个元素大，则交换它们的位置。外层循环控制比较的轮数，内层循环控制每轮比较的次数。最终，数组会按照从小到大的顺序排序。运行代码后，会输出排序前和排序后的数组。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值