数组中的算法

已于 2024-05-19 19:19:57 修改
阅读量15 收藏
点赞数
分类专栏： java学习 文章标签： java
于 2022-03-26 15:00:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45683698/article/details/123756149
版权

文章目录

1. 数组元素的赋值（杨辉三角和回形数等）

1.1 杨辉三角

public class YangHuiTest {
    public static void main(String[] args){
        //对二维数组的初始化
        int[][] yangHui = new int[10][];
        for(int i = 0; i < yangHui.length; i++){
            yangHui[i] = new int[i + 1];
            //对每一行的第一个元素和最后一个元素赋值
            yangHui[i][0] = yangHui[i][i] = 1;
            //从第三行开始，对于非第一个和最后一个元素，即 yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
            for(int j = 1; j < yangHui[i].length-1;j++){
                yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
            }
        }
        for(int i = 0; i < yangHui.length; i++){
            for(int j = 0; j < yangHui[i].length; j++){
                System.out.print(yangHui[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

1.2 拓展之笔试题

创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求元素的值各不相同。

class ArrayExer{
    public static void main(String[] args){
        int[] arr = new int[6];
        for(int i = 0; i < arr.length; i++){
            arr[i] = (int)(Math.random()*30) + 1;
            for(int j = 0; j < i; j++){
                if(arr[i] = arr[j]){
                    j--;
                    break;
                }
            }
        }
        for(int i = 0; i < arr.length; j++){
            System.out.println(arr[i]);
        }
    }
}

1.3 回形数格式方阵的实现

1.3.1 方式一：
class RectangleTest{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int len = scanner.nextInt();
        int[][] arr = new int[len][len];
        
        int s = len * len;
        /*
        k = 1:向右 k = 2:向下 k = 3:向左 k= 4:向上
        */
        int k = 1;
        int i = 0,j = 0;
        for(int m = 1; m < s; m++){
            if(k == 1){
                if(j < len && arr[i][j] == 0){
                    arr[i][j++] = m;
                }else{
                    k = 2;
                    i++;
                    j--;
                    m--;
                }else if(k == 2){
                    if(i < len && arr[i][j] == 0){
                        arr[i++][j] = m;
                    }else{
                        k = 3;
                        i--;
                        j--;
                        m--;
                    }
                }else if(k == 3){
                    if(j >= 0 && arr[i][j] == 0){
                        arr[i][j--] = m;
                    }else {
                        k = 4;
                        i--;
                        j++;
                        m--;
                    }
                }else if(k == 4){
                    if(i >= 0 && arr[i][j] == 0){
                        arr[i--][j] = m;
                    }else{
                        k = 1;
                        i++;
                        j++;
                        m--;
                    }
                }
            }
        }
        for (int m = 0; m < arr.length; m++){
            for(int n = 0; n < arr[m].length; n++){
                System.out.print(arr[m][n] + "\t");
            }
            System.out.println();
        }
    }
}
1.3.2 方式二
class RectangleTest1{
    public static void main(String[] args){
        int n = 7;
        int[][] arr = new int[n][n];
        
        int count = 0;//要显示的数据
        int maxX = n-1;//x轴的最大下标
        int maxY = n - 1;//y轴的最大下标
        int minX = 0;//x轴的最小下标
        int minY = 0;//y轴的最小下标
        while(minX <= maxX){
            for(int x = minX; x <= maxX; x++){
                arr[minY][x] = ++count;
            }
            minY++;
            for(int y = minY; y <= maxY; y++){
                arr[y][maxX] = ++count;
            }
            maxX--;
            for(int x = maxX; x >= minX; x--){
                arr[maxY][x] = ++count;
            }
            maxY--;
            for(int y = maxY; y >= minY; y--){
                arr[y][minX] = ++count;
            }
            minX++;
        }
        for(int i = 0; i < arr.length; i++){
            for(int j = 0; j < arr[i].length; j++){
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

2. 求数值型数组中元素的最大值、最小值、平均数、总和等

定义一个int型的一维数组，包含10个元素。分别赋一些随机整数，然后求出所有元素的最大值，最小值，和值。要求：所有随机数都是两位数

两位数的随机数：Math.random()得到的是一个double型的值

公式：Math.random()*(b - a + 1) + a

3. 数组的复制、反转、查找（线性查找、二分法查找）

3.1 数组的复制

3.1.1 思考

使用简单数组

（1）创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量，它们是int[]类型的数组

（2）使用大括号{},把array1初始化为8个素数：2,3,5,7,11,13,17,19.

（3）显示array1的内容

（4）赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值（如array[0] = 0, array[2] = 2）,打印出array1

思考：array1和array2是什么关系？（array1 和 array2地址值相同，都指向了堆空间中唯一的一个数组实体）

拓展：修改题目：实现array2对array1数组的复制

class ArrayExer{
    public static void main(String[] args){//"alt + /"Eclipse中提示键
        int[] array1,array2;
        array1 = new int[]{2,3,5,7,11,13,17,19};
        
        //显示array1的内容
        for(int i = 0; i < array1.length; i++){
            System.out.print(array1[i] + "\t");
        }
        
        //赋值array2变量等于array1（相当于创建了一个快捷方式，只存了一个地址值）
        //此操作不能称作数组的复制（复制需要再开辟一块空间）
        array2 = array1;
        
        //修改array2中的偶索引元素，使其等于索引值（如array[0] = 0, array[2] = 2）,打印出array1
        for(int i = 0; i < array2.length; i++){
            if(i % 2 == 0){
                array2[i] = i;
            }
        }
        System.out.println();
        for(int i = 0; i < array1.length; i++){
            System.out.print(array1[i] + "\t");
        }
    }
}

array1 和 array2地址值相同，堆空间中只有一个array1 = new int[]{2,3,5,7,11,13,17,19} 这样的数组（new一次有一个，只new了一次，因此只有一个），因此array1和array2都指向这个数组，因此改了array2，相当于改了array1

3.1.2 数组的复制
class ArrayExer1{
    public static void main(String[] args){//"alt + /"Eclipse中提示键
        int[] array1,array2;
        array1 = new int[]{2,3,5,7,11,13,17,19};
        
        //显示array1的内容
        for(int i = 0; i < array1.length; i++){
            System.out.print(array1[i] + "\t");
        }
        
        //数组的复制
        array2 = new int[array1.length];
        for(int i = 0; i < array2.length; i++){
            array2[i] = array1[i];
        }
        
        //修改array2中的偶索引元素，使其等于索引值（如array[0] = 0, array[2] = 2）,打印出array1
        for(int i = 0; i < array2.length; i++){
            if(i % 2 == 0){
                array2[i] = i;
            }
        }
        System.out.println();
        //此情况改了array2，array1不变
        for(int i = 0; i < array1.length; i++){
            System.out.print(array1[i] + "\t");
        }
    }
}

数组的赋值操作总结：

class ArrayTest2{
    public static void main(String[] args){
        String[] arr = new String[]{"jj","dd","gg","aa"};
        //数组的复制(区别于数组变量的赋值)
        String[] arr1 = new String[arr.length];
        for(int i = 0; i < arr1.length; i++){
            arr1[i] = arr[i];
        }
    }
}
3.1.3 数组的反转（数组里面的值的反转）
class ArrayTest3{
    public static void main(String[] args){
        String[] arr = new String[]{"jj","dd","gg","aa","bb"};
        //实现数组反转:方法一：
        for(int i = 0; i < arr.length/2; i++){//此处用小于号而非小于等于号。
            String temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
        
        //方法二：定义两个变量
        for(int i = 0,j = arr.length -1 ;i < j;i++, j--){
            String temp = arr.[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t");
        }
    }
}
3.1.4 数组的查找（线性查找、二分法查找）
线性查找
class SearchTest{
    public static void main(String[] args){
        String[] arr = new String[]{"jj","dd","gg","aa","bb"};
        String dest = "bb";
        
        boolean isFlag = true;
        
        for(int i = 0; i < arr.length; i++){
            if(dest.equals(arr[i])){//比较字符串的内容，可以用equals方法
                System.out.println("找到了指定的元素，位置为：" + i);
                isFlag = false;
                break;
            }
        }
        if(isFlag){
            System.out.println("No find!");
        }
    }
}
二分法查找（也叫折半查找）

前提：所要查找的数组必须有序。

class SearchTest1{
    public static void main(String[] args){
        int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
        int dest = -34;
        int head = 0;//初始的首索引
        int end = arr2.length - 1;//初始的尾索引
        boolean isFlag = true;
        while(head <= end){//循环终止条件：首索引大于尾索引时跳出循环
            int middle = (head + end)/2;//获取中间索引
            
            if(dest == arr2[middle]){
                System.out.println("找到了指定元素，位置为：" + middle);
                isFlag = false;
                break;
            }else if(arr2[middle] > dest){
                end = middle - 1;
            }else{
                head = middle + 1;
            }
        }
        if(isFlag){
            System.out.println("No find!");
        }
    }
}

4. 算法和排序算法的概述

数组中涉及到的常见算法：排序算法

4.1 排序算法的基本概念

a. 排序：假设含有n个记录的序列为{R1,R2, …Rn}，其相应的关键字序列为{K1,K2, …Kn}。将这些记录重新排序为{Ri1，Ri2，…Rin}，使得相应的关键字满足条件Ki1 <= Ki2 <=…<= Kin，这样的一种操作称为排序

通常来说，排序的目的是快速查找

b. 衡量排序算法的优劣：

  1. 时间复杂度：分析关键字的比较次数和记录的移动次数
  2. 空间复杂度：分析排序算法中需要多少辅助内容
  3. 稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。（例如{3,4,1,6,7,8,3’}）排完序后变为（{1,3,3’，4,6,7,8}）即带"'"的3原来在后面，现在还在后面，即称其为稳定的。

c. 排序算法的分类：

内部排序和外部排序

  • 内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成
  • 外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（比如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。

4.2 十大内部排序算法

  • 选择排序

    直接选择排序、堆排序

  • 交换排序

    冒泡排序、快速排序

  • 插入排序

    直接插入排序、折半插入排序、Shell排序（希尔排序）

  • 归并排序

  • 桶式排序

  • 基数排序

较常用的是上面八种

4.3 算法的5大特征

  • 输入（input）
  • 输出（output）
  • 有穷性（有限性，Finiteness）
  • 确定性（明确性，Definiteness）
  • 可行性（有效性，Effectiveness）

4.4 冒泡排序的实现

排序思想：

  1. 比较相邻的元素，如果第一个比第二个大（升序），就交换他们两个；
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数；
  3. 针对所有的元素重复以上的步骤，除了最后一个；
  4. 持续每次对越来越少的元素重复上面的步骤，知道没有任何一对数字需要比较为止。
public class BubbleSortTest{
    public static void main(String[] args){
        int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
        //冒泡排序  n个元素，需要排n-1轮
        for(int i = 0; i < arr.length - 1; i++){
            for(int j = 0; j < arr.length - 1 - i; j++){
                if(arr[j] > arr[j + 1]){//保证索引每次都是除比较过的值之外的最后一个元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t")
        }
    }
}

4.5 快速排序

快速排序通常明显比同为O(nlogn)的其他算法更快，因此常被采用，而且快排序采用了分治法的思想，所以在很多笔试面试中能经常看到快排的影子。可见其重要性

快速排序（Quick Sort）由图灵奖获得者Tony Hoare发明，被列为20世纪十大算法之一，是迄今为止所有内排序算法中速度最快的一种。冒泡排序的升级版，交换排序的一种，快速排序的时间复杂度为O(nlogn)

  • 排序思想：
    1. 从数列中挑出一个元素，称为"基准"（pivot）
    2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆放在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
    3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序
    4. 递归的最底部情形，是数列的大小是0或1，也就是永远都已经被排序好的了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
4.5.4 快速排序演示

在这里插入图片描述

4.5.5 快速排序实现
public class QuickSort{
    private static void swap(int[] data, int i, int j){
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
    private static void subSort(int[] data, int start, int end){
        if(start < end){
            int base = date[start];
            int low = start;
            int high = end + 1;
            while(true){
                while(low < end && data[++low] - base <= 0);
                while(high > start && data[--high] - base >= 0);
                if(low < high){
                    swap(data, low, high);
                }else
                    break;
            }
            swap(data, start, high);
            
            subSort(data,start,high - 1);//递归调用,即方法自己调用自己
            subSort(data, high + 1, end);
        }
    }
    public static void quickSort(int[] data){
        subSort(data, 0, data.length - 1);
    }
    public static void main(String[] args){
        int[] data = {9, -16, 30, 23, -30, -49, 25, 21, 30};
        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
        quickSort(data);
        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
    }
}
琪毅
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++ 数组去重算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-09 5068
使用HashMap：将数组元素作为Key，出现次数作为Value，遍历数组时统计每个元素的出现次数。数组去重算法是一种通过遍历数组，将重复元素删除或替换为不重复的元素的方法。缺点：需要额外的空间存储HashMap，空间复杂度为O(n)，并且可能改变元素的相对顺序。使用双指针：通过双指针，将非重复的元素放到数组的前面，然后截断数组。缺点：需要额外的空间存储Set，空间复杂度为O(n)，并且可能改变元素的相对顺序。优点：不需要额外的空间存储，空间复杂度为O(1)，且保持元素的相对顺序不变；
数组倒置算法
人生代码 ---- 公众号
04-03 4714
数组有许多算法，比如倒置，查找，插入，删除，排序，这些算法都是非常重要的，下面首先介绍倒置算法，所谓倒置算法就是数组的元素中数据倒过来存放。 #include<stdio.h> int main(void) { int a[5] = {1,2,3,4,5}; int b[5]; int i,j; for(i=0,j=4;i<5,j>=0; ++i,--j) { ...
数组常见算法汇总
MrDAW的博客
07-22 1542
数组常见算法汇总 1、寻找数组中的最大值 | 最小值 ` public class max_min { public static void main(String[] args) { int[] nums = {10,20,30,40,33,22,11,8}; //1.创建一个变量，用于存储遍历数组发现的最大值 int n = nums[0]; for (int i = 1; i < nums.length; i++) {
数组分割算法
weixin_44124986的博客
03-20 1795
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...
数组常见算法比较
promiseend的博客
09-21 7857
1.选择排序基本思想： 选择排序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件则交换元素。 算法示例： 如图，先将下标为0的数组元素分别与其他元素相比，23<45,不交换（从小到大排序），再比较23与6，交换……这样将23与其他元素比较后，下标为0的元素变成了6。再将下标为1的元素与下标为2，3，4，5的元素进行比较，经过5轮这样的比较后，就可完成排
数组均分算法题
qq_37668436的博客
06-04 1161
leetcode数组均分，字节面试题
数组逆序算法
05-27 1277
对于数组的逆序算法实现思路无非就是将头与尾对应的元素进行交换，直到完全交换完毕即完成逆序。所以完成交换就是头与尾指针相遇，相遇的位置无非是数组的中间位置。对于给定的数组，中间位置分为两种：即数组元素个数为奇数个数与偶数个数。 1：奇数：{1,2,3} ，length =3 ，mid = 3/...
算法：数组 中位数
yanhaijunyan的博客
10-30 2506
//数组中的中位数 //中位数：当有序数组的元素个数n为奇数时，(n+ 1)/2即最中间那个数字为内容方面的中位数；当有序数组的元素个数n为偶数时，(n/2+(n/2-1))/2即中间位置的两个数字的平均数为内容方面的中位数。 - (void)medianofArrayMethod { int arr[] = {2,6,3,1,7,10,3,5,8,34,56,0,1,4,9,17,13,15,12,33}; int cnt = 20; //冒泡排序 for (int i=.
数组排序算法
子非魚的博客
06-13 6721
以下原理及实现均为个人理解，如有错误或更优解，欢迎留言指正！排序算法概述盗个图转自：https://www.cnblogs.com/onepixel/articles/7674659.html排序算法复杂度备注：以下排序算法默认由小到大排序交换排序冒泡排序算法简介从右向左依次对比相邻元素，将较小值交换到左边；每一轮循环可将最小值交换到最左边；下一轮从之后的位置开始重复1,2 过程，直至完成整个数组...
常用的数组匹配算法-1对n匹配
【03】的博客
07-17 3775
工具代码 /** * 数组一对多匹配 * oneList对应多个moreList * 适用全部 */ function oneToList (oneList, moreList, oneListKey, moreListKey, itemName) { var spareOneList = [] for (var i = 0; i < oneList.length; i++) { spareOne
KnockoutJS数组比较算法实例详解
10-15
在处理动态数据，尤其是数组时，KnockoutJS需要一种算法来跟踪和更新视图模型中的变化，以便及时反映在DOM中。本篇文章主要探讨的是KnockoutJS如何比较两个数组，以确定DOM需要执行哪些操作来保持与数据模型的一致性...
数组的算法.xmind
08-11
数组的算法的思维导图
JavaScript数组去重算法实例小结
10-18
主要介绍了JavaScript数组去重算法,结合实例形式总结分析了JavaScript数组去重相关的读写、遍历、比较、排序等操作及算法改进相关实现技巧,需要的朋友可以参考下
Elsaticsearch java基本操作
最新发布
qq_62383709的博客
07-13 357
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 384
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 448
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1450
在 Java 中，可以通过多种方法将一个Object转换为Integer。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2429
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java 数组分类算法
10-25
Java中的数组分类算法主要包括排序算法和查找算法两类。排序算法可以将数组中的元素按照一定的规则进行排序，常见的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序等。而查找算法则是在已经排好序的数组中查找指定元素的位置，常见的查找算法有线性查找和二分法查找。除此之外，Java中的数组还可以进行复制、反转等操作。在实际编程中，熟练掌握数组分类算法可以提高程序的效率和可读性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值