1. Toy模板网首页
  2. > Toy博客

二维数组(Dyadic Array)

8月前 作者：JavacKaka 分类：Toy博客 阅读(40) 违法举报

这篇具有很好参考价值的文章主要介绍了二维数组(Dyadic Array)。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

二维数组(Dyadic Array)

一维数组 : 数组中直接存放数据

二维数组 : 数组中存放数组

二维数组可以看成以数组为元素的数组。就是一个特殊的一维数组,其每一个元素都是一个一维数组

String[][] str = new String[3][4];//String类型二维数组举例

其实多维数组不仅仅只有二维数组,还有三维数组,四维数组…, 但是三维以上很少见到,所以大家重点了解二维数组即可.

1.举例

int [][] a = {{1,2},{3,4,0,9},{5,6,7}};

二维数组,JAVA,java,数据结构,算法

2.二维数组的声明

		数据类型  变量名;     -->变量声明
        数据类型[] 数组名;    -->一维数组声明
        数据类型[][] 数组名;  -->二维数组声明

3.二维数组的初始化

3.1.动态初始化

数组定义与为数组元素分配空间和赋值的操作分开进行

数据类型[][] 数组名 = new 数据类型[一维][二维];

注意:这种初始化方式,每一个内层的二位数组长度相同

int[][] a=new int[3][2];
a[0][0] = 1;
a[0][1] = 2;

二维数组,JAVA,java,数据结构,算法

动态初始化  : 创建二维数组的同时赋值(内部一维数组创建+每一个一维数组中的数据)
    创建外层二维数组同时创建内层每一个一维刷组+没有赋值数据,存在默认值
    	数据类型[][] 数组名 = new 数据类型[外层二维数组长度][内层一维数组长度];
	创建外层二维数组,内层每一个一维数组在后续确定时单独创建+赋值数据
        数据类型[][] 数组名 = new 数据类型[外层二维数组长度][];

int[][] a=new int[3][];
arr[0]=new int[2];
arr[1]=new int[]{3,4,5,6};
arr[2]=new int[]{7,8,9};
arr[0][0] = 1;
arr[0][1] = 2;

二维数组,JAVA,java,数据结构,算法

3.2.静态初始化

在定义数组的同时就为数组元素分配空间并赋值

数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};
数据类型[][] 数组名 = {{...},{...},{...}}; --简化写法

int[][] arr1=new int[][]{{5,4,8},{3,8},{1}};
char[][] arr2={{'a'},{'b','c'}};

4.二维数组的使用

  • 根据索引进行使用
  • 数组数组名 [外层二维索引] [内层一维索引]

4.1.数组的遍历

双重循环实现多维数组的遍历

/*
    二维数组的遍历方式 :
        1.for
        2.foreach
        以上两种循环任意嵌套
 */
public class ArrayTest {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5},{6}};
		//	for循环嵌套加强for
        //for-->foreach
        for(int i=0;i<arr.length;i++){//
            for(int j:arr[i]){
                System.out.println(j);
            }
        }
		//	两个加强for嵌套
        //foreach-->foreach
        for(int[] a:arr){
            for(int i:a){
                System.out.println(i);
            }
        }
    }
}

public class AraayEachTest {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5},{6,7}};
        //for嵌套for
       for (int i = 0; i < arr.length; i++) {
           for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
       }
        //System.out.println(Arrays.deepToString(arr));//返回指定数组内容的字符串表示形式。
        //for 嵌套each
       for (int i = 0; i < arr.length; i++) {
            for (int a:arr[i]
                ) {
                System.out.println(a);
            }
        }
//        //each 嵌套each
//        for (int[] a:arr
//             ) {
//            for (int b:a
//                 ) {
//                System.out.println(b);
//            }
//        }
//        //each 嵌套for
//        for (int[] i:arr
//             ) {
//            for (int j = 0; j < i.length; j++) {
//                System.out.println(i[j]);
//            }
//        }
    }
}

Arrays中提供操作多维数组的方法:

package com.arraytest;

import java.util.Arrays;//它提供的所有方法都是静态的。

public class AraayEachTest {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5},{6,7}};
        int[][] arr2 = {{1,2,3},{4,5},{6,7}};
        int[][] arr1 = {{1,2,3},{4,5},{6,7}};
        int[] arr3 = {3,1,5,8,9};
        System.out.println(arr1);//打印对象地址
        System.out.println(Arrays.deepToString(arr1));//返回指定数组的“深层内容”的字符串表示形式
        System.out.println(arr== arr2);//false   地址不一样
        System.out.println(Arrays.equals(arr,arr2));//false
        System.out.println(Arrays.deepEquals(arr,arr2));//如果两个数组彼此深度相等，则返回 true
        //将数组升序排序
        System.out.println(Arrays.toString(arr3));
        Arrays.sort(arr3);
        System.out.println(Arrays.toString(arr3));
        //二进制搜索指定值
        System.out.println(Arrays.binarySearch(arr3,8));//数值8在下标3的位置
        System.out.println(Arrays.binarySearch(arr3,10));//-6如果不存在,返回 -插入点-1
        System.out.println(Arrays.binarySearch(arr3,100));//-6
    }
}

import java.lang.reflect.Array;
import java.util.Arrays;

/*
    Arrays :
        该类包含用于操作数组的各种方法（例如排序和搜索）。
        java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。具有但不限于以下功能:
         给数组赋值：通过fill方法。
         对数组排序：通过sort方法,按升序。
         比较数组：通过equals方法比较数组中元素值是否相等。
         查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

 */
public class Class001_Arrays {
    public static void main(String[] args) {
        int[] arr1 ={3,1,5,2,4};
        int[] arr2 ={3,1,5,2,4};
        int[] arr5 ={13,1,5,2,14};

        int[][] arr3 = {{1,2,3},{4,5},{6}};
        int[][] arr4 = {{1,2,3},{4,5},{6}};

        //static String toString(int[] a) 返回指定数组内容的字符串表示形式。
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr3));

        //static String deepToString(Object[] a) 返回指定数组的“深层内容”的字符串表示形式。
        System.out.println(Arrays.deepToString(arr3));

        //static boolean equals(int[] a, int[] a2) 如果两个指定的int数组彼此 相等 ，则返回 true 。
        System.out.println(arr1==arr2);
        System.out.println(Arrays.equals(arr1,arr2));

        //static boolean deepEquals(Object[] a1, Object[] a2) 如果两个指定的数组彼此 深度相等 ，则返回 true 。
        System.out.println(Arrays.deepEquals(arr3,arr4));

        //static boolean equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex) 如果指定范围内的两个指定的int数组彼此 相等 ，则返回true。
        System.out.println(Arrays.equals(arr2,1,4,arr5,1,4));

        //static void fill(int[] a, int val) 将指定的int值分配给指定的int数组的每个元素。
        //static void fill(int[] a, int fromIndex, int toIndex, int val) 将指定的int值分配给指定的int数组的指定范围的每个元素。
        //注意 : 一般指定结束索引位置都不包含
        int[] arr6 = new int[10];
        System.out.println(Arrays.toString(arr6));
        Arrays.fill(arr6,100);
        System.out.println(Arrays.toString(arr6));
        Arrays.fill(arr6,3,6,1);
        System.out.println(Arrays.toString(arr6));

        //static void sort(int[] a) 将指定的数组按升序排序。
        System.out.println(Arrays.toString(arr1));
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));
        //static void sort(int[] a, int fromIndex, int toIndex) 按升序对数组的指定范围进行排序。
        System.out.println(Arrays.toString(arr2));
        Arrays.sort(arr2,1,4);
        System.out.println(Arrays.toString(arr2));
        //定义字符数组|字符串数组|double数组,使用Arrays.sort对其数据做升序排序

        //static int binarySearch(int[] a, int key) 使用二进制搜索算法在指定的int数组中搜索指定的值。
        System.out.println(Arrays.binarySearch(arr1,6));  //如果不存在,返回-插入点-1

    }
}

5.附部分练习题

5.1 二维数组遍历求和操作：

用二重循环求出二维数组b所有元素的和

package com.task.d11_array;
/*6.二维数组遍历求和操作：用二重循环求出二维数组b所有元素的和：
 int[][] b={{11},{21,22},{31,32,33}}*/
public class Sum06 {//双层普通for循环
    public static void main(String[] args) {
        int sum = 0;//计数器
        int[][] b={{11},{21,22},{31,32,33}};//数组静态初始化
        for (int i = 0; i < b.length; i++) {//遍历外层二维数组
            for (int j = 0; j < b[i].length; j++) {//遍历内层一维数组
                sum += b[i][j];//两个下标位置识别一个数
            }
        }
        System.out.println(sum);//输出150
    }
}
/*接下来其余三种组合的循环遍历*/
class S2{//第二种,普通for,内层嵌套foreach
    public static void main(String[] args) {
        int sum = 0;
        int[][] b={{11},{21,22},{31,32,33}};//数组静态初始化
        for (int i = 0; i < b.length; i++) {//外层普通for
            for (int j:b[i]) {//内层增强for
                sum += j;//每次循环出一个数j
            }
        }
        System.out.println(sum);//输出150
    }
}
class S3{//第三种两层foreach循环嵌套
    public static void main(String[] args) {
        int sum = 0;
        int[][] b={{11},{21,22},{31,32,33}};//数组静态初始化
        for(int[] a:b){//外层循环,得到一个数组,因此用int[]类型接收,数组名是a
            for(int i:a){//内层循环,a数组,得到每一个值
                sum += i;
            }
        }
        System.out.println(sum);
    }
}
class S4{//第四种 外层foreach 嵌套内层for循环
    public static void main(String[] args) {
        int sum = 0;
        int[][] b={{11},{21,22},{31,32,33}};//数组静态初始化
        for(int[] a:b){
            for (int i = 0; i < a.length; i++) {//循环遍历a数组
                sum += a[i];//得到每一个索引i位置的元素
            }
        }
        System.out.println(sum);
    }
}

5.2 数组查找操作：

定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。

package com.task.d11_array;

import java.util.Scanner;

/*1.数组查找操作：定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。*/
public class Check01 {
    public static void main(String[] args) {
        String[] arr = new String[10];//定义长度为10的一维字符串数组
        arr[0] = "lbj";//给数组赋值
        arr[1] = "kb";
        arr[2] = "kd";
        arr[3] = "cp3";
        arr[4] = "kaka";
        arr[5] = "messi";
        arr[6] = "ad";
        arr[7] = "kg";
        arr[8] = "dw";
        arr[9] = "msn";
        Scanner sc = new Scanner(System.in);//创建对象
        System.out.println("请输入需要查找的内容:");
        String in = sc.next();//使用功能,接收键盘输入信息
        boolean flag = false;//布尔类型声明并赋值
        for(String s:arr){//foreach遍历
            if(s.equals(in)){//用equals方法比较是否对象深度内容相同
                flag = true;
            }
        }
        if(flag){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
        
    }
}

/*数组排序及元素查找*/
public class ArrOrder {
    public static void main(String[] args) throws Exception{//main方法,抛出异常
        int[] arr = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
        Arrays.sort(arr);//sort方法给数组排序
        printArr("数组排序结果是:",arr);
        System.out.println("-----------换行----------");
        int index = Arrays.binarySearch(arr,4);//查找数组中元素
        System.out.println("元素4的下标位置是"+index);
    }
    private static void printArr(String str,int[] arr){
        System.out.println(str+"[数组长度:"+ arr.length +"]");
        for (int i:arr
             ) {
            System.out.print(" "+i);
        }
    }
}
/*数组排序结果是:[数组长度:10]
 -9 -7 -3 -2 0 2 4 5 6 8-----------换行----------
元素4的下标位置是6*/

5.3 获取数组最大值和最小值操作

package com.task.d11_array;
/*获取数组最大值和最小值操作：利用Java的Math类的random()方法，编写
函数得到0到n之间的随机数，n是参数。并找出产生50个这样的随机数中最大的、最小
的数，并统计其中>=60的有多少个。*/
public class GetMaxMin02 {
    public static void main(String[] args) {
        int[] arr = getArray(100);
        printArr(arr);
        int min = getMin(arr);
        int max = getMax(arr);
        System.out.println("数组中最大值和最小值分别是"+max+"和"+min);
        int count = count(arr,60);
        System.out.println("数组中大于或者等于60的数的个数是"+count);
    }
    //创建一个数组对象,并且初始化50个随机数
    public static int[] getArray(int n){
        int[] arr = new int[50];//静态声明,长度50个
        for (int i = 0; i < 50; i++) {//遍历
            arr[i] = (int)(n*Math.random());//给每个索引赋值随机数
        }
        return arr;
    }
    //数组遍历
    private static void printArr(int[] arr){
        System.out.println("输出数组元素");
        for (int i = 0; i < arr.length; i++) {
            if(i%10 == 0){
                System.out.println();
            }
            System.out.print(arr[i]+"\t");
        }
    }
    //最大值
    private static int getMax(int[] arr){
        int max = arr[0];
        for(int m:arr){
            if(max < m){
                max = m;
            }
        }
        return max;
    }
    //最小值
    private static int getMin(int[] arr){
        int min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(min > arr[i]){
                min = arr[i];
            }
        }
        return min;
    }
    //统计数组中大于等于60
    public static int count(int[] arr,int num){
        int count = 0;
        for(int v:arr){
            if(v >= num){
                count++;
            }
        }
        return count;
    }
}

/*数组倒序实例*/
public class ReverseTest {
    private static int[] reverse;

    public static void main(String[] args) {
        int[] arr1 = {1,3,4,7,9};
        for(int i:arr1){
            System.out.print(i+" ");//不换行遍历输出原来数组内容
        }
        System.out.println("\n");
        arr1 = ReverseTest.reverse(arr1);
        for(int i: arr1){
            System.out.print(i+" ");
        }
    }

    public static int[] reverse(int[] arr){//返回值是新数组配合return 形参是数组
        int[] res = new int[arr.length];//动态声明初始化新数组,数组长度不变
        for (int i = 0, j = res.length-1; i < arr.length ;i++,j--) {
            res[j] = arr[i];//新数组最后一位就等于原数组第一位
        }
        return res;//返回新数组
    }
}

5.4 获取数组长度

/*获取数组长度*/
public class Arr_Length {
    public static void main(String[] args) {
        String[][] str = new String[3][8];
        System.out.println("第一维数组长度是:"+str.length);
        System.out.println("第二维数组长度是:"+str[0].length);
/*第一维数组长度是:3
第二维数组长度是:8*/
        int[][] arr = {{1,2},{3,4,5},{6,7,8,9}};
        int rows = arr.length;//行的长度
        int cols = arr[0].length;//列的长度
        int c = arr[1].length;
        int co = arr[2].length;
        System.out.println(rows);//3
        System.out.println(cols);//2
        System.out.println(c);//3
        System.out.println(co);//4
    }
}

5.5 数组反转

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;

/*数组倒序实例*///数组反转
public class ReverseTest {
    private static int[] reverse;
		//方法一测试
    public static void main(String[] args) {
        int[] arr1 = {1,3,4,7,9};
        for(int i:arr1){
            System.out.print(i+" ");//不换行遍历输出原来数组内容
        }
        System.out.println("\n");
        arr1 = ReverseTest.reverse(arr1);//调用方法一
        for(int i: arr1){
            System.out.print(i+" ");
        }
        System.out.println("----------");
        
        //调用方法二测试
        int[] arr3 = {1,2,3,4};
        rever(arr3,arr3.length);
        /*9 7 4 3 1 反转后的数组是:
            1 3 4 7 9 */
        System.out.println("===========");
        
        //调用方法三测试
        int[] arr4 = {10,11,12,14,17};
        runoobtest(arr4,arr4.length);
        System.out.println("---------");
		
        //方法四测试
        Integer[] arr2 = {1,2,3,4,5};
        re(arr2);//[5, 4, 3, 2, 1]
    }
    
    //方法一
    public static int[] reverse(int[] arr){//返回值是新数组配合return 形参是数组
        int[] res = new int[arr.length];//动态声明初始化新数组,数组长度不变
        for (int i = 0, j = res.length-1; i < arr.length ;i++,j--) {
            res[j] = arr[i];//新数组最后一位就等于原数组第一位
        }
        return res;//返回新数组
    }
    
    //方法二:
    public static void rever(int[] arr,int n){
        int[] arr1 = new int[n];
        int j = n;
        for (int i = 0; i < n; i++) {
            arr1[j-1] = arr[i];
            j--;
        }
        System.out.println("反转后的数组是:");
        for (int i = 0; i < n; i++) {
            System.out.print(arr1[i]+" ");
        }
    }
    
    //方法三:
    public static void runoobtest(int[] arr,int n){
        //0和n-1换,1和n-1-1换,2和-n-1-2换
        int c;
        for (int i = 0; i < n/2 ; i++) {

             c = arr[i];
            arr[i] = arr[n-i-1];
            arr[n-i-1] = c;
        }
        System.out.println("新数组是:\n");
            for (int j = 0; j < n; j++) {
                System.out.print(arr[j]+" ");
            }
    }
    
    //方法四:
    static void re(Integer arr[]){
        Collections.reverse(Arrays.asList(arr));
        System.out.println(Arrays.asList(arr));
    }
}

5.6 杨辉三角

public class YangHuiTest {
    public static void main(String[] args) {
        int[][] arr = new int[10][];
        arr[0] = new int[]{1};
        arr[1] = new int[]{1,1};
        for (int i = 2; i < arr.length; i++) {
            arr[i] = new int[i+1];
            arr[i][0] = arr[i][i] = 1;
            for (int j = 1; j < i; j++) {
                arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
            }
        }
        for (int[] arr1:arr
             ) {
            for (int i:arr1
                 ) {
                System.out.print(i+" ");
            }
            System.out.println();
        }
    }
}

//打印结果如下
1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 
1 6 15 20 15 6 1 
1 7 21 35 35 21 7 1 
1 8 28 56 70 56 28 8 1 
1 9 36 84 126 126 84 36 9 1

寄 语:

我们与成功之间并不遥远，
许多非凡的成就只不过是简单坚持的结果， 关键是要守住你的初心~``

​文章来源地址https://www.toymoban.com/news/detail-842913.html

到了这里，关于二维数组(Dyadic Array)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 数据结构——用Java实现数组

    数据结构是一门基础的学科，是研究数据如何在计算机中进行组织和存储，使得我们可以高效的获取数据和修改数据的。 1.线性结构：数组、队列、栈、链表、哈希表… 2.树形结构：二叉树、二分搜索树、AVL树，红黑树、堆、Trie、线段树、并查集… 3.图结构：邻接矩阵、邻接

    2024年01月18日
    浏览(47)

  • Java 与数据结构（1)：数组

    数组是一种线性数据结构，可以将一组相同类型的数据元素存储在顺序的连续内存空间中。每个元素都可以通过索引访问，索引通常从0开始。 在计算机内存中，数组的每个元素都占用相同的存储空间，这使得元素的访问变得更加高效，时间复杂度为O(1)。数组的长度一旦确定

    2024年02月04日
    浏览(35)
  • 数据结构Java版（1）——数组

    数据结构Java版（1）——数组

    是一门基础学科 研究的是数据如何在计算机中进行组织和存储，使得我们可以高效的获取数据和修改数据 数据结构可以分为三类： 线性结构： 数组、队列、栈、链表、哈希表… 树型结构：二叉树、二分搜索树、AVL树，红黑树、堆、Trie、线段树、并查集… 图结构：邻接矩阵

    2024年01月19日
    浏览(44)
  • java数据结构与算法刷题-----LeetCode240. 搜索二维矩阵 II

    java数据结构与算法刷题-----LeetCode240. 搜索二维矩阵 II

    java数据结构与算法刷题目录（剑指Offer、LeetCode、ACM）-----主目录-----持续更新(进不去说明我没写完)： https://blog.csdn.net/grd_java/article/details/123063846 解题思路 法一：把整个数组遍历一遍，时间复杂度O(m*n) 法二：每一行用二分搜索，那么时间复杂度就是O(m * l o g 2 n log_2{n} l o g

    2024年01月22日
    浏览(61)
  • Java 数据结构篇-用链表、数组实现栈

    Java 数据结构篇-用链表、数组实现栈

    🔥博客主页： 【 小扳_-CSDN博客】 ❤感谢大家点赞👍收藏⭐评论✍    文章目录         1.0 栈的说明         2.0 用链表来实现栈         2.1 实现栈 - 入栈方法（push）         2.2 实现栈 - 出栈（pop）         2.3 实现栈 - 查看栈顶元素（peek）         2.4 实

    2024年02月05日
    浏览(58)
  • Java 数据结构篇-用链表、数组实现队列（数组实现：循环队列）

    Java 数据结构篇-用链表、数组实现队列（数组实现：循环队列）

    🔥博客主页： 【 小扳_-CSDN博客】 ❤感谢大家点赞👍收藏⭐评论✍   文章目录         1.0 队列的说明         1.1 队列的几种常用操作         2.0 使用链表实现队列说明         2.1 链表实现队列         2.2 链表实现队列 - 入栈操作         2.3 链表实现队

    2024年02月05日
    浏览(40)
  • 数据结构实验之矩阵的运算器（二维数组）

    数据结构实验之矩阵的运算器（二维数组）

    实验目的 掌握并学会运用数组及相关知识 掌握矩阵相关运算的代码实现 学会小组的分工与合作 体会封装的好处 实验任务及要求 要求实现矩阵的计算器，能供用户选择不同菜单，进而实现不同存储形式及调用相应计算的算法，并记录运算过程。 运算程序主要包括：①矩阵的

    2024年01月15日
    浏览(37)
  • 【数据结构】二维数组的行优先、列优先存储问题

    【数据结构】二维数组的行优先、列优先存储问题

    今天同学问我一道感觉很基础的数据结构问题，虽然答案做对了，但是原理一直比较迷，仔细看了一下题，原来是自己把自己绕进去了。。。在此记录一下，大佬如果有更好的方法，可以在评论区留言，不定期更新。 先给出行优先和列优先的计算公式： 设数组为A[m][n]（ m 行

    2024年02月10日
    浏览(55)
  • 数据结构二维数组计算题，以行为主？以列为主？

    数据结构二维数组计算题，以行为主？以列为主？

    1.假设以行序为主序存储二维数组A=array[1..100,1..100]，设每个数据元素占2个存储单元，基地址为10，则LOC[5,5]=（  ）。 A．808            B ． 818             C．1010             D．1020 答案： B 解释：以行序为主，则 LOC[5,5]=[ （ 5-1 ） *100+ （ 5-1 ） ]*2+10=818 。 2

    2024年02月05日
    浏览(48)

  • 用java以数组为底层数据结构创建自己的栈

    栈可以解决什么问题呢： 1.括号匹配问题 2.递归 3.表达式求值问题 首先明确栈的功能： 1.入栈：给底层数组的尾部插入元素相当于入栈 2.出栈：把底层数组的最后一个元素提出来相当于出栈 3.获取栈长度：获取size 4.判断栈是否为空：底层数组size==0则为空 5.获取栈顶:返回底层

    2024年01月20日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包