第五章 数组及排序 ② 代码

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量387 收藏
点赞数
分类专栏： # Java 文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liu_wen_wen/article/details/125539665
版权
本文介绍了Java中的基础操作，包括字符串查找、日期差计算以及三种数组创建方式。此外，还详细讲解了冒泡排序和选择排序的实现，并探讨了数组的扩容和对象数组的使用。示例代码展示了如何查找字符串出现次数、计算日期差以及实现排序算法。
摘要由CSDN通过智能技术生成

这里写目录标题

1.课前测试

在这里插入图片描述

代码如下：

package com.yzh7.test1;

import java.util.Scanner;

/**
 * @author: hy
 * @create: 2022-06-30 09:34:00
 */
public class Test {
    public static void main(String[] args) {
        //创建输入工具类对象
        //Scanner scanner = new Scanner(System.in);
        //System.out.println("请输入一个主字符串:");
        String mainStr = "新年好，新年好，祝福新年好";//scanner.next();
        //System.out.println("请输入要查找的字符串:");
        String findStr ="新年好"; //scanner.next();

        /*
        int count = 0;
        //查找过程，统计出现次数
        while (true){
            int pos = mainStr.indexOf(findStr);
            //没找到
            if(pos==-1){
                break;
            }
            //找到则次数加1
            count++;
            //将主字符串截取出来没有查找过的部分
            mainStr = mainStr.substring(pos+findStr.length());
        }
        */

        int count=0;
        for (int i=0;i<=mainStr.length()-findStr.length();i++){
            //从特定位置截取出要查找内容长度的字符串
            String sub = mainStr.substring(i,i+findStr.length());
            System.out.println(mainStr);
            System.out.println(i);
            System.out.println(sub);

            if(sub.equals(findStr)){
                count++;
                System.out.println("匹配上了");
            }
            System.out.println("====================");
        }

        System.out.println("查找到的["+findStr+"]在主字符串中的次数是:"+count+"次");

    }
}

package com.yzh7.test1;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

/**
 * @author: hy
 * @create: 2022-06-30 09:51:05
 */
public class Test2 {
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("=====求日期差=====");
        System.out.println("请输入日期1:");
        String str1 = sc.next();
        System.out.println("请输入日期2:");
        String str2 = sc.next();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date d1 = sdf.parse(str1);
        Date d2 = sdf.parse(str2);

        while (true) {
            System.out.println("请选择求差单位:1.年 2.月 3.日 4.退出");
            int choose = sc.nextInt();
            switch (choose) {
                case 1:
                    System.out.println((d2.getTime()-d1.getTime())/1000/3600/24/365);
                    break;
                case 2:
                    System.out.println((d2.getTime()-d1.getTime())/1000/3600/24/30);
                    break;
                case 3:
                    System.out.println((d2.getTime()-d1.getTime())/1000/3600/24);
                    break;
                case 4:
                    System.out.println("退出");
                    return;
                default:
                    System.out.println("选择错误，请重新选择");
                    break;
            }

        }
    }
}

思路一：
先查找第一个字符串 然后截取出未查找的部分进行一次查找
不确定次数的循环 while(true)
计数器计数 终止条件break

思路二：三字逐字匹配
匹配成功计数器+1
字符串随着for循环进行截取改变

package com.yzh70630;
import java.util.Scanner;
/**
 * @author: XYT
 * @create-date: 2022/6/30 8:59
 */
public class TiMU1 {
    public static void main(String[] args) {
//        Scanner input=new Scanner(System.in);
//        System.out.println("请输入一个主字符串：");
//        String zhu1=input.next();
//        System.out.println("请输入要查找的字符串：");
//        String zhu2=input.next();
//        String[] N=zhu1.split(zhu2);
//        int n=N.length;
//        System.out.println("查找的["+zhu2+"]在字符串中出现了"+n+"次");

        Scanner input=new Scanner(System.in);
        System.out.println("请输入一个主字符串：");
        String zhu1=input.next();
        System.out.println("请输入要查找的字符串：");
        String zhu2=input.next();
        int count=0;
        /*
        //第一种方法 不确定次数的循环while(true)
        while(true){
            int pos=zhu1.indexOf(zhu2);
            if(pos==-1){
                break;
            }
            count++;
            zhu1=zhu1.substring(pos+1);
        }
        */

        //字符长度 xxx.length() 数组长度 xxx.length 详见下一章节博客
        //第二种方法 for循环
        for (int i = 0; i <= zhu1.length()-zhu2.length(); i++) {  //这里是<=,否则最后一个"新年好"将无法匹配
            String jie=zhu1.substring(i,i+zhu2.length());
            if(zhu2.equals(jie)){
                count++;
            }
        }
        System.out.println("查找的["+zhu2+"]在字符串中出现了"+count+"次");
    }
}

在这里插入图片描述

package com.yzh70630;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Period;
import java.time.format.DateTimeFormatter;

import java.util.Scanner;

/**
 * @author: XYT
 * @create-date: 2022/6/30 9:11
 */
public class QiCe {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入第一个日期字符串：");
        String s1=input.next();
        System.out.println("请输入第二个日期字符串：");
        String s2=input.next(); 
        DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate ld1 =  LocalDate.parse(s1,dtf2);    //这里老师用的是.getTime()
        LocalDate ld2 = LocalDate.parse(s2,dtf2);
        Period period = Period.between(ld1,ld2);
        //System.out.println("请输选择求差单位：1，年2.月，3.日，4，推出"); //注意:需要把判断变量放在函数里，否则将会出现死循环
        //int n=input.nextInt();

        //以下是功能不完整的残次品
//        int yue=period.getMonths();
//        int ri=period.getDays();
//        if(n==1){
//            System.out.println("两个日期相差了："+period.getYears()+"年");
//        } else if (n==2) {
//
//            System.out.println("两个日期相差了："+period.getYears()*12+yue+"月");
//        }else if(n==3){
//            System.out.println("两个日期相差了："+(period.getYears()*12+yue)*30+ri+"日");
//        }else if(n==4){
//            return;
//        }
        //功能完整的代码
        while(true){
            System.out.println("请输选择求差单位：1，年2.月，3.日，4，推出");
            int n=input.nextInt();
            int yue=period.getMonths();  
            int ri=period.getDays();
            switch(n){
                case 1:
                    System.out.println("两个日期相差了："+period.getYears()+"年");
                    break;
                case 2:
                    System.out.println("两个日期相差了："+period.getYears()*12+yue+"月");
                    break;
                case 3:
                    System.out.println("两个日期相差了："+(period.getYears()*12+yue)*30+ri+"日");
                    break;
                case 4:
                    System.out.println("推出");
                    return;
                default:
                    System.out.println("选择错误，请重新选择！");
                    break;
            }

        }

    }
}

运行结果如下：
在这里插入图片描述
在这里插入图片描述

2.数组的三种创建方式

代码如下：
第一种：

package com.yzh7.test2;

/**
 * @author: hy
 * @create: 2022-06-30 10:07:38
 */
public class Test {
    public static void main(String[] args) {
        //1.创建指定长度的数组
        int[] nums = new int[3];
        System.out.println(nums.length);

        //遍历数组:索引遍历数组
        for (int i=0;i<nums.length;i++){
            System.out.println(nums[i]);
        }
        System.out.println("======================");

        nums[0]=10;
        nums[1]=30;
        nums[2]=200;
        //nums[3]=400;//Array(数组)Index(索引)OutOf(超出)Bounds(边界)Exception(异常)

        //for each遍历
        for (int xxxxxx : nums){
            //xxxxxx:此时是遍历的数组元素本身
            System.out.println(xxxxxx);
        }

    }
}

在这里插入图片描述

第二种：

package com.yzh7.test2;

/**
 * @author: hy
 * @create: 2022-06-30 10:13:31
 */
public class Test2 {
    public static void main(String[] args) {
        //2.用new的方式创建有初始值的数组
        String[] names ;
        names = new String[]{"孙悟空","猪八戒","唐僧","沙僧"};
        //访问数组元素
        System.out.println(names[3]);
        System.out.println(names[names.length-1]);

        //修改数组元素
        names[2]="嫦娥";
        //遍历数组
        for (int i=0;i<names.length;i++){
            System.out.println(names[i]);
        }

    }
}

第三种：

package com.yzh7.test2;

/**
 * @author: hy
 * @create: 2022-06-30 10:16:23
 */
public class Test3 {
    public static void main(String[] args) {
        //静态方式创建数据，并赋初始值
        double[] tall = {1.3,1.9,2.1};
        //tall = {1.3,1.9,2.1}; //不能分开定义赋值
        for (int i=0;i<tall.length;i++){
            System.out.println(tall[i]);
        }

        for (double d:tall){
            System.out.println(d);
        }


    }
}

练习：

package com.yzh7.test2;

import com.sun.org.apache.xerces.internal.impl.xs.SchemaNamespaceSupport;

import java.util.Scanner;

/**
 * @author: hy
 * @create: 2022-06-30 10:45:27
 */
public class Test4 {
    public static void main(String[] args) {
        //扩展:定义长度为3的字符串数组，用循环输入3个名字，循环输出
        Scanner sc = new Scanner(System.in);
        String[] names = new String[3]; //0 1 2
        for (int i=0;i<names.length;i++){
            System.out.println("请输入第"+(i+1)+"个学生的姓名:");
            String n =sc.next();
            names[i]=n;
        }

        System.out.println("===========");
        for(String s: names){
            System.out.println(s);
        }
    }
}

使用数组时需要：import java.lang.reflect.Array;

package com.yzh70630;

import java.lang.reflect.Array;

/**
 * @author: XYT
 * @create-date: 2022/6/30 10:20
 */
public class Array0 {
    public static void main(String[] args) {
        // 定义有容量的数组
        // 数据类型[] 数组变量 = new 数据类型[数组容量];
        int[] arr=new int[3];
        System.out.println(arr.length);
        //for循环遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        arr[0]=0;
        arr[1]=1;
        arr[2]=2;
        //for-each
        for (int xxx:arr) {
            System.out.println(xxx);
        }

    }
}

运行结果如下：

在这里插入图片描述

package com.yzh70630;

/**
 * @author: XYT
 * @create-date: 2022/6/30 10:29
 */
public class Array1 {
    public static void main(String[] args) {
        // 定义有初始化数据的数组.后面的中括号中不能写长度
        //数据类型[] 数组变量 = new 数据类型[]{数据1,数据2...};
        //String[] arr1= new String[]{"八戒","猴子","和尚"};
        //拆分
        String[] arr1;
        arr1 = new String[]{"八戒","猴子","和尚"};

        System.out.println(arr1[2]);
        System.out.println(arr1[arr1.length-1]);

        //更换数组元素
        arr1[0]="嫦娥";
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }

    }
}

运行结果如下：
在这里插入图片描述

package com.yzh70630;

import java.util.Scanner;

/**
 * @author: XYT
 * @create-date: 2022/6/30 10:40
 */
public class Array2 {
    public static void main(String[] args) {
        /*
        // 直接赋值创建(静态创建)，定义和赋值必须写在一起
        //数据类型[] 数组变量 = {数据1,数据2...};
        double[] d={1.1,1.2,1.3};
        //for
        for (int i = 0; i < d.length; i++) {
            System.out.println(d[i]);
        }
        //for-each
        for(double xxxx:d){
            System.out.println(xxxx);
        }
        */
        //开辟一个数组
        int[] sz=new int[3];
        //依次输入三个数字
        for(int i=0;i<3;i++){
            System.out.println("请输入第"+(i+1)+"个数：");
            Scanner input=new Scanner(System.in);
            int a=input.nextInt();
            sz[i]=a;
        }
        for (int xxxxx:
             sz) {
            System.out.print(xxxxx+"  ");
        }

    }
}

运行结果如下：
在这里插入图片描述

3.最大值&&位置||最小值&&位置

代码如下：

package com.yzh7.test2;

/**
 * @author: hy
 * @create: 2022-06-30 10:50:41
 */
public class Test5 {
    public static void main(String[] args) {
        //定义长度为5的数组，并赋值，找出数组的最大值，最小值，最大值的位置，最小值的位置
        int[] nums = {9,1,7,10,6};
        //10:1  1:3
        //int max=nums[0]; //默认认为0的位置存储的是最大值
        int maxPos=0; //默认认为0的位置存储的是最大值位置
        //int min=nums[0];//默认认为0的位置存储的是最小值
        int minPos=0;//默认认为0的位置存储的是最小值位置

        //让数组元素依次相比
        for (int i=1;i<nums.length;i++){
            //比较最大值
            if(nums[maxPos]<nums[i]){
                maxPos=i; //存储最大值的位置
            }

            if(nums[minPos]>nums[i]){
                minPos = i; //存储最小值位置
            }
        }

        System.out.println("max:"+nums[maxPos]+" min:"+nums[minPos]);
        System.out.println("maxPos:"+maxPos+" minPos:"+minPos);
    }
}

运行结果如下：
在这里插入图片描述

4.冒泡排序->选择排序

代码如下：
冒泡排序：

package com.yzh7.test3;

/**
 * @author: hy
 * @create: 2022-06-30 11:12:14
 */
public class Test {
    public static void main(String[] args) {
        //N元数组冒泡序，两两相比小前移，外层循环从1始，内层循环减i去
        int[] nums = {40,20,50,30,10};
        //外层控制轮数
        for (int i=1;i<nums.length;i++){
            //内层控制比较次数
            for (int j=0;j<nums.length-i;j++){
                //前后相比
                if(nums[j]>nums[j+1]){
                    //比较换位
                    int temp = nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }

        for (int i :nums){
            System.out.println(i);
        }
    }
}

选择排序：

package com.yzh7.test3;

import java.util.Arrays;

/**
 * @author: hy
 * @create: 2022-06-30 11:15:18
 */
public class Test2 {
    public static void main(String[] args) {
        //选择排序:选择本轮中最小值，与开始位置的数换位，每轮最多换位一次，但是会比较若干次
        int[] nums = {40,20,50,30,10};
        //外层循环控制轮数，同时i表示，每一轮的开始位置
        for (int i=0;i<nums.length-1;i++){
            //k用于记录最小值位置的
            //k=i，假设这一轮的开始位置是最小值
            int k = i;
            //开始本轮比较，找到真的最小值位置
            for(int j=i+1;j<nums.length;j++){
                //比较获取最小值的位置
                if(nums[k]>nums[j]){
                    //k记录当前最小值的位置
                    k=j;
                }
            }
            //循环之后，找到了这一轮中的最小值位置k
            System.out.println("本轮中的最小值位置:"+k);

            //最小值位置上的数与开始位置换位
            if(k!=i){
                int temp = nums[k];
                nums[k]=nums[i];
                nums[i]=temp;
            }
        }

        /*for(int i: nums){
            System.out.println(i);
        }*/

        //Arrays.toString(nums):将数组元素拼接成字符串
        System.out.println(Arrays.toString(nums));
    }
}

package com.yzh70630;

import java.util.Arrays;

/**
 * @author: XYT
 * @create-date: 2022/6/30 11:32
 */
public class PaiXu {
    public static void main(String[] args) {
        int[] nums = {40,20,50,30,10};

        for (int i = 0; i < nums.length-1; i++) {
            int minp=i;
            for (int j = i+1; j < nums.length; j++) {
                if(nums[minp]>nums[j]){
                    //nums[minp]=nums[j]; //注意 这里不能赋值 赋值的话意味着交换顺序 这里只需要得到最小值的下标索引
                    minp=j;
                }

            }
            System.out.println("第"+(i+1)+"轮最小值是"+nums[minp]);

            if(nums[minp]!=nums[i]){
                int temp=nums[minp];
                nums[minp]=nums[i];
                nums[i]=temp;
            }
        }
        System.out.println(Arrays.toString(nums));
        
    }
}

运行结果如下：
在这里插入图片描述

5.数组的扩容

代码如下：

package com.yzh7.test3;

import java.util.Arrays;

/**
 * @author: hy
 * @create: 2022-06-30 11:43:25
 */
public class Test3 {
    public static void main(String[] args) {
        int[] nums = {39,48,12,5,44};
        //排序
        //Arrays.sort(nums);

        //打印输出
        //System.out.println(Arrays.toString(nums));

        //扩容
        //1.创建一个指定长度的新数组
        //2.将原有数组的内容，按对应位置复制到新数组中
        int[] mynums = Arrays.copyOf(nums,3);
        System.out.println(mynums.length);
        System.out.println(Arrays.toString(mynums));
    }
}

不是新添加数组
而是新建立了一个数组，初始值为0，将原来数组的数据搬过来
在这里插入图片描述

6.对象数组

代码如下：
创建学生对象数组方法：

package com.yzh7.test4;

/**
 * @author: hy
 * @create: 2022-06-30 11:50:58
 */
public class Student {
    String name;
    int age;

    public Student(){}

    //fn+(alt+insert) ->constructor 生成构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void instroduce(){
        System.out.println(this.name+" "+this.age);
    }
}

在这里插入图片描述
在这里插入图片描述

调用学生对象数组：

package com.yzh7.test4;

/**
 * @author: hy
 * @create: 2022-06-30 11:52:44
 */
public class Test {
    public static void main(String[] args) {
        /*int[] nums = {3,4,5,6};
        Student[] stus = {
            new Student("张三",10),
            new Student("李四",20)
        };

        //访问对象数组中，下标为0的元素的姓名
        System.out.println(stus[0].name);
        //访问对象数组中，下标为0的元素的年龄
        System.out.println(stus[0].age);

        //访问对象数组中，下标为0的元素的自我介绍方法
        stus[0].instroduce();
        //访问对象数组中，下标为1的元素的自我介绍方法
        stus[1].instroduce();*/

        Student[] stus = new Student[3];
        System.out.println(stus[0]);
        System.out.println(stus[1]);
        System.out.println(stus[2]);

        Student s1 = new Student("张三",10);
        stus[0] = s1;
        stus[1] = new Student("李四",20);
        stus[2] = new Student("王五",18);

        for (int i=0;i<stus.length;i++){
            //将当前数组元素，存储到学生变量中
            Student s = stus[i];
            System.out.println(s.name+" "+s.age);

        }

        System.out.println("==============");
        for (Student s : stus){
            s.instroduce();
        }
    }
}

package com.yzh7.test4;

import javafx.scene.transform.Scale;

import java.util.Scanner;

/**
 * @author: hy
 * @create: 2022-06-30 11:59:42
 */
public class Test2 {
    public static void main(String[] args) {
        //学生对象数组，长度为10
        Student[] stus = new Student[10];
        //实际存储的学生对象0
        int count = 0;

        Scanner scanner = new Scanner(System.in);
        while (true){
            System.out.println("请选择:1.添加学生 2.修改学生 3.删除学生 4.查询学生 5.退出");
            int choose = scanner.nextInt();
            switch (choose){
                case 1:
                    System.out.println("请输入要添加的姓名：");
                    String name= scanner.next();
                    System.out.println("请输入要添加的年龄：");
                    int age = scanner.nextInt();
                    Student s = new Student(name,age);
                    //学生存储到指定位置
                    stus[count] = s;
                    //学生数量加1
                    count++;
                    break;
                case 2:
                    break;
                case 3:
                    break;
                case 4:
                    System.out.println("编号\t姓名\t年龄");
                    for (int i=0;i<count;i++){
                        System.out.print(i+1);
                        System.out.print("\t");
                        System.out.print(stus[i].name);
                        System.out.print("\t");
                        System.out.print(stus[i].age);
                        System.out.print("\n");
                    }
                    break;
                case 5:
                    System.out.println("退出");
                    return;
                default:
                    System.out.println("选错了");
                    break;
            }
        }
    }
}
小丫头爱打盹
关注
专栏目录
php 二维数组时间排序实现代码
10-21
在PHP中，尽管PHP提供了一些内置的数组排序函数，例如sort()、asort()、arsort()、ksort()、krsort()等，但这些函数都是用于对数组的键或者值进行排序，而不支持直接对二维数组中的特定元素（比如数组里的某个字段）...
java第四章数组初识排序
12-26
数组排序算法 Java提供了多种排序算法，其中最常用的是`Arrays.sort()`方法。例如，对整数数组进行升序排序： ```java import java.util.Arrays; int[] numbers = {5, 3, 9, 1, 7}; Arrays.sort(numbers); ``` ...
数组遍历代码
weixin_48586922的博客
11-09 417
public class jaChu { public static void main(String[] args) { //顺序是从零开始数的 int[] a ={1,2,3,4,5,6,7,8}; System.out.println(a[0]);//输出1 //遍历数组，记得是length-1. for (int i = 0; i <= a.length-1; i++) { Sys
JavaScript解密之旅-----数组的遍历方法总结
weixin_45176415的博客
05-14 1709
文章目录数组的循环一、forEach（）二、map（）三、filter（）四、reduce（）与reduceRight()五、every（）六、some（）七、find（）与findIndex（）八、 for in九、 for of十、 for总结 数组的循环 一、forEach（） 对数组进行遍历循环，对数组中的每一项运行给定函数。这个方法没有返回值。 参数都是function类型，默认有传参，参数分别为：遍历的数组内容；第对应的数组索引，数组本身。 var arr = [1, 2, 3,
各种常用的排序算法实现对数组的排序——整理总结（代码实现）
zm1_1zm
07-13 814
冒泡排序、插入排序、折半排序（二分插入排序）、快速排序、选择排序、归并排序、希尔排序、堆排序
C++ Sort函数详解
热门推荐
zhangbw's blog
06-06 13万+
C++sort函数介绍、案例，自定义排序方法。
数组~代码实例
weixin_41954142的博客
12-11 1019
“本文部分内容摘自《java语言程序设计》，郭克华主编。转载请标明出处。后期不定时跟新。 一、结合代码，讲解概念 解析： （1）要使用一个东西，先要给他一个“名分”——定义 以main方法入口，首先定义一个数组，如上： int[] arr = new int[100]; 注意格式可以概括为：type arrayName = new type[arraySize] 以上代码，创建了一...
Java第5章 数组 含源代码
11-08
Java语言中的数组是一种非常基础且...总之，Java第5章关于数组的内容是学习Java编程的基础，理解和熟练运用数组对于后续的学习和实际项目开发至关重要。通过实践和代码分析，可以加深对数组特性的理解，提高编程技能。
易语言自定义数据类型数组排序
07-23
本话题聚焦于“易语言自定义数据类型数组排序”，将深入探讨如何在易语言中创建、操作自定义数据类型数组，并实现各种排序算法，如根据产地、类别和售价等属性进行排序。 自定义数据类型在易语言中允许我们定义包含...
C语言程序设计第七章数组2
06-25
第七章主要探讨的是数组的使用，特别是针对一维数组的定义、引用以及初始化。 一维数组可以看作是在内存中连续存储的一系列变量，它们具有相同的类型。数组的定义包括类型说明符、数组名和可选的常量表达式，用于...
js实现多维数组组合算法
cjs1534717040的专栏
08-19 1658
由航线生成方案引发的多维数组组合实现算法。
多个(N)个数组的的元素组合排序算法,多维数组的排列组合或多个数组之间的排列组合
小石头
04-15 1360
算法代码写法一： // 执行组合排列的函数 function doExchange(array){ var len = arr.length; // 当数组大于等于2个的时候 if(len >= 2){ // 第一个数组的长度 var len1 = arr[0].length; // 第二个数组的长度 ...
排列组合算法的代码实现——附Python源码
AI量化交易实验室
06-30 9264
一、问题描述 假设我们从数组[1,2,3,4,5,6]中，取出三个不重复的数，求所有可能的组合，数据不多，我们手动列举一下： 二、枚举法 看着几个三角形，是不是觉得很有规律，让人立刻想到是递归，但是递归式很容易让人混乱的算法，最简单的实现方法无疑是暴力枚举法，先写为敬，代码如下： def dd(): for i in range(1,7): for p in ...
js中多个数组排列组合
The One Who's at the Front
11-29 2689
以项目中用到的数组排列组合为例，下图是最后的效果图(图只是用来说明并不具体实现)： 数据 data() { return { arr: [ [{ name: "院区1", number: "001" }, { name: "院区2", number: "002" }], //对应图中条件1的数据 [{ name: "部门1", number: "001" }, { name: "部门2", number: "002" }], //对应图中条件2的数据
排序算法-插入排序及其优化
Weber's blog
04-17 449
Insert Sort
数组------数组的遍历、排序、最值操作
ThisIsSunshine的博客
04-18 1820
一、数组的遍历 在操作数组时，经常需要依次富翁数组中的每个元素，这种操作称作数组的遍历。 接下来通过一个案例来学习如何使用for循环遍历数组 案例一（使用for循环遍历数组） public class ArrayTest { public static void main(String[] args){ int[] arr={1,2,3,4,5}; // 定义数组 //通过for循环遍历输出数组 for(int i = 0;i <arr.
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 407
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 729
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 510
spring boot 整合 mybatis
C语言第五章实验与习题详解：数组与排序
"C语言程序与设计第5章实验及习题复习资料" 在C语言中，数组是一种非常重要的数据结构，它允许我们存储多个相同类型的数据。在本章的实验和习题中，主要涉及了一维数组的操作，包括验证性实验和设计性实验。 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值