数组的使用及算法

已于 2023-04-07 18:32:27 修改
阅读量76 收藏
点赞数
文章标签： 算法 数据结构
于 2023-04-07 17:55:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FrankieCao/article/details/129997656
版权

目录

7. 数组的扩容

9.数组类型的参数和返回值

10. 值传递和引用传递

11. 排序

11.1 冒泡排序

11.2选择排序

11.3 二分查找

11.4 数组的插入

11.5 数组的删除

12. 可变长参数

13. 二维数组

7. 数组的扩容

注意：数组的长度是固定的  所以长度是无法改变的 

我们这里所谓的扩容其实是  将原数组中的内容  复制到新数组中 

然后再将原数组的地址

指向新数组的空间

public class TestArrayGrow {
    public static void main(String[] args) {
        int [] oldArr = {1,2,3,4,5};

        int [] newArr = new int[oldArr.length * 2];

        for(int i = 0;i < oldArr.length;i++){
            // 这里要执行复制元素的操作
            // 等号右边赋值给等号左边的
            newArr[i] = oldArr[i];
        }
        System.out.println(Arrays.toString(newArr));

        System.out.println(oldArr);
        System.out.println(newArr);

        oldArr = newArr;

        System.out.println(oldArr);
        System.out.println(newArr);
    }
}

8. 数组的复制

复制数组的三种方式：

1.编写循环实现复制

2.void System.arraycopy(原数组，起始位置，新数组，起始位置，复制元素个数)

   注意下标和元素个数不要超出范围

3.数组 [ ]  Arrays.copyOf(原数组，新长度)

public class TestArrayCopy {
    public static void main(String[] args) {
        int [] oldArr = {1,2,3,4,5};
        int [] newArr = new int[oldArr.length];

        System.arraycopy(oldArr, 0,newArr,0,5);
        System.out.println(Arrays.toString(newArr));

        System.out.println("--------------------------------------------------");

        // [1, 2, 3, 4, 5]
        int [] copyArr =  Arrays.copyOf(newArr, 10);
        System.out.println(Arrays.toString(copyArr));
    }
}

9.数组类型的参数和返回值

不管是作为参数，还是作为返回值，跟之前的使用方式相同

/**
 *  需求：
 *  1.编写方法实现统计5门课程成绩 并且返回
 *  2.编写方法用于接收一个成绩数组 然后将成绩进行打印
 *
 */
public class TestArrayParameterReturned {

    public static double[] inputScore(){
        Scanner input = new Scanner(System.in);
        double [] scores = new double[5];
        for(int i  =0;i < scores.length;i++){
            System.out.println("请输入第" + (i + 1) + "门成绩");
            scores[i] = input.nextDouble();
        }
        return scores;
    }
    public static void printScore(double [] scores){
        for(int i = 0;i < scores.length;i++){
            System.out.println("第" + (i + 1) + "门成绩为：" + scores[i]);
        }
    }
    public static void main(String[] args) {
        double [] scores =  inputScore();
        printScore(scores);
        System.out.println(Arrays.toString(scores));、
    }
}

10. 值传递和引用传递

Java官方明确表示 Java中只有值传递 没有引用传递 “引用传递”也属于值传递  只不过这个值是一个地址 也是一个引用

基本数据类型传参  属于值传递  在方法中对值的改变 不会影响原变量

引用数据类型传参  属于引用传递  在方法中根据地址操作数据 会影响原变量

String类型是特殊的引用数据类型  作为参数传递不会改变原变量

public class TestTransfer {
    public static void transferValue(int num){
        num++;
        System.out.println("transferValue方法中num的取值为：" +  num);
    }
    public static void transferAddress(int [] nums){
        System.out.println("transferAddress方法中数组的地址值为：" + nums);
        for(int i = 0;i < nums.length;i++){
            nums[i]++;
        }
    }
    public static void main(String[] args) {
        int a = 10;
        transferValue(a);
        System.out.println(a);

        int [] arr = {1,2,3,4,5};
        System.out.println(arr);
        transferAddress(arr);
        System.out.println(Arrays.toString(arr));
    }
}

11. 排序

冒泡排序：冒泡排序是两个元素比较完成以后  符合条件  立即交换位置  这样对于元素的移动比较频繁

选择排序：使用一个元素 依次与其他元素比较大小 遇到需要交换位置的元素  先不交换  等待第一轮比较完成后再交换位置

11.1 冒泡排序

public class TestBubbleSort {
    public static void main(String[] args) {
        int [] nums = {89,56,441,552,6369,741,85};

        int a = 10;
        int b = 20;

//        int temp = a;
//        a = b;
//        b = temp;

        for(int i = 0;i < nums.length-1;i++){ // 控制比较的轮数
            for(int j = 0;j < nums.length -1 -i;j++){

                if(nums[j] < nums[j + 1]){
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
            System.out.println("第"+(i + 1)+"轮比较完成以后数组的顺序为：" + Arrays.toString(nums));
        }
        System.out.println(Arrays.toString(nums));
    }
}

11.2选择排序

/**
 *  选择排序
 *  外层循环属于比较的数A  从第一个元素开始 直到 倒数第二个元素 int i = 0;i < nums.length - 1;i++
 *  内层循环属于比较的数B  永远是从比较的数A相邻的后边的元素开始 int j = i + 1;j < nums.length;j++
 */
public class TestChoiceSort {
    public static void main(String[] args) {
        int [] nums = {8888,89,100,56,441,552,6369,741,85};

        for(int i = 0;i < nums.length - 1;i++){
            int index = i; // index变量默认值和i相同  用来记录最初i的取值 以及在比较过程中交换下标使用
            for(int j = i + 1;j < nums.length;j++){
                if(nums[index] < nums[j]){
                    index = j;
                }
            }
            if(index != i){ // 当这个条件 表示需要交换位置 反之不需要交换
                int temp = nums[index];
                nums[index] = nums[i];
                nums[i] = temp;
            }
        }
        System.out.println(Arrays.toString(nums));
    }
}

11.3 二分查找

二分查找算法：根据指定的元素  查找此元素在序列中的下标 如果未找到  则返回-1 找到则返回对应的下标

前提：必须是有序数组

将序列一分为二，如果查找的元素小于中间值 则从左边开始查找 如果是大于中间值 则从右边查找

如果等于中间值 则直接返回即可 重复以上过程 直到找到 或者循环条件不成立

public class TestBinarySearch {

    public static void main(String[] args) {
        int [] nums = {8888,89,100,56,441,552,6369,741,85};

        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));
        System.out.println(binarySearch(nums, 666));
        System.out.println(Arrays.binarySearch(nums, 666));
    }
    public static int binarySearch(int [] nums,int num){
        int index = -1; // 最终用于返回的下标 默认初识值为-1
        int begin = 0; // 开始位置
        int end = nums.length -1; // 结束位置
        int middle = ( begin + end ) / 2; // 中间位置

        while (begin <= end) { //
            if(num < nums[middle]){
                // 从左边查找
                // 因为是小于中间值 所以查找范围为中间下标左侧的序列
                // 所以此时我们需要改变结束下标的位置
                end = middle -1;
            }else if(num > nums[middle]){
                // 从右边查找
                begin = middle + 1;
            }else{
                index = middle;
                break;
            }
            middle = (begin + end) / 2;
        }
        return index;
    }
}

11.4 数组的插入

1.先创建一个比原来长度长1的数组

2.循环实现元素的移动

      如果  下标小于插入的位置 则直接复制到新数组中

      大于等于插入的位置 则将原数组的元素移动到新数组下标+1的位置

3.将新数组空缺的位置  直接插入元素即可

4.将新数组返回

public class TestArraysInsert {

    public static void main(String[] args) {
        int [] nums = {11,22,33,44,55};
        int[] newArr = insert(nums, 888, 2); // .var 自动生成对应类型的变量接收返回值
        System.out.println(Arrays.toString(newArr));
    }
    /**
     * @param nums 被插入元素的数组
     * @param num 插入元素
     * @param index 插入位置
     * @return
     */
    public static int[] insert(int [] nums,int num,int index){
        if(index < 0 || index > nums.length -1){
            return nums;
        }
        int [] newArr = new int[nums.length + 1];
        for(int i = 0;i < nums.length;i++){
            if(i < index){
                newArr[i] = nums[i];
            }else{
                newArr[i + 1] = nums[i];
            }
        }
        newArr[index] = num;
        return newArr;
    }
}

11.5 数组的删除

1.先创建一个比原数组长度-1的数组

2.循环实现数组的移动

      如果  下标小于插入的位置 则直接复制到新数组中

      如果大于等于插入的位置  则将原数组中的元素  从删除下标+1位置开始

      移动到新数组相应的位置

3.将新数组返回

public class TestArraysRemove {
    public static void main(String[] args) {
        int [] nums = {11,22,33,44,55};
        int[] newArr = remove(nums, 3);
        System.out.println(Arrays.toString(newArr));
    }
    public static int[] remove(int [] nums,int index){
        if(index < 0 || index > nums.length -1){
            return nums;
        }
        int [] newArr = new int[nums.length -1];
        for(int i = 0;i < newArr.length;i++){
            if(i < index){
                newArr[i] = nums[i];
            }else{
                newArr[i] = nums[i + 1];
            }
        }
        return newArr;
    }
}

12. 可变长参数

可变长参数：可接收0个或多个同类型实参，个数不限，使用方式与数组相同。

语法：数据类型...形参名

要求：必须定义在形参列表的最后，且整个形参列表中只能有一个可变长参数。

public class TestModifyParameter {
    public static void m1(int...args){
        for(int i = 0;i < args.length;i++){
            System.out.println(args[i]);
        }
        System.out.println("m1方法执行完毕");
    }
    public static void main(String... args) {
        m1(1,2,3,4,5);
    }
}

13. 二维数组

二维数组：数组中的元素还是（一维数组）数组

定义：与一维数组基本一样 四种方式。特别之处，二维数组在定义的时候，高维度的长度必须指定，低维度可以根据需要 是否立即指定

数组的默认值：引用类型为null

二维数组的遍历，使用嵌套循环

FrankieCao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数组常见算法比较
promiseend的博客
09-21 7817
1.选择排序基本思想： 选择排序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件则交换元素。 算法示例： 如图，先将下标为0的数组元素分别与其他元素相比，23<45,不交换（从小到大排序），再比较23与6，交换……这样将23与其他元素比较后，下标为0的元素变成了6。再将下标为1的元素与下标为2，3，4，5的元素进行比较，经过5轮这样的比较后，就可完成排
js 数组全排列组合算法
weixin_40451409的博客
10-09 2540
function doCombination(arr) { var count = arr.length - 1; //数组长度(从0开始) var tmp = []; var totalArr = [];// 总数组 return doCombinationCallback(arr, 0);//从第一个开始 //js 没有静态数据，为了避免和外部数据混淆...
数组分割算法
weixin_44124986的博客
03-20 1778
W3Cschool数组分割算法挑战： 编写一个函数,把一个数组arr按照指定的数组大小size分割成若干个数组块。 例如:chunk([1,2,3,4],2)=[[1,2],[3,4]]; chunk([1,2,3,4,5],2)=[[1,2],[3,4],[5]]; function chunk(arr, size) { var newArr = []; for(var i = 0...
KMP算法——详解next数组
qq_55229149的博客
12-05 1万+
令人烦恼的next数组,本文是作者自己的理解与思考，并不完善，只是为了提示自己，如果您已研究了KMP算法，本文对您的帮助并不大 next数组完成的任务： 当s1与s2字符串比较到上图所示位置时，拥有next数组的KMP算法不需要像BF算法一样： 将 j 回退到开始的第二个字符 将 i 退回到字符串头部 而是： 将 i 回退到第二个字符b处 j 不动 因为图示位置的前面都是匹配的字符 ， 相匹配的字符串一定具有相同的前缀，所以b，c的比较就显得有点浪费资源，所以只需要找到相同的前缀就可以减少
KMP算法 → 计算nextval数组
hnjzsyjyj的专栏
09-29 4720
【编程技巧】 ● 由于字符串的下标从0开始，因此采用李春葆《数据结构》中的方式定义nextval[0]=-1，nextval[1]=0是很自然的事情。之后，利用语句 cout
KMP算法 → 计算next数组
hnjzsyjyj的专栏
09-28 9214
若在KMP算法设计中，将模式串下标从0开始计数，则定义next[0]=-1，next[1]=0。那么求next数组的算法步骤为： （1）若第j-1位的字符与第x位的字符相等，则next[j]=x+1； （2）若直到第0位依然没有字符与第j-1位的字符相等，则next[j]=0。
数组倒序 c语言算法
m0_73964151的博客
11-26 2361
算法
KMP算法之next数组详解
热门推荐
一点星光
12-03 1万+
KMP算法之next数组详解 KMP算法实现原理 KMP算法是一种非常高效的字符串匹配算法，下面我们来讲解一下KMP算如何高效的实现字符串匹配。我们假设如下主串和模式串： int i;//i表示主串的下标 int j;//j表示模式串的下标 char P[]=“ABCABDACFGHEADEW”;//主串 char T[]=“ABCABAEABD”；//模式串 开始查找 按照正常逻辑，我们都知道，如果我想在主串中匹配“ABCABAEABD”这个模式串，那么我们首先想到的是将主串和模式串中的每个
手算KMP算法nextval数组
专注。
07-24 2156
上一篇文章介绍了手算KMP算法nextl数组。 接下来就来介绍如何通过next数组求得nextval数组。 通过上篇得到的next数组进行讲解. 第一步：nextval数组的第一位必定为0；第二位模式串中元素的值如果与第一位相同则为0，不同为1。 下标 1 2 3 4 5 6 7 8 9 模式串 a b a a b c a b a next 0 1 1 2 2 3 1 2 3 nextval 0 1 第二步：第 3 个元素的next值为 1 ，于是将其与下标为 1
KMP算法&next数组详解
ooblack的博客
10-28 9861
KMP算法详解 文章目录KMP算法详解前言一、示例二、用朴素的字符串匹配算法三、KMP算法实现1、KMP算法思路2、next数组的本质3、next数组带入思路实现4、next数组的求法4、代码实现C语言实现Java语言实现 前言 KMP算法是目前字符串算法里面最高校效的一种算法，相较于朴素的字符串匹配算法，其时间复杂度低得多 提示：以下是本篇文章正文内容，下面案例可供参考 一、示例 给定一个字符串s = “abcabcabd” 另一字符串t = “abcabd”，在s中查找t是否存在，若存在返回t[0]
使用数组实现BOOTH算法
05-23
使用C语言数组实现BOOTH算法。算法思想来源于计算机组成原理。可以参考 唐朔飞.[计算机组成原理](第2版)
php数组冒泡排序算法实例
10-22
主要介绍了php数组冒泡排序算法,以简单实例形式分析了php数组冒泡排序算法的实现原理与相关技巧,需要的朋友可以参考下
JS实现的数组全排列输出算法
10-24
主要介绍了JS实现的数组全排列输出算法,实例分析了全排列的原理与相关的javascript实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
数组和常用算法
10-08
数组和常用算法
[Easy] leetcode-35 搜索插入位置
最新发布
Sofine
05-09 111
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。利用二分查找可以更快的找到，只需要修改返回值即可，注意获取mid的计算方法考虑了溢出。注意到是按顺序排列的数组，那么按顺序遍历，如果找到，则跳出循环返回索引即可。如果找到最后还没找到，则返回数组长度索引值即为插入位置。
C语言 | Leetcode C语言题解之第73题矩阵置零
m0_59237910的博客
05-07 269
C语言 | Leetcode C语言题解之第73题矩阵置零
LeetCode 35.搜索插入位置
tus00000的博客
05-08 192
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。输入: nums = [1,3,5,6], target = 5。输入: nums = [1,3,5,6], target = 2。输入: nums = [1,3,5,6], target = 7。此算法时间复杂度为O(logn)，空间复杂度为O(1)。请必须使用时间复杂度为 O(log n) 的算法。nums 为 无重复元素 的 升序 排列数组。
【算法】高精度乘法
m0_73209194的博客
05-02 522
高精度乘法
C++类和对象（下）（2）
2302_79331124的博客
05-02 789
关于类和对象的内容，至此就结束了，希望大家能从这几篇博客中对类和对象有更加深刻的认识，接下来会继续更新C++的内容。
无序数组查找最优算法
09-30
无序数组的查找算法有很多种，其中一种常见的算法是线性查找。线性查找算法从数组的第一个元素开始逐个比较，直到找到目标元素或者遍历完整个数组。这种算法的时间复杂度是O(n)，其中n是数组的大小。所以，线性查找...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值