JavaDay15——数组——冒泡排序——选择排序

最新推荐文章于 2021-05-19 19:44:25 发布
最新推荐文章于 2021-05-19 19:44:25 发布
阅读量232 收藏
点赞数
分类专栏： 个人JAVA学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38057941/article/details/108308768
版权

1.数组

1.1.数组的基本知识：
  • 1.空间存储上，内存地址是连续的。
  • 2.每个元素占用的空间大小相同。
  • 3.首元素的内存地址即“数组的地址”。
  • 4.通过下标可以计算出偏移量。
  • 5.通过一个数学表达式，就可以快速计算出某个下标位置上元素的内存地址，直接通过内存地址定位，效率非常高。
1.2.数组的优、缺点
  • 优点：检索效率高。（条件：1、4、5）
  • 缺点：随机增删效率较低(注意，是随机！数组最后一个元素的增删效率不受影响。)
  • 数组无法存储大数据量。（因为很难在内存中找到一块很大的、地址连续的内存空间）
1.3.一维数组的静态初始化和动态初始化

静态初始化：

  •   int[] arr = {1,2,3,4};
  Object[] objs = {new Object(), new Object(), new Object()};

动态初始化：

  •   int[] arr = new int[4]; // 4个长度，每个元素默认值0
  Object[] objs = new Object[4]; // 4个长度，每个元素默认值null
1.4.二维数组：

静态初始化：

int[][] arr = { {1,2,34},
					{54,4,34,3},
					{2,34,4,5}
				};

Object[][] arr = { {new Object(),new Object()},
						 {new Object(),new Object()},
						 {new Object(),new Object(),new Object()}
						};
1.5.数组的copy—— System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length);

数组有一个特点长度一旦确定，不可变。
所以长度不够时，需要扩容，方法：新建一个大数组。
将小数组copy到大数组。

数组copy案例程序：

int[] a={1,2,3,4,5}——>int[] b=new int[10];
执行结果：
在这里插入图片描述

/**********数组copy******/
class ArrayCopy{
    public static void main(String[] args) {
       int[] a={1,2,3,4,5};
       //输出数组a
        System.out.print("小数组a：");
        for (int i=0;i< a.length;i++) {
            System.out.print(a[i]+",");
        }
        System.out.println();//换行
        
       int[] b=new int[10];
       System.arraycopy(a,0,b,0,a.length);
        //输出数组b
        System.out.print("大数组b：");
        for (int i=0;i< b.length;i++) {
            System.out.print(b[i]+",");
        }
    }
}
1.6.main方法——public static void main(String[] args) {}

main方法上“String[] args”参数的使用（非重点，了解一下，以后一般都是有界面的，用户可以在界面上输入用户名和密码等参数信息。）
用户输入的不同字符串之间用空格分开。

eg.用户传入用户名和密码：
  •   java  class文件名  zhangsan  12345678

2.冒泡排序算法

……………………

3.选择排序算法

选择排序比冒泡排序的效率高。
效率高在交换位置的次数上。
选择排序的交换位置是有意义的。

循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的值和
最前面的数据“交换位置”。每循环一次，参与比较的数就少一个。

4.Java项目——一维数组模拟栈数据结构——酒店管理系统

4.1.一维数组模拟栈数据结构

要求：

  •  1.这个栈可以存储java中任何引用类型的数据

  •  2.在栈中提供push方法模拟压栈，（栈满了，要有提示信息）

  •  3.在栈中提供pop方法弹栈（栈空了要有提示信息）

  •  4.编写测试程序，new栈对象，调用push、pop来模拟压栈、弹栈

程序：

public class AnalogData2 {
    public static int srcPos0=-1;
    public static void main(String[] args) {

        /***万能口袋Object**/
        StackOperation2 stack=new StackOperation2();
        stack.Mystack();/***初始化一维数组*/
        //stack.elements是数组，
        //stack.index是指针

        while(true){
            //输入操作目的：
            System.out.println();
            System.out.println("请输入操作目的……压栈_y？弹栈_t？");
            java.util.Scanner s =new java.util.Scanner(System.in);
            String instruction=s.next();//接收字符串

            /****压栈*/
            if("y".equals(instruction)) {
                System.out.println("请输入压栈数据……");
                java.util.Scanner s2 =new java.util.Scanner(System.in);
                String objData=s2.next();//接收字符串
                stack.pushStack(stack,objData);

            }
            /****弹栈**/
            else if ("t".equals(instruction)) {
                stack.popStack(stack);

            }
            else
                System.out.println("输入错误，请重新输入……");
        }
    }

}


class StackOperation2{
    Object[] elements;
    int index;

    public void Mystack(){          /***创建对象*/
        this.elements=new Object[10];
        this.index=-1;
    }

    /****构造方法**/
    public StackOperation2() {
    }


    /***压栈*/
    public void pushStack(StackOperation2 stacksrc,Object objData){
        //srcPos==stacksrc.index;
        if (stacksrc.index+1>=0 && stacksrc.index+1<stacksrc.elements.length){

            //stacksrc.index++;/***压栈前，指针上移指向”未来的“栈顶*/
            stacksrc.elements[++stacksrc.index]=objData;
            System.out.println("压栈成功");

            System.out.println("栈顶指针位置（0~9）："+(stacksrc.index));/***输出栈顶指针位置，因为已经压入一个，所以+1*/
            System.out.print("输出栈内元素：");
            for (int i=0;i<= stacksrc.index;i++)
                System.out.print(stacksrc.elements[i]+",");
        }
        else
            System.out.println("栈满，压栈失败");


    }
    /***弹栈*/
    public void popStack(StackOperation2 stacksrc){
        if (stacksrc.index>=0 && stacksrc.index< stacksrc.elements.length){

            stacksrc.elements[stacksrc.index--]=null;/**弹栈*/
            //stacksrc.index--;
            System.out.println("弹栈成功");
            System.out.println("栈顶指针位置（0~9）："+stacksrc.index);/***输出栈顶指针位置，因为已经弹出一个，所以-1*/

            System.out.print("输出栈内元素：");
            for (int i=0;i<= stacksrc.index;i++)
                System.out.print(stacksrc.elements[i]+",");
        }

        else if (stacksrc.index<0){
            System.out.println("弹栈失败");
        }


    }

}
4.2.酒店管理系统
  • 为某个酒店编写程序，酒店管理系统，模拟订房、退房、打印所有房间状态，的功能
  •  1.系统用户是：酒店前台

  •  2.酒店用一个二维数组来模拟。Room[][] rooms

  •  3.酒店中每一个房间都应该是一个java对象:Room

  •  4.每个房间都应该有：房间号、房间类型、房间是否空闲

  •  5.系统应该对外提供的功能：

  •      可以预订房间：输入房间号订房

  •      可以退房：输入房间号退房

  •      可以查看所有房间状态

程序说明：

  • 输入d，订房；输入c，查某一房间；输入t，退房；输入s，输出所有房间状态；
  • 系统初始化，第一层：单人间，第二层：标准间，第三层：豪华间
  • 默认，3层，每层20个房间。
  • 输入数字必须是3位：eg.109,表示1层9号房。
public class HotelManage {
    public static void main(String[] args) {
        if (args.length!=2) {
            System.out.println("输入不正确，请重新登陆……");
            return ;
        }
        if ("homeinns".equals(args[0]) && "abc".equals(args[1])){
            System.out.println("登陆成功，请继续操作……");
        }
        else{
            System.out.println("登陆失败");
            return ;
        }


        //系统初始化，第一层：单人间，第二层：标准间，第三层：豪华间
        Room [][] rooms=new Room[3][20];//这里只是创建了Room类的数组，还没有赋值

        for (int i=0;i< rooms.length;i++) {
            for (int j = 0; j < rooms[i].length; j++) {
                rooms[i][j] = new Room(); //给二维数组rooms赋Room类的值
                rooms[i][j].setNo((i+1)*100+(j+1));//赋“房间号”
                switch (i) {
                    case 0: {
                        rooms[i][j].setType("单人间");/**一楼是单人间*/
                        break;
                    }
                    case 1: {
                        rooms[i][j].setType("标准间");
                        break;
                    }
                    case 2: {
                        rooms[i][j].setType("豪华间");
                        break;
                    }
                }
            }
        }


        while(true){
            //输入操作目的：
            System.out.println("请输入操作目的……订房_d？退房_t？查房_c？输出房间状态_s？");
            java.util.Scanner s =new java.util.Scanner(System.in);
            String i=s.next();//接收字符串

            /****查房操作**/
//            if("查房".equals(i)){
            if("c".equals(i)){
                System.out.println("请输入查询3位房间号……（101~320）");
                java.util.Scanner floors1 =new java.util.Scanner(System.in);
                int floor1=floors1.nextInt();
                if((floor1>=101 && floor1<=120)||(floor1>=201 && floor1<=220)||(floor1>=301 && floor1<=320)) {
                    System.out.println(floor1 + "房间" + "是" + rooms[floor1 / 100 - 1][floor1 % 100 - 1].getState() + "的" + rooms[floor1 / 100 - 1][floor1 % 100 - 1].getType());
                }
                else
                    System.out.println("房间号输入错误");

            }
            /***订房操作*/
//            else if("订房".equals(i)){
            else if("d".equals(i)){
                System.out.println("请输入预定3位房间号……（101~320）");
                java.util.Scanner floors1 =new java.util.Scanner(System.in);
                int floor1=floors1.nextInt();
                if((floor1>=101 && floor1<=120)||(floor1>=201 && floor1<=220)||(floor1>=301 && floor1<=320)) {

                    if ("空房".equals(rooms[floor1 / 100 - 1][floor1 % 100 - 1].getState())) {
                        rooms[floor1 / 100 - 1][floor1 % 100 - 1].setState("非空");
                        System.out.println(floor1 + "号" + rooms[floor1 / 100 - 1][floor1 % 100 - 1].getType() + "预订成功");
                    } else
                        System.out.println(floor1 + "号" + rooms[floor1 / 100 - 1][floor1 % 100 - 1].getType() + "已有预订，本次预订失败");

                }
                else
                    System.out.println("房间号输入错误");


            }
            /****退房操作*/
//            else if("退房".equals(i)){
            else if("t".equals(i)){
                System.out.println("请输入退订3位房间号……（101~320）");
                java.util.Scanner floors1 =new java.util.Scanner(System.in);
                int floor1=floors1.nextInt();
                if((floor1>=101 && floor1<=120)||(floor1>=201 && floor1<=220)||(floor1>=301 && floor1<=320)) {

                    if ("非空".equals(rooms[floor1 / 100 - 1][floor1 % 100 - 1].getState())) {

                        rooms[floor1 / 100 - 1][floor1 % 100 - 1].setState("空房");
                        System.out.println(floor1 + "号" + rooms[floor1 / 100 - 1][floor1 % 100 - 1].getType() + "退订成功");
                    } else
                        System.out.println(floor1 + "号" + rooms[floor1 / 100 - 1][floor1 % 100 - 1].getType() + "是空房，本次退订失败");
                }
                else
                    System.out.println("房间号输入错误");


            }
            /***输出所有房间状态**/
            else if("s".equals(i)){
                Room.printRoom(rooms);
            }
            else {
                System.out.println("输入错误，请重新输入……");
            }
        }



    }
}


//定义抽象类
class Room{
    private int no;//房间编号[楼层][房间]
    private String type;//房间类型:标准间、单人间、豪华间
    private String state="空房";//房间状态：空房、非空
                        //默认为空房

    /***设定房间号、读取房间号*/
    public void setNo(int no){
        this.no=no;
    }
    public int getNo(){
        return this.no;
    }

    /***设定房间类型、读取房间类型*/
    public void setType(String type){
        this.type=type;
    }
    public String getType(){
        return this.type;
    }

    /***设定房间状态、读取房间状态*/
    public String getState(){
        return this.state;
    }
    public void setState(String state){
        this.state=state;
    }

    //打印房间号、状态
    public static void printRoom(Room[][] rooms){
        for (int i=0;i< rooms.length;i++) {
            for (int j = 0; j < rooms[i].length; j++) {
                System.out.print("["+rooms[i][j].no+ "号" + rooms[i][j].type +rooms[i][j].getState()+"],");
            }
            System.out.println();
        }

    }

}
丢丢diu丢
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
小王java学习打卡day04——数组，排序，重载
w1099938370的博客
05-07 124
数组拷贝及扩容 首先得有两个数组 的指导从哪拷贝到哪，拷贝多长 需求：从源数组拷贝第二个元素到第四个元素，到目标数组里面 /*需求：从源数组拷贝第2个元素到第4个元素，到目标数组里面*/ public class CopyDemo { public static void main(String[] args) { int[] ages = {15, 12, 56, 45, 2, 56, 15, 1, 8, 4}; int srcPos =2...
二维数组，选择排序和冒泡排序
最新发布
05-30
二维数组，选择排序和冒泡排序
用指针实现,采用冒泡排序法将数组中的数据升序排序
热门推荐
yeliner的博客
06-20 1万+
冒泡排序原理: 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 举例:int a[]={1, 4, 22 ,6, 88}; 排序过程如下: times 1: 1...
【C++--04】实验报告:数组、指针及引用;冒泡排序与二维数组存储学生信息;
白小鱼的博客
06-10 2152
目录 一.实验目的: 二.实验任务: 三.实验内容: 1.冒泡排序实验分析: 2.冒泡排序实验代码: 3.冒泡排序实验结果: 4.二维数组实验分析: 5.实验代码 6.运行结果: 四.实验总结: 一.实验目的: 掌握用指针及引用作参数编写程序的知识技能; 提高学习者面向对象程序开发工具的自学习能力； 掌握一维数组和二维数组的定义、赋值和输入输出的方法。 能...
C语言指针习题：用冒泡排序法对数组a按降序排序，再输出排序后的a数组
qq_42308203的博客
05-19 2142
C语言指针习题 【独立编程】程序功能：输入正整数 n（n≤10）和n个整数存入数组a，先用冒泡排序法对数组a按降序排序，再输出排序后的a数组。 #include<stdio.h> int main(){ int a[10]; int i,n; void sort(int *p,int n); scanf("%d",&n); for(i=0;i<n;i++){ scanf("%d",&a[i]); } sort(a,n); for(i=0;i<n;
Java简单数组排序(冒泡法)
09-03
主要介绍了Java简单数组排序,实例分析了基于冒泡法实现数组排序的相关技巧,简单实用,具有一定参考借鉴价值,需要的朋友可以参考下
java算法题数组从小到大冒泡排序
03-02
初级练习
二维数组如何进行冒泡排序
07-18
思路以及注意点、说明我都加在了代码旁边的注释里，好好悟悟！
Java中的数组排序方式(快速排序、冒泡排序、选择排序)
09-04
主要介绍了Java中的数组排序方式(快速排序、冒泡排序、选择排序),需要的朋友可以参考下
JavaDay12——构造方法能被继承吗？——不能！！！
m0_38057941的博客
08-27 1025
构造 构造函数和类同名，父类和子类肯定不同名， 那父类的构造函数放在在子类里有什么用啊，那不成一般方法了吗？ 所以父类的构造函数是无法继承的。 引用传智播客的老毕语录 调用： 子类继承父类的时候，先运行父类构造函数； 具体的说就是运行父类时就会先“调用”父类的构造函数，（利用super()、super(实参列表)调用） 注意“调用”和继承不是一个含义，实质上是“自动运行”。 ...
JAVA学习Day2—public class与class的区别—标识符—变量3要素—2020.8.15
m0_38057941的博客
08-27 815
1.程序的注释 public class HelloWorld{ //public表示公开的，class表示这是一个类，类名是HelooWorld public static void main(String[] args){ //这块是main方法，是程序入口 System.out.println("Hello World"); //向控制台输出一句话 } } main方法在类体里，也必须在类体里。没有main方法，则不可编译执行。 public class 与 class的区别： .
JavaSE_Day28_获取、访问Field—可变长度参数—反射\调用Method、Construcor—注解
m0_38057941的博客
09-23 332
1.获取、修改Field（属性、成员） 1.1.获取Field 以student为例： class student{ public String name; private int age; boolean sex; protected int no; } 部分提要： 输出属性、成员的修饰符"（eg：public、protected、private……） Modifier.toString(xxxx.getModifiers()) 输出属性、成员的类型（
JavaDay25—多线程—线程sleep—线程终止（强行vs合理）—线程调度（优先级、让位、合并）—线程安全—synchronized
m0_38057941的博客
09-19 301
1.多线程基础知识 1.1.什么是进程？什么是线程？ 进程是一个应用程序（1个进程是一个软件）。 线程是一个进程中的执行场景/执行单元。 一个进程可以启动多个线程。 1.2.进程和线程是什么关系？举个例子 进程可以看做是现实生活当中的公司，线程可以看做是公司当中的某个员工。 阿里巴巴：进程 马云：阿里巴巴的一个线程 张勇: 阿里巴巴的一个线程 苹果公司：进程 乔布斯：苹果的一个线程 库克：苹果的一个线程 进程A和进程B的内存独立不共享。（阿里巴巴和京东资源不会共享的！） 魔兽游戏是一个进程
JavaDay16-P104-P142—二分法查找—String类—常量池—包装—装箱、拆箱—NumberFormatException
m0_38057941的博客
08-31 297
1.二分法查找——建立在数组排序之上 案例程序： class BinarySearch{ public static void binarySearch(int[] arr,int des) { Arrays.sort(arr);/**对数组排序*/ int begin=0; int end=arr.length; while (begin<=end){ int mid=(begin+end)/2;
JavaDay9—封装—实例方法—static—静、动态代码块—this用法—8.24
m0_38057941的博客
08-27 297
1.封装 1.1.封装的作用 （1）保证内部结构的安全，外部人员不可随意访问 （2）屏蔽复杂，暴露简单 不封装会使xxx类的属性对外暴露，可以被随意访问、更改，不安全。 1.2.封装方法—private表示私有的，被他修饰后，该数据只能在“当前类”中访问。 封装代码的两步： （1）、属性私有化（private） （2）、1个属性对外提供2个set\get方法，可以在set方法中设立关卡（限定传入数据的取值范围，eg.年龄不能为负）保证数据安全 强调： （1）.set、get都是实例方法，不可带static
JavaDay19—p184-p199—集合——remove和contains底层调用equals方法（equals有时要重写）
m0_38057941的博客
09-03 281
1、什么是集合？有什么用？ 数组其实就是一个集合。集合实际上就是一个容器。可以来容纳其它类型的数据。 1.1.集合为什么说在开发中使用较多？ 集合是一个容器，是一个载体，可以一次容纳多个对象。 在实际开发中，假设连接数据库，数据库当中有10条记录， 那么假设把这10条记录查询出来，在java程序中会将10条数据封装成10个java对象， 然后将10个java对象放到某一个集合当中， 将集合传到前端，然后遍历集合，将一个数据一个数据展现出来。 1.2、集合不能直接存储基本数据类型，另
JavaDay17——一维数组模拟栈——酒店管理系统
m0_38057941的博客
09-01 240
编写程序，使用一维数组，模拟栈数据结构 要求： 1.这个栈可以存储java中任何引用类型的数据 2.在栈中提供push方法模拟压栈，（栈满了，要有提示信息） 3.在栈中提供pop方法弹栈（栈空了要有提示信息） 4.编写测试程序，new栈对象，调用push、pop来模拟压栈、弹栈 /****完全对象实现 * 编写程序，使用一维数组，模拟栈数据结构 * 要求： * 1.这个栈可以存储java中任何引用类型的数据 * 2.在栈中提供pus...
JavaDay13—抽象类—接口—package\import
m0_38057941的博客
08-28 201
1.抽象类 1.1.什么是抽象类？ 类与类之间有共同特征，将这些特征提取出来，形成抽象类 抽象类无法创建对象（无法实例化） 抽象类是用来继承的 1.2.抽象类属于引用数据类型 1.3.语法： [修饰符列表] abstract class 类名{ 类体; } 1.4.abstract与final无法联合使用 1.5.抽象类的子类可以是抽象类 1.6.抽象类可以有构造方法，供子类使用 1.7.抽象方法的特点： public abstract void doSome(); 特点：1.无方法体，
用Java定义一个数组,写出冒泡排序或选择排序
05-29
好的，以下是定义一个数组并使用冒泡排序和选择排序排序的示例代码： ```java public class Main { public static void main(String[] args) { // 定义一个数组 int[] arr = {5, 2, 8, 3, 1}; // 冒泡排序 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值