线性数据结构之数组、数组栈、数组队列以及稀疏数组实现

最新推荐文章于 2024-09-26 22:55:54 发布
最新推荐文章于 2024-09-26 22:55:54 发布
阅读量95 收藏
点赞数
文章标签： 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53324833/article/details/121133101
版权

前言

本章详细阐述了数组这一种线性数据结构的使用方法以及相关操作。

数组的基本使用方法

下面程序示范了数组的基本使用方法。

package 数组;

public class 数组的基本使用 {
    public static void main(String[] args) {
        //创建一个数组
        int[] arr1 = new int[3];
        //获取数组长度
        int length1 = arr1.length;
        //打印数组长度
        System.out.println("arr1's length" + length1);
        //访问数组中的元素：数组名[下标] 注意：下标从0开始，最大可以取到：数组长度-1
        int element0 = arr1[0];
        //打印数组第一个元素的值
        System.out.println("element0:"+element0);
        //为数组中的元素赋值
        arr1[0] = 99;
        System.out.println("element0:"+element0);
        arr1[1] = 98;
        arr1[1] = 97;
        //遍历数组
        for (int i = 0; i < length1; i++) {
            System.out.println("arr1 element"+i+":"+arr1[i]);
        }
        //创建数组的另一种方式，创建同时为数组中的元素赋值
        int[] arr2 = new int[]{90,98,97};
    }
}

但从上面的程序中我们可以很容易的看出来，就是数组的长度拥有不可变性，因为数组一旦被定义之后，即长度和地址空间就是确定的了，想要更改就很不容易，对其元素的增加和删除都会很麻烦，但麻烦归麻烦，我们有解决办法。

数组元素的添加

比如原数组arr长度为3并且有三个值，现在我们想要让该数组添加一个新的值在后面，怎么办呢？
我们的想法是：
因为数组长度不可变，且原数组arr长度为3并且有三个值，那么我们会新建一个数组叫newArr，这个数组我们定义长度为4，我们将arr原数组的三个值都赋给newArr这个新数组，然后将newArr的最后一个元素位置赋上要添加的那个元素的值，最后将arr引用指向我们的新数组newArr即可。
代码如下：

package 数组;

import java.util.Arrays;

public class 数组的基本使用 {
    public static void main(String[] args) {

        //解决数组长度不可变的问题
        int[] arr = new int[]{9,8,7};
        //快速打印数组中的元素方法
        System.out.println(Arrays.toString(arr));
        //要添加到数组的新元素
        int dst = 6;

        //创建一个新数组，长度为原数组的长度+1
        int[] newArr = new int[arr.length+1];
        //把原数组的值都赋给新数组
        //注意这里的终止循环条件应该是i小于原数组的长度
        //如果是小于新数组的长度的话，因为新数组比原数组长的缘故，会导致数组下标越界异常
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];
        }
        //打印一下新数组的元素
        System.out.println(Arrays.toString(newArr));
        //将新数组的最后一个值赋上我们的目标添加元素
        newArr[3] = dst;
        //将arr原数组的引用指向我们的新数组
        arr = newArr;
        //打印arr数组
        System.out.println(Arrays.toString(arr));

    }
}

数组元素的删除

比如现在我们有一个数组，它包含的元素有9，8，7，6，5，现在我们要删除7这个元素，怎么做？
我们的想法是：
同上面添加元素的方法相同，因为数组的不可变性，所以我们要创建一个新数组newArr，它的长度定义为原数组长度-1（因为是删除一个元素），然后我们只要将除了要删除的元素以外的其他元素都放进新数组里面，最后将原数组的引用指向新数组即可。
代码如下：

package 数组;

import java.util.Arrays;

public class 数组的基本使用 {
    public static void main(String[] args) {

        //目标数组
        int[] arr = new int[]{9,8,7,6,5};
        //已知要删除的元素是7，,其下标为2
        int dst = 2;

        //创建一个新数组，原数组长度为5，那么新数组长度为5-1=4
        int[] newArr = new int[4];

        //使用循环将原数组的值赋进新数组中
        for (int i = 0; i < newArr.length; i++) {
            //要删除的元素的前面的所有元素，那么直接赋值
            if(i < dst){
                newArr[i] = arr[i];
            }else{
                //到要删除的元素的后面的所有元素了
                //因为原数组arr比新数组newArr多一个要被删除的元素，所以应该将其加1
                newArr[i] = arr[i+1];
            }
        }
        //将原数组的引用指向我们所创建的新数组
        arr = newArr;
        //输出答案
        System.out.println(Arrays.toString(arr));

    }
}

数组元素的插入

这算一个上面删除问题的一个延伸叭，思想都差不多，直接上代码：

package 数组;

import java.util.Arrays;

public class 数组的基本使用 {
    public static void main(String[] args) {

        //目标数组
        int[] arr = new int[]{9,8,6,5};
        //已知要插入的元素是7,其目标插入的位置下标为2
        int dstNum = 7; //插入的元素值
        int dstLoc = 2; //插入的数组中的位置
        //创建一个新数组，原数组长度为4，那么新数组长度为4+1=5
        int[] newArr = new int[5];

        //使用循环将原数组的值赋进新数组中
        for (int i = 0; i < newArr.length; i++) {
            //当i 小于 dstLoc时，直接赋值即可
            if(i < dstLoc){
                newArr[i] = arr[i];
            }else if(i == dstLoc){
                //当i 等于 dstLoc时，将目标插入值赋给新数组
                newArr[i] = dstNum;
            }else{
                //当i 大于 dstLoc时，因为原数组比新数组少一个，
                //且因为在i == dstLoc判断时i自加了一次，
                // 所以原数组此时下标应该-1来给新数组进行赋值
                //否则将会数组越界异常
                newArr[i] = arr[i-1];
            }
        }
        //将原数组的引用指向新数组
        arr = newArr;
        //打印答案
        System.out.println(Arrays.toString(arr));
        //将原数组的引用指向我们所创建的新数组

    }
}

类ArrayList集合的底层实现过程

但是在实际使用当中，我们在进行数组的增删改查时不会像上面一样写的这么繁琐，这是因为Java的基础类库中已经替我们封装好了一些数据结构集合API，我们可以直接使用，比如ArrayList，现在我们可以自己来实现一个ArrayList集合，通过上面的知识，可以巩固一下基础，以加深对数组这种数据结构的理解：

package 数组;

import java.util.Arrays;

public class MyArray {
    //类变量
    //创建一个用于存储数据的数组
    private int[] elements;

    //方法
    //new对象时就初始化这个数组
    public MyArray(){
        elements = new int[0];
    }

    //获取数组长度
    public int size(){
        return elements.length;
    }

    //往数组末尾添加一个元素
    public void add(int element){
        //创建一个新数组
        int[] newArr = new int[elements.length+1];
        //把原数组中的元素赋值到新数组中
        for (int i = 0; i < elements.length; i++) {
            newArr[i] = elements[i];
        }
        //把添加的元素放入到新数组中
        newArr[elements.length] = element;
        //使用新数组替换旧数组
        elements = newArr;
    }

    //删除数组中的元素,index是要删除第几个位置元素的索引
    public void delete(int index){
        //判断下标是否越界
        if(index < 0 || index > elements.length-1){
            throw new RuntimeException("数组下标越界异常");
        }
        //创建一个新数组,长度为原数组-1
        int[] newArr = new int[elements.length-1];
        //循环将原数组的值放入新数组中
        for (int i = 0; i < newArr.length; i++) {
            //i 小于 要删除目标位置元素的索引，则直接赋值即可
            if(i < index){
                newArr[i] = elements[i];
            }else{ //i 大于等于 要删除目标位置元素的索引时，则原数组的索引应该+1再赋值
                newArr[i] = elements[i+1];
            }
        }
        //将原数组引用指向新数组
        elements = newArr;
    }

    //取出指定位置的元素,index是获取哪一个元素的下标索引
    public int get(int index){
        return elements[index];
    }

    //插入一个元素到指定位置,index插入的位置索引，element是插入的元素值
    public void insert(int index, int element){
        //判断下标是否越界
        if(index < 0 || index > elements.length-1){
            throw new RuntimeException("数组下标越界异常");
        }
        //创建一个新数组
        int[] newArr = new int[elements.length+1];
        //将原数组中的元素赋值到新的数组中
        for (int i = 0; i < elements.length; i++) {
            //目标位置之前的元素，直接赋值
            if(i < index){
                newArr[i] = elements[i];
            }else{ //目标之后的元素
                newArr[i+1] = elements[i];
            }
        }
        //执行完上面的循环之后我们会发现，我们需要插入的元素还没插
        //所以我们在循环结束后，将其插入新数组中
        newArr[index] = element;
        //将原数组引用指向新数组
        elements = newArr;
    }

    //替换指定位置的元素
    public void set(int index,int element){
        //判断下标是否越界
        if(index < 0 || index > elements.length-1){
            throw new RuntimeException("数组下标越界异常");
        }
        elements[index] = element;
    }

    //打印所有元素到控制台
    public void show(){
        System.out.println(Arrays.toString(elements));
    }



}

数组的线性查找算法

功能：输入我们要查找的元素的值，然后进行查找，查找成功则返回该元素位置的下标，找不到则返回-1
代码如下：

public class Main {
    public static void main(String[] args) {
        //查找的目标数组
        int[] arr = new int[]{2,3,5,6,8,4,9,0};
        //查找的目标元素值
        int target = 8;
        //查找的目标元素所在下标
        int index = -1;
        //遍历数组查找所求的目标值
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == target) {
                index = i;
                break; //找到之后停下循环，以节省运行时间
            }
        }
        //输出index，为-1则没有找到，不为-1则已经找到
        System.out.println("index: "+index);
    }
}

数组的二分查找算法

线性查找算法效率比较低，而二分查找则会高些。
但是二分查找算法也有缺点，它有前置需求就是：我们所要查找的这个数组必须是有序的，否则不能使用二分查找。
思路：

用一个begin开始指针指向数组的第一个元素，用一个end指针指向数组的最后一个元素，再用一个mid指针指向数组的中间元素（即(end+begin)/2的值），怎么样，这二分是不是很形象？
然后每一次循环，先判断查找的目标值是否与我们的中间mid值相等，相等则说明找到了不相等则说明没有，这个时候再判断我们的中间值是比目标值大还是小，因为数组是有序的，所以如果中间值比目标值大，那么我们第二次循环缩小查找范围，查找中间值往左的区域（因为目标值小于我们的中间值，说明在左侧），即end值发生变化，它将指向mid - 1的位置（因为mid值已经与目标值比较过了，所以指向mid-1而不是mid），而这时mid也要刷新，它将在左侧区域去指向一个新的中间值，即mid = (begin+end)/2;
但如果我们的中间值是比目标值小的话，分析思路同上，那么目标值应该是位置我们中间值的右侧，这时我们改变的则是begin的值，它将指向mid+1的位置，此时也要刷新mid的值。然后如此反复循环，直到查找到我们要的目标元素或者查找完了所有元素。
但我们应该有一个循环结束的标记，即在所有元素都被查找完之后也没查找到目标值时起作用，那么什么时候才是查找完呢？
其实很好想，就是当左边的指针（begin）变化到了右边指针（end）的后面（或相等于右边指针）时，表示所有元素已经被遍历完。

代码如下：

public class Main {
    public static void main(String[] args) {

        //目标数组，必须有序
        int[] arr = new int[]{1,2,3,4,5,6,7,8,9};
        //目标元素
        int target = 8;
        //begin指针指向数组的第一个元素
        int begin = 0;
        //end指针指向数组的最后一个元素
        int end = arr.length-1;
        //mid指针记录每一次查找的中间位置
        int mid = (begin+end) / 2;
        //记录查找元素目标的下标索引
        int index = -1;

        //循环查找
        while (true){
            //判断此时是否已经遍历完所有元素
            if(begin >= end) break;
            //判断中间的这个元素是不是我们的目标查找元素
            if( arr[mid] == target){
                index = mid;
                break;
            }else{
                //中间这个元素不是我们要查找的元素
                //那么我们判断它是比我们的目标元素的索引位置要大还是小
                if(arr[mid] > target){
                    //把结束位置调整到中间位置的前一个位置
                    end = mid - 1;
                }else{
                    begin = mid + 1;
                }
            }
            //调整完end和begin位置之后，要更新我们的中间位置指针mid
            mid = (begin + end) / 2;
        }
        //循环结束，输出index看找没找到
        System.out.println("index: "+index);
    }
}

数组实现栈数据结构

栈就不用多说了吧，就是类似于压子弹的过程，添加元素和删除元素都只能从一端进行的数据结构就是栈。
如图：
在这里插入图片描述
注意：出栈也只能从最上面的栈顶出栈。
代码实现：

package 数组;

public class MyStack {

    //栈的底层我们使用数组来存储数据
    int[] elements;

    public MyStack(){
        elements = new int[0];
    }

    //压入栈元素
    public void push(int element){
        //创建一个新数组
        int[] newArr = new int[elements.length+1];
        //把原数组中的元素赋值到新数组中
        for (int i = 0; i < elements.length; i++) {
            newArr[i] = elements[i];
        }
        //把添加的元素放入到新数组中
        newArr[elements.length] = element;
        //使用新数组替换旧数组
        elements = newArr;
    }

    //返回栈顶元素并弹出该元素
    public int pop(){
        //当栈内没有元素时，pop应该抛异常
        if(elements.length == 0) throw new RuntimeException("栈空异常，无法POP");
        //先取出数组的最后一个元素
        int element = elements[elements.length - 1];
        //然后我们创建一个新的数组来代替原来少了栈顶元素的那个数组
        int[] newArr = new  int[elements.length - 1];
        //循环赋值
        for (int i = 0; i < newArr.length; i++) {
            newArr[i] = elements[i];
        }
        //原数组引用指向新数组
        elements = newArr;
        return element;
    }

    //查看栈顶元素
    public int peek(){
        //这不就是查看数组的最后一个元素吗
        return elements[elements.length - 1];
    }

    //判断栈是否为空
    public boolean isEmpty(){
        return elements.length == 0;
    }

}

数组实现队列数据结构

这个感觉也很基础叭…和栈不一样，队列遵循先进先出原则，也就是一段进行数据的添加，另一端则进行数据的删除。
如图：
在这里插入图片描述

代码如下：

package 数组;

public class MyQueue {

    int[] elements;

    public MyQueue(){
        elements = new int[0];
    }

    //入队
    public void add(int element){
        //创建一个新数组
        int[] newArr = new int[elements.length+1];
        //把原数组中的元素赋值到新数组中
        for (int i = 0; i < elements.length; i++) {
            newArr[i] = elements[i];
        }
        //把添加的元素放入到新数组中
        newArr[elements.length] = element;
        //使用新数组替换旧数组
        elements = newArr;
    }

    //出队列
    public int poll(){
        //取出数组中的第一个元素
        int element = elements[0];
        //创建一个新数组
        int[] newArr = new int[elements.length - 1];
        //循环赋值，需要注意的是
        //我们原数组的第一个值elements[0]是不用赋值的
        //因为它已经出队列了懂我意思叭
        for (int i = 0; i < newArr.length; i++) {
            newArr[i] = elements[i+1];
        }
        //替换数组
        elements = newArr;
        //返回出列的值
        return element;
    }

    //判断队列是否为空
    public boolean isEmpty(){
        return elements.length == 0;
    }

}

稀疏数组实现

什么是稀疏数组？
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
代码实现：

package 稀疏数组;

public class SparseArray {

    public static void main(String[] args) {
        //创建一个原始的二维数组 11 * 11
        // 0：表示没有棋子  1：表示黑子    2：表示蓝子
        int[][] chessArr1 = new int[11][11];
        chessArr1[1][2] = 1; //赋值
        chessArr1[2][3] = 2; //赋值
        System.out.println("原始的二维数组：");
        //打印棋盘:二维数组
        for (int[] row : chessArr1){
            for (int data : row){
                System.out.printf("%d\t",data);
            }
            System.out.println(); //换行
        }

        //将二维数组 转 稀疏数组的思路
        //1. 先遍历二维数组 得到非0数据的个数
        int sum = 0; //计数器，计数非0值
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(chessArr1[i][j] != 0) sum++; //如果二维数组的元素值不等于0，则sum++
            }
        }

        //2. 创建对应的稀疏矩阵
        int[][] sparseArr = new int[sum + 1][3]; //数组从0开始，所以数组行大小为sum+1，稀疏矩阵就三列需要的数据，所以为3
        //给稀疏矩阵赋值
        sparseArr[0][0] = 11; //第一行第一列为原始数组的行数11
        sparseArr[0][1] = 11; //第一行第二列为原数数组的列数11
        sparseArr[0][2] = sum; //第一行第三列为原始数组的有效值（非0值）

        // 遍历二维数组，将非0的值存放到稀疏数组sparseArr中
        int count = 0; //用于计数是第几个非零数据
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(chessArr1[i][j] != 0){ //如果这个值非0，将其赋值给稀疏数组
                    count++; //稀疏矩阵的第一行是用来记录原数数组的总行数总列数以及总有效值数的
                    //稀疏数组sparseArr的第二行第一列用来记录原始数组有效元素（非零值）的行数
                    sparseArr[count][0] = i;
                    //稀疏数组sparseArr的第二行第二列用来记录原始数组有效元素（非零值）的列数
                    sparseArr[count][1] = j;
                    //稀疏数组sparseArr的第二行第三列用来记录原始数组有效元素的值
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }

        //输出稀疏数组的形式
        System.out.println();
        System.out.println("------得到稀疏数组为------");
        for (int i = 0; i < sparseArr.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        }
        System.out.println();

        //将稀疏数组 -- > 恢复成 原始的二维数组
        /*
        1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chessArr2 = int[11][11]
        2.再读取稀疏数组后几行的数据，并赋给 原始的二维数组即可
         */
        //1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
        int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];

        //2.再读取稀疏数组后几行的数据(从第二行开始)，并赋给 原始的二维数组

        for (int i = 1; i < sparseArr.length; i++) { //从第二行开始，所以这里i=1
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }

        //输出恢复后的二维数组
        System.out.println("-----恢复后的二维数组-----");
        for (int[] row : chessArr1){
            for (int data : row){
                System.out.printf("%d\t",data);
            }
            System.out.println(); //换行
        }
    }
}
在地球迷路的怪兽
关注
专栏目录
【洛谷P6704 GITARA】题解
qq_29541301的博客
10-25 468
实际上是一道单调栈的简单题 题目背景 Darko 有一个想象的外星朋友，他有十亿根手指。外星人快速拿起吉他，在网上找到一段简单的旋律并开始弹奏。 这个吉他像寻常一样有六根弦，令其用 111 到 666 表示。每根弦被分成 PPP 段，令其用 111 到 PPP 表示。 旋律是一串的音调，每一个音调都是由按下特定的一根弦上的一段而产生的（如按第 444 弦第 888 段）。如果在一根弦上同时按在几段上，产生的音调是段数最大的那一段所能产生的音调。 例：对于第 333 根弦，第 555 段已经被按，若你要弹出第
stack栈和stack栈数组
乐于分享，共同成长
11-13 2107
声明一个stack栈stack<int> s1; stack<string> s2; stack中的操作 stack<int> s; s.push(x) 无返回值，将元素x压栈 s.pop(); 退栈，无返回值 s.top(); 取栈顶元素，返回栈顶元素 s.empty(); 判断栈是否为空，如果是空，返
数据结构和算法学习（1）- 数组、队列和栈
curePony
02-20 417
文章目录数组数组是什么？数组的时间复杂度稀疏数组队列队列是什么？队列的时间复杂度队列Queue的java api如何利用数组来简单地模拟队列如何实现循环队列栈栈是什么栈的经典应用场景栈的应用例子-深度优先遍历栈应用例子-波兰表达式中缀表达式后缀波兰表达式 数组 数组是什么？ 在计算机科学中，数组数据结构（英语：array data structure），简称数组（英语：Array），是由相同类型的元素（element）的集合所组成的数据结构，分配一块连续的内存来存储。利用元素的索引（index）可以计算出该
深入理解常见数据结构：数组、链表、栈、队列、树、图、哈希表和堆
weixin_42559561的博客
12-01 958
在计算机科学中，数据结构是一种组织和存储数据的方式，对于解决各种问题和优化算法至关重要。本文将深入探讨几种常见的数据结构，包括数组、链表、栈、队列、树、图、哈希表和堆。我们将详细解释每种数据结构的定义、特点以及常见的应用场景，同时提供代码示例以帮助读者更好地理解这些概念。
数据结构：栈、队列、数组 详解
Cerulea_n的博客
07-01 668
1。
数据结构基础（数组、线性表、栈和队列）
询昵的博客
02-22 605
基础知识 数据结构基本概念 1)数据 数据元素：数据基本单位，可由若干数据项组成； 数据对象：性质相同的数据元素的集合； 数据类型：包括原子类型，结构类型，抽象数据类型； 抽象数据类型(ADT)：通常用(数据对象，数据关系，基本操作集)这样的三元组表示； 数据结构：包括逻辑结构、存储结构、数据的运算； 2)数据的逻辑结构(独立于计算机的，与存储结构无关) 包括：线性结构(...
线性结构之稀疏数组
weixin_42404977的博客
10-17 145
线性结构之稀疏数组:简介稀疏数组sparsearray定义二维数组转稀疏数组的思路:稀疏数组转二维数组的思路:代码实现 简介 线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)，顺序存储的线性表成为顺序表，顺序表中的存储元素是连续的，链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。 线性结构常见的有:数组，队列，链表合栈； 非线性架构包括:二维数组，多维数组，广义表，树结构，图结构。 稀疏数组sparsearray 定义 当一个
数据结构-稀疏数组& 环形队列
Shawn Jeon`s blog
10-09 217
SparseArray& CircularQueue数据结构稀疏数组(Sparse Array)环形队列(CircularQueue) 数据结构 数据结构分为2种, 线性结构和非线性结构 线性结构 (1) 数据元素之间是一对一的线性关系. 常见有数组, 队列, 链表和栈等 (2) 存储结构有两种: 顺序存储结构: 顺序存储的线性表称为顺序表, 顺序表中的存储元素是连续的 链式存储结构: 链式存储的线性表称为链表, 链表中的存储元素不一定是连续的(元素节点中存放的数据包括:元素和相邻元素
数据结构-栈、队列、数组、串
weixin_42559968的博客
01-29 955
栈和队列是程序中常用的两种数据结构，它们的逻辑结构和线性表相同。其特点在于运算 有所限制：栈按“后进先出”的规则进行操作，队列按“先进先出”的规则进行操作，故称为 运算受限的线性表。
线性结构和非线性结构、稀疏数组、队列、链表（LinkedList） 数组和链表.pdf
04-18
通过对线性结构与非线性结构、稀疏数组的理解，我们可以更好地选择合适的数据结构来解决问题。线性结构因其简单易用而被广泛应用于各种算法设计中，而非线性结构则适用于更复杂的关系表示。稀疏数组作为一种特定场合...
【Java数据结构与算法】稀疏数组
01-20
文章目录数据结构类型线性结构与非线性结构稀疏数组实例应用二维数组转稀疏数组的思路稀疏数组转原始的二维数组思路 数据结构类型 数据结构包括：线性结构和非线性结构。 线性结构与非线性结构 线性结构 线性结构...
数据结构学习笔记（3.栈，队列，数组 4.串）
super_song的博客
05-04 1199
文章目录第三章 栈，队列和数组栈（stack）顺序栈的实现 第三章 栈，队列和数组 栈（stack） 栈的定义 只允许在一端进行插入或删除操作的线性表 重要术语：栈顶，栈底，空栈 栈的基本操作 创建，销毁，进栈，出栈， 栈的常考题型 可能是先全部进栈，再出栈；也可能是边进边出； 可能的出栈顺序的排列组合为卡特兰数，了解即可 考试多数出选择题，选出可能的情况 知识点小结 栈是一种进出受限的线性表 顺序栈的实现 ...
数据结构2——单链表
weixin_73629886的博客
09-23 1127
了解了顺序表的不足，下面我们就来学习一下链表，看一看链表能不能解决顺序表的不足。
浙大数据结构：06-图2 Saving James Bond - Easy Version
qq_74924951的博客
09-26 245
采用bfs解决
【数据结构】什么是二叉搜索(排序)树?
C/C++领域,数据结构,linux,MySQl学习者
09-20 1315
数据结构之二叉搜索树概念详解,内容包括:二叉搜索树的概念,二叉搜索树的操作(查找,插入,删除)逻辑详解及图示,二叉搜索树的应用以及二叉搜索树的性能分析。
数据结构之——单链表
m0_71974552的博客
09-23 1042
深入了解单链表：数据结构中的灵活利器
数据结构——初识树和二叉树
最新发布
weixin_74209413的博客
09-26 658
树是由根和子树组成，子树又是由子树的根和子树的子树组成，是一个递归的（嵌套的）结构。示意图如下：树的其他表现方式为何要重点研究每结点最多只有两个的树?二叉树的结构最简单，规律性最强;可以证明，所有树都能转为唯一对应的二又树，不失一般性。普通树(多又树)若不转化为二又树，则运算很难实现二叉树在树结构的应用中起着非常重要的作用，因为对二叉的许多操作算法简单，而任何树都可以与二叉树相互转换，这样就解决了树的存储结构及其运算中存在的复杂性。二叉树。
数据结构（Day19）
weixin_65095004的博客
09-23 1440
理解单链表、双向链表和循环链表的结构及其操作方式。
线性与非线性数据结构详解：稀疏数组与链表应用
广义表、树结构和图结构都是非线性数据结构，其中树和图是典型的代表，树是分层次的结构，而图则允许任意元素之间的连接。 稀疏数组是一种特别的数据结构，当一个数组大部分元素为零或重复值时，使用它可以节省存储...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

在地球迷路的怪兽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值