1.基础的线性数据结构：数组

最新推荐文章于 2024-08-16 10:42:04 发布
最新推荐文章于 2024-08-16 10:42:04 发布
阅读量957 收藏 23
点赞数 18
分类专栏： 数据结构与算法 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43559187/article/details/135093481
版权

一、基础的线性数据结构：数组

image-20231219201911893

1. 静态数组

1.1 随机读写性能很棒

  • 数组是线性数据结构，使用数组存储的数据会排成像一条线一样

image-20231219195026616

  • 用一组

连续的内存空间，来存储一组具有相同类型的数据

选址公式：

image-20231219195050730

int[] data = new int[5];

image-20231219195126222

data[2]元素内存地址=1000+2*4=1008

所以data[2]=0

随机访问数组中任一元素的时间复杂度为O(1)

将index=3的元素的值设置为4

    1. 先找到index=3的元素所在的内存地址=1000+3*4=1012
    2. 将内存地址为1012指向的内存值设置为4

随机读写数组中任一元素的时间复杂度为O(1)

结论：数组的随机读写性能非常的好

1.2 随机新增元素

image-20231219195459300

 public static int[] insertElement(int[] src,int index,int element){
     int length=src.length;
     int[] dest = new int[length+1];
 ​
     for (int i = 0; i < index; i++) {
         dest[i]=src[i];
     }
     dest[index]=element;
     for (int i = index; i < length; i++) {
         dest[i+1]=src[i];
     }
     return dest;
 }

时间复杂度为O(n)，空间复杂度为O(n)

1.3 随机删除元素

image-20231219195520625

 public static int[] removeElement(int[] src,int index){
     int[] dest = new int[src.length-1];
 ​
     for (int i = 0; i < index; i++) {
         dest[i]=src[i];
     }
 ​
     for (int i = index; i < src.length-1; i++) {
         dest[i]=src[i+1];
     }
     return dest;
 }

空间复杂度为O(n)，时间复杂度为O(n)

结论：相对于数组的随机读写，数组的随机删除和新增的性能不是很好

2. 二次封装静态数组

Java内置数组的缺点：

需要写一个ArrayUtils来实现以下功能：

  1. 没有新增元素的方法
  2. 没有删除元素的方法
  3. 没有判空方法
  4. 没有获取真实存储元素个数的方法
  5. 没有判断是否存在指定目标值的方法
  6. 例如：
 /**
      * 判断是否为空
      * @param arr
      * @return
      */
 public static boolean isEmpty(int[] arr){
     for(int num:arr){
         //此处假设等于0表示没有元素
         //这个是不严谨的，因为元素的值可能是0
         if(num!=0)
             return false;
     }
     return true;
 }

因此需要二次封装静态数组ArrayList

image-20231219195549287

成员变量包括：一个内置数组，capacity记录数组容量，size记录数组元素个数

2.1 新增操作

例如：把21插入到索引为1的位置

将index指向1，并将后面的元素都向后移一位(从最后一个元素开始往后移)，最后size加1

public void add(int index,int e){
    if(size == data.length){
        throw new IllegalArgumentException("add failed,Array is full");
    }
    if(index<0 || index>size){
        throw new IllegalArgumentException("add failed,require index>=0 && index<=size");
    }
    //计算最差时间复杂度，循环代码运行最大次数
    //size=data.length && index=0
    //时间复杂度O(n)
    for(int i=size-1;i>=index;i--){
        data[i+1]=data[i];
    }
    data[index]=e;
    size++;
}

时间复杂度为O(n)

2.2 查询操作

  • 获取index索引位置的元素
public int get(int index){
    if(index<0||index>=size){
        throw new IllegalArgumentException("get failed,require index>=0 && index<=size");
    }
    return data[index];
}

时间复杂度为O(1)

  • 查找元素e所在的索引，如果不存在元素e，则返回-1
 public int find(int e){
     for(int i=0;i<size;i++){
         if(data[i]==e){
             return i;
         }
     }
     return -1;
 }

时间复杂度为O(n)

  • 是否包含元素e
 public boolean contains(int target){
     for (int num : data) {
         if(num==target)
             return true;
     }
     return false;
 }

时间复杂度为O(n)

  • 重写toString()
 @Override
 public String toString() {
     StringBuilder sb = new StringBuilder();
     sb.append(String.format("Array:size = %d,capacity = %d\n",size,data.length));
     sb.append("[");
     for (int i = 0; i < size; i++) {
         sb.append(data[i]);
         if(i!=size-1){
             sb.append(",");
         }
     }
     sb.append("]");
     return sb.toString();
 }

2.3 修改操作

 public void set(int index,int e){
     if(index<0||index>=size){
         throw new IllegalArgumentException("set failed,require index>=0 && index<=size");
     }
     data[index]=e;
 }

时间复杂度为O(1)

2.4 删除操作

例如：删除索引为1的元素

将后面的元素覆盖掉前面的元素，size减1，并将当前位置的元素对象释放掉

public int remove(int index){
    if(index<0||index>=size){
        throw new IllegalArgumentException("remove failed,require index>=0 && index<=size");
    }
    //记录要删除的元素
    int res = data[index];
    //最差：index=0 && size=data.length
    //时间复杂度为O(n)
    for (int i = index+1; i < size; i++) {
        data[i-1]=data[i];
    }
    size--;
    //GC 清除不用的对象
    data[size]=null;
    return res;
}

//删除指定元素
public void removeElement(int e){
    //时间复杂度为O(n)
    int index = find(e);
    if(index!=-1){
        remove(index);
    }
}

2.5 使用泛型

 public class ArrayList<E> {
     private E[] data;
     private int capacity;
     private int size;
 ​
     public ArrayList(int capacity){
         this.data = (E[]) new Object[capacity];
         this.capacity=capacity;
         this.size=0;
     }
 ​
     public ArrayList(){
         this(15);
     }
 ​
     public boolean isEmpty(){
         return size==0;
     }
 ​
     public int getSize(){
         return size;
     }
 ​
     public int getCapacity(){
         return capacity;
     }
 ​
     /**
      * 新增操作：在指定位置插入一个元素
      * @param index
      * @param e
      */
     public void add(int index,E e){
         if(size == data.length){
             throw new IllegalArgumentException("add failed,Array is full");
         }
         if(index<0 || index>size){
             throw new IllegalArgumentException("add failed,require index>=0 && index<=size");
         }
         for(int i=size-1;i>=index;i--){
             data[i+1]=data[i];
         }
         data[index]=e;
         size++;
     }
 ​
     public void addFirst(E e){
         add(0,e);
     }
 ​
     public void addLast(E e){
         add(size,e);
     }
 ​
     /**
      * 查询操作：获取index索引位置的元素
      * @param index
      * @return
      */
     public E get(int index){
         if(index<0||index>=size){
             throw new IllegalArgumentException("get failed,require index>=0 && index<=size");
         }
         return data[index];
     }
 ​
     /**
      * 查找元素e所在的索引，如果不存在元素e，则返回-1
      * @param e
      * @return
      */
     public int find(E e){
         for(int i=0;i<size;i++){
             if(data[i].equals(e)){
                 return i;
             }
         }
         return -1;
     }
 ​
     /**
      * 修改操作：将index索引位置的元素修改为新元素e
      * @param index
      * @param e
      */
     public void set(int index,E e){
         if(index<0||index>=size){
             throw new IllegalArgumentException("set failed,require index>=0 && index<=size");
         }
         data[index]=e;
     }
 ​
     /**
      * 删除操作：删除指定索引位置的元素
      * @param index
      */
     public E remove(int index){
         if(index<0||index>=size){
             throw new IllegalArgumentException("remove failed,require index>=0 && index<=size");
         }
         E res = data[index];
         for (int i = index+1; i < size; i++) {
             data[i-1]=data[i];
         }
         size--;
         //GC 清除不用的对象
         data[size]=null;
         return res;
     }
 ​
     public E removeFirst(){
         return remove(0);
     }
 ​
     public E removeLast(){
         return remove(size-1);
     }
 ​
     /**
      * 删除指定元素
      * @param e
      */
     public void removeElement(E e){
         int index = find(e);
         if(index!=-1){
             remove(index);
         }
     }
 ​
     public boolean contains(E target){
         for (E num : data) {
             if(num.equals(target))
                 return true;
         }
         return false;
     }
 ​
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
         sb.append(String.format("Array:size = %d,capacity = %d\n",size,data.length));
         sb.append("[");
         for (int i = 0; i < size; i++) {
             sb.append(data[i]);
             if(i!=size-1){
                 sb.append(",");
             }
         }
         sb.append("]");
         return sb.toString();
     }
 }

3. 动态数组

3.1 扩容

扩容缩容三步法：

  1. 创建一个容量为newCapacity的临时数组
  2. 将原来数组中的元素拷贝到新数组中
  3. 将新数组覆盖老数组

image-20231219200238167

//改进前
public void add(int index,E e){
    if(index<0 || index>size){
        throw new IllegalArgumentException("add failed,require index>=0 && index<=size");
    }
    //扩容
    if(size == data.length){
        //1.创建一个容量为2倍于之前容量的临时数组
        int newCapacity = capacity<<1;
        E[] newData = (E[])new Object[newCapacity];
        //2.将原来数组中的元素拷贝到新数组中
        for (int i = 0; i < data.length; i++) {
            newData[i] = data[i];
        }
        //3.将新数组覆盖老数组
        data = newData;
        // bug 修复：将容量设置位新容量值
        capacity = newCapacity;
    }
    for(int i=size-1;i>=index;i--){
        data[i+1]=data[i];
    }
    data[index]=e;
    size++;
}

//改进后，扩容只需调用resize方法，将新容量传入即可
public void add(int index,E e){
    if(index<0 || index>size){
        throw new IllegalArgumentException("add failed,require index>=0 && index<=size");
    }
    //扩容
    if(size == data.length){
        resize(capacity<<1);
    }
    for(int i=size-1;i>=index;i--){
        data[i+1]=data[i];
    }
    data[index]=e;
    size++;
}

3.2 缩容

image-20231219200514122

image-20231219200516329

将扩容和缩容的公共部分提取成resize方法，如需改变容量，调用resize方法即可，将新的数组容量通过参数传入

 //扩容和缩容操作
 public void resize(int newCapacity){
     //1.创建一个容量为newCapacity的临时数组
     E[] newData = (E[])new Object[newCapacity];
     //2.将原来数组中的元素拷贝到新数组中
     //此处缩容会有数组下标越界异常，需注意！
     for (int i = 0; i < data.length; i++) {
         newData[i] = data[i];
     }
     //3.将新数组覆盖老数组
     data = newData;
     // bug 修复：将容量设置位新容量值
     capacity = newCapacity;
 }
 ​
 //删除操作
 public E remove(int index){
     if(index<0||index>=size){
         throw new IllegalArgumentException("remove failed,require index>=0 && index<=size");
     }
     E res = data[index];
     for (int i = index+1; i < size; i++) {
         data[i-1]=data[i];
     }
     size--;
     //GC 清除不用的对象
     data[size]=null;
 ​
     //如果size等于总容量的一半的话，则进行缩容
     //此处可能会出现时间复杂度震荡，需注意！
     if(size==data.length/2){
         resize(data.length>>1);
     }
     return res;
 }

3.3 缩容的bug修复

缩容的情况下如果使用data.length会报错，不能使用data.length

 //扩容和缩容操作
 public void resize(int newCapacity){
     //1.创建一个容量为newCapacity的临时数组
     E[] newData = (E[])new Object[newCapacity]; //7
     
     //2.将原来数组中的元素拷贝到新数组中
     
     //此处不需要将原先整个data数组复制到新数组中，只需要将里面的元素拷贝到新数组即可，元素个数size(此时size为总容量的一半)，此时传入的newCapacity为data的一半，新数组的容量为newCapacity，如果将原先数组data.length都复制到新数组中时，会出现下标越界异常
     for (int i = 0; i < size; i++) {    //data.length：14
         newData[i] = data[i];
     }
     
     //3.将新数组覆盖老数组
     data = newData;
 }

3.4 均摊时间复杂度

addLast均摊时间复杂度：

在往数组最后添加元素时，如果数组满了，需要扩容，不会影响时间复杂度

正常情况下，addLast时间复杂度为O(1)

操作：第一次：56；第二次：12；第三次：33；第四次：24；第五次：45

第六次：复制…

第十一次：31

第十二次：data = newData;

image-20231219200554330

image-20231219200557179

addLast均摊时间复杂度：O(1)

removeLast均摊时间复杂度：O(1)

3.5 时间复杂度震荡

在边界时，不断插入元素或者删除元素，在缩容和扩容之间徘徊，会导致时间复杂度震荡

addLast时间复杂度O(n)

removeLast时间复杂度O(n) (扩容或者缩容都需要遍历数组)

解决办法：在缩容的时候，并非在size为容量一半的时候缩容，而是选择在1/4的时候缩容，尽可能减少时间复杂度震荡；另外需要注意原先数组的长度有可能不断的减少，有可能会小于 2，此时假如是1的话，1/2为0，传入的新容量就为0了，所以需要判断不等于0

 public E remove(int index){
     if(index<0||index>=size){
         throw new IllegalArgumentException("remove failed,require index>=0 && index<=size");
     }
     E res = data[index];
     for (int i = index+1; i < size; i++) {
         data[i-1]=data[i];
     }
     size--;
 ​
     //GC 清除不用的对象
     data[size]=null;
 ​
     //如果size等于总容量的四分之一的话，则进行缩容
     //此处可能会有时间复杂度震荡，为了避免，选择在1/4的时候进行缩容
     //注意：因为data.length有可能不断的减少，所以有可能小于2了，所以需要判断下
     if(size==data.length/4 && data.length/2!=0){
         resize(data.length>>1);
     }
     return res;
 }

4. 静态数组vs动态数组

  1. 动态数组使用相对方便
  2. 动态数组支持自动扩容缩容
  3. 动态数组申请内存耗费时间，没有静态数组性能好
  4. 动态数组不能存储基本类型的元素

5. 最终代码

 public class ArrayList<E> {
     private E[] data;
     private int capacity;
     private int size;
 ​
     public ArrayList(int capacity){
         this.data = (E[]) new Object[capacity];
         this.capacity=capacity;
         this.size=0;
     }
 ​
     public ArrayList(){
         this(15);
     }
     
     public ArrayList(E[] arr) {
         this.data = (E[])new Object[arr.length];
         for (int i = 0; i < arr.length; i++) {
             data[i] = arr[i];
         }
         size = arr.length;
         // bug 修复：加上 capacity 的初始化
         this.capacity = arr.length;
     }
 ​
     //判断是否为空
     public boolean isEmpty(){
         return size==0;
     }
 ​
     //获取数组元素个数
     public int getSize(){
         return size;
     }
 ​
     //获取容量
     public int getCapacity(){
         return capacity;
     }
 ​
     /**
      * 新增操作：在指定位置插入一个元素
      * 时间复杂度：O(n)
      * @param index
      * @param e
      */
     public void add(int index,E e){
         if(index<0 || index>size){
             throw new IllegalArgumentException("add failed,require index>=0 && index<=size");
         }
         //扩容
         if(size == data.length){
             resize(capacity<<1);
         }
         //计算最差时间复杂度，循环代码运行最大次数
         //size=data.length && index=0
         //时间复杂度O(n)
         for(int i=size-1;i>=index;i--){
             data[i+1]=data[i];
         }
         data[index]=e;
         size++;
     }
 ​
     //时间复杂度O(n)
     public void addFirst(E e){
         add(0,e);
     }
 ​
     //时间复杂度O(1)，如果添加最后时数组满了，需要扩容，此时均摊时间复杂度
     public void addLast(E e){
         add(size,e);
     }
 ​
     //扩容和缩容操作
     public void resize(int newCapacity){
         //1.创建一个容量为newCapacity的临时数组
         E[] newData = (E[])new Object[newCapacity];
         //2.将原来数组中的元素拷贝到新数组中
         //缩容bug修复
         for (int i = 0; i < size; i++) {
             newData[i] = data[i];
         }
         //3.将新数组覆盖老数组
         data = newData;
         // bug 修复：将容量设置位新容量值
         capacity = newCapacity;
     }
 ​
     /**
      * 删除操作：删除指定索引位置的元素
      * @param index
      */
     public E remove(int index){
         if(index<0||index>=size){
             throw new IllegalArgumentException("remove failed,require index>=0 && index<=size");
         }
         //暂存要删除索引位置的元素
         E res = data[index];
         for (int i = index+1; i < size; i++) {
             data[i-1]=data[i];
         }
         size--;
 ​
         //GC 清除不用的对象
         data[size]=null;
 ​
         //如果size等于总容量的四分之一的话，则进行缩容
         //此处可能会有时间复杂度震荡，为了避免，选择在1/4的时候进行缩容
         //注意：因为data.length有可能不断的减少，所以有可能小于2了，所以需要判断下
         if(size==data.length/4 && data.length/2!=0){
             resize(data.length>>1);
         }
         return res;
     }
 ​
     //时间复杂度为O(n)
     public E removeFirst(){
         return remove(0);
     }
 ​
     //时间复杂度为O(1)
     public E removeLast(){
         return remove(size-1);
     }
 ​
     /**
      * 删除指定元素
      * 时间复杂度为O(n)
      * @param e
      */
     public void removeElement(E e){
         int index = find(e);
         if(index!=-1){
             remove(index);
         }
     }
 ​
     /**
      * 修改操作：将index索引位置的元素修改为新元素e
      * @param index
      * @param e
      */
     public void set(int index,E e){
         if(index<0||index>=size){
             throw new IllegalArgumentException("set failed,require index>=0 && index<=size");
         }
         data[index]=e;
     }
 ​
     /**
      * 查询操作：获取index索引位置的元素
      * 时间复杂度为O(1)
      * @param index
      * @return
      */
     public E get(int index){
         if(index<0||index>=size){
             throw new IllegalArgumentException("get failed,require index>=0 && index<=size");
         }
         return data[index];
     }
 ​
     /**
      * 查找元素e所在的索引，如果不存在元素e，则返回-1
      * 时间复杂度为O(n)
      * @param e
      * @return
      */
     public int find(E e){
         for(int i=0;i<size;i++){
             if(data[i].equals(e)){
                 return i;
             }
         }
         return -1;
     }
 ​
     /**
      * 是否包含某一元素
      * 时间复杂度为O(n)
      * @param target
      * @return
      */
     public boolean contains(E target){
         for (E num : data) {
             if(num.equals(target))
                 return true;
         }
         return false;
     }
 ​
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
         sb.append(String.format("Array:size = %d,capacity = %d\n",size,data.length));
         sb.append("[");
         for (int i = 0; i < size; i++) {
             sb.append(data[i]);
             if(i!=size-1){
                 sb.append(",");
             }
         }
         sb.append("]");
         return sb.toString();
     }
 }

6.数据结构与算法学习

https://tmdus.xetlk.com/s/eUMyr

image-20231219201126021

懿所思
关注
  • 18
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
1. 线性表-顺序存储-数组1
08-03
数组是一种最简单且最基础的数据结构，它在内存中连续存储元素，每个元素可以通过一个固定的下标来访问。 时间复杂度是衡量算法效率的重要指标，它描述的是算法运行时间与输入数据规模之间的关系。在计算机科学中，...
数据结构：数组存储结构
11-01
数组存储结构是数据结构领域一个基础且重要的概念，它是一种线性数据结构，用一组连续的存储单元来存储一系列的值，通常是相同类型的数据。在C++等编程语言中，数组可以是一维的也可以是多维的，适用于对数据集合...
四大基础数据结构：数组、链表、队列和栈
weixin_46585151的博客
03-22 3113
四大基础数据结构：数组、链表、队列和栈1、时间复杂度（大O表示法）2、数组3. 链表合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 1、时间复杂度（大O表示法） 衡量时间复杂度与空间复杂度的计数表示，即 衡量算法时间长与不长、占用内存多与多
数据结构： 数组与链表
timberman666的博客
10-02 2011
数据结构： 数组与链表
深入理解基本数据结构：数组详解
qq_40254606的博客
07-09 1122
数组是一种线性数据结构，用于存储一组相同类型的元素。数组中的元素在内存中是连续存储的，可以通过索引快速访问。数组作为最基础的数据结构之一，具有固定大小相同类型连续存储和随机访问的特点。通过对数组的基本操作和实现的学习，我们可以更好地理解和使用数组。在实际编程中，数组的应用广泛且高效，是每个程序员都必须掌握的基础知识。
重温四大基础数据结构：数组、链表、队列和栈
“逛丢一只鞋”的博客
09-06 1909
文章目录前言数组链表队列栈 前言 数组、链表、队列、栈，是数据结构中最基础的四大结构，数组和链表更是基础中的基础，后续所有复杂的数据结构都是在它们的基础上演变而来的。 本节，我们就来重温这四大结构。 数组 关于数组，大家都比较熟悉了。 它是一种线性数据结构，使用一组连续的内存空间存储一组具有相同类型的数据。 这个概念中有三个关键词：线性、连续、相同类型。 线性，表示没有分叉，任意元素的前后元素最多只有一个，同样是线性结构的还有链表、队列等。 连续，它在内存空间中的存储是连续的，不间断的，前后两个元素紧挨着
数据结构：数组、链表、栈、队列、堆
区块链之美
05-14 1199
https://www.cnblogs.com/jimoer/p/8783604.html 解释定义 数据结构： 数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。再简单描述一下：数据结构就是描述对象间逻辑关系的学科。 如果还是不太清楚下面会举例说明的。 数据存储结构： 简单的讲就是数据在计算机中的存储方式。 常用的数据存储方式有两种：顺序存储，非顺序存储。顺序存储就是把数据存储在一块联系的存储介质（硬盘或内存等）中。反之就是非顺序存储咯。Java中的数组就是典型的顺序存储，链表就是非顺序存储。数
数据结构：数组ADT
Viadimir的博客
04-24 3161
数组，相信大家对这个名词不陌生，他在高级语言中都已经物理实现为数组数据类型。数组是一个特殊的线性表，特殊在元素受多个线性关系约束。因为数组的特殊性，所以其定义的操作非常少。 接下来我将讲一下数组的一些知识以及利用数组实现一种特殊的数据结构——矩阵。 （我结合我们老师的PPT给大家讲解，其中会夹杂一下我本人对某些问题的理解和看法，说的不对的地方，还请大家不吝赐教。） 一、数组的基本知识 ...
c++数据结构：数组和向量
qq_45303986的博客
10-10 1816
A[i,j] 每个元素的长度为3，i的范围为1-8 j的范围为1-10，首地址为G。c[0]代表的是以c[0][0]为首地址的一维数组（将数组c摊开）一般用二维数组来存储矩阵元。在数据元素的非空有限集中。计算A[5,8]的地址。
python数据结构：数组、链表、栈、队列、树
qq_43745578的博客
02-07 2246
python数据结构：数组、链表、栈、队列、树
数据结构：八种数据结构大全
热门推荐
緑水長流*z
07-29 20万+
数据结构 1.1 数据结构概述 数据结构是计算机存储、组织数据的方式；通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构的优良将直接影响着我们程序的性能；常用的数据结构有：数组（Array）、栈（Stack）、队列（Queue）、链表（Linked List）、树（Tree）、图（Graph）、堆（Heap）、散列表（Hash）等； 1.2 数据结构的分类 1.2.1 排列方式 1）集合 集合：数据结构中的元素之间除了“同属一个集合” 的相互关系外，别无其他关系； 2）线性结构 线性
线性数据结构：数组与链表的探索与应用
学IT，找陈寒
08-23 1164
数组和链表是线性数据结构的代表，它们在不同场景下发挥着重要作用。数组适用于快速访问和搜索，而链表则适用于频繁插入和删除操作。选择合适的数据结构取决于问题的特点和需求。通过深入学习数组和链表，我们不仅能够更好地理解它们的操作和应用，还能够在解决实际问题时选择合适的数据结构，提高程序的性能和可维护性。线性数据结构作为数据结构领域的基础，为我们进一步学习更复杂的数据结构打下了坚实的基础。🧸结尾😊🙏Java面试技巧Java面试八股文 - 掌握面试必备知识（目录篇）Java学习路线。
数据结构：第5章 数组和广义表.ppt
06-18
数组是一种基本的数据结构，由n(n＞1)个相同类型的数据元素a0, a1, …, an-1构成的有限序列，且该有限序列存储在一块地址连续的内存单元中。数组的定义类似于采用顺序存储结构的线性表，是线性表在维数上的扩张，也...
CH4-数组18.zip_数据结构
09-21
数组是一种线性数据结构，它存储了一组相同类型的数据元素，这些元素在内存中是连续存放的。每个元素都有一个唯一的索引，索引通常是从0开始的整数，用于访问和操作数组中的特定元素。数组的主要特点包括： 1. **...
数据结构：第5章 数组和稀疏矩阵.ppt
06-12
"数据结构：数组和稀疏矩阵" 在计算机科学中，数组是一种基本的数据结构，广泛应用于各种领域。数组是一种随机存储结构，可以直接存取任意数据元素...理解数组和稀疏矩阵的定义、存储结构和应用是学习数据结构的基础。
数据结构之---堆（2）
2301_81684056的博客
08-15 633
出堆是指将堆顶数据出堆。出堆完成后要保证剩余数据还是满足原来堆的性质。所以我们把堆顶数据和堆底最后一个数据交换，取出新堆底数据，之后通过向下调整算法将剩下的数据重新排列成一个堆。大堆经过出堆操作得出的数据是升序的小堆经过出堆操作得出的数据是降序的。
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 907
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
数据结构之树的存储结构
最新发布
DKPT的博客
08-16 567
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
数据结构——时间复杂度和空间复杂度
2301_80373479的博客
08-15 919
带你了解时间复杂度和空间复杂度
数据结构基础：数组与链表复习指南
在数据结构中，数组是一种线性数据结构，它将相同类型的数据元素存储在连续的内存空间中，通过索引（下标）进行访问。数组的主要知识点包括： 1. **结构与结构变量**：首先，介绍如何定义结构，如`struct student`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

懿所思

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

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

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

打赏作者

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

抵扣说明：

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

余额充值