算法与数据结构 01 线性结构

最新推荐文章于 2024-03-25 19:22:00 发布
原创 最新推荐文章于 2024-03-25 19:22:00 发布 · 498 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #算法 #链表

本文介绍了线性表和栈这两种基本的数据结构。线性表由相同类型的数据元素组成，支持多种基本操作如插入、删除等。栈作为线性表的一种特殊形式，仅允许在一端进行插入和删除操作。
  1. 线性表

（1） 线性表是由n（n>=0）个数据元素所构成的有限序列。
（2） 对于同一个线性表，其每一个数据元素的虽然有所不同，但必须具有相同的数据类型；同时，数据元素之间具有一种线性或“一对一”的逻辑关系：

  • 第一个数据元素没有前驱，这个数据元素称为开始结点；
  • 最后一个数据元素没有后继，这个数据元素称为终端结点；
  • 除了首尾数据元素之外，其他数据元素有且仅有一个前驱和一个后继。

（3） 上述的逻辑关系就是线性结构。线性表就是一种线性结构。
（4） 线性表的基本操作：

  • clear（）：将一个已经存在的线性表置空
  • isEmpty（）：判断线性表是否为空。若为空，返回true；不为空，返回false；
  • length（）：求线性表中的元素个数，并返回其值
  • get（i）：读取并返回线性表中的第i个元素的值，其中0<= i <=length() -1
  • insert( i，x)：在线性表的第i个元素之前插入一个值为x的数据元素。其中0<= i <=length（），当i=0时，在表头插入；当i=length（）时，在表尾插入
  • remove（i ）：删除并返回线性表中第i个元素。其中0<= i <=length() -1
  • indexOf（ x ）：返回线性表中首次出现指定元素位序号，不包含此元素则返回 -1

创建接口：

public interface List<E> extends Iterable<E>{
  //默认在表尾添加一个元素
  public void add(E element);
  //在指定角标处添加元素
  public void add(int index, E element);
  //删除指定元素
  public void remove(E element);
  //删除指定角标处的元素 并返回原先的值
  public E remove(int index);
  //获取指定角标处的元素
  public E get(int index);
  //修改指定角标index处的值为element 并返回原先的值
  public E set(int index, E element);
  //获取线性表中的元素个数
  public int size();
  //查看元素第一次出现的角标位置（从左到右）
  public int indexOf(E element);
  //判断是否包含元素
  public boolean contains(E element);
  //判断线性表是否为空
  public boolean isEmpty();
  //清空线性表
  public void clear();
  //按照比较器的内容进行排序
  public void sort(Comparator<E> c);
  //获取子线性表 原线性表中[fromIndex, toIndex)这个部分
  public List<E> subList(int fromIndex, int toIndex);
}

线性表的简单操作实现

package 线性结构;

import 数据结构接口.List;
import java.util.Comparator;
import java.util.Iterator;

//自定义的线性表的顺序存储方式
public class ArrayList<E> implements List<E> {

  //数组的容器 data.length 指的就是当前数组的容量
  private E[] data;

  //元素的个数 size == 0 线性表为空 size == data.length 线性表满了
  //size 新元素默认尾部添加时要去的角标
  private int size;

  //默认容量
  private static int DEFAULT_CAPACITY = 10;

  //创建一个默认容量为10的线性表
  public ArrayList() {
    data = (E[]) new Object[DEFAULT_CAPACITY];
    size = 0;
  }

  //创建一个指定容量的线性表
  public ArrayList(int capacity) {
    if (capacity <= 0) {
      throw new IllegalArgumentException("capacity must > 0");
    }
    DEFAULT_CAPACITY = capacity;
    data = (E[]) new Object[DEFAULT_CAPACITY];
    size = 0;
  }

  //传入一个数组 将该数组封装成为一个线性表
  public ArrayList(E[] arr) {
    if (arr == null || arr.length == 0) {
      throw new IllegalArgumentException("arr can not be null");
    }
    data = (E[]) new Object[DEFAULT_CAPACITY];
    for (int i = 0; i < arr.length; i++) {
      add(arr[i]);
    }
  }


  @Override
  public void add(E element) {
    add(size, element);
  }

  @Override
  public void add(int index, E element) {
    if (index < 0 || index > size) {
      throw new IllegalArgumentException("add index out of range");
    }
    //判断线性表是否是满状态
    if (size == data.length) {
      resize(2 * data.length);
    }
    //向后移动元素
    for (int i = size - 1; i >= index; i--) {
      data[i + 1] = data[i];
    }
    //将新元素插入到指定位置
    data[index] = element;
    size++;
  }

  //扩容/缩容 操作 不应该向外界提供
  private void resize(int newLen) {
    E[] newData = (E[]) new Object[newLen];
    for (int i = 0; i < size; i++) {
      newData[i] = data[i];
    }
    data = newData;
  }

  @Override
  public void remove(E element) { //删除指定元素 只删除一次 && 删除所有的指定元素
    int index=indexOf(element);
    if (index!=-1){
      remove(index);
    }
  }

  @Override
  public E remove(int index) {
    if (index < 0 || index >= size) {
      throw new IllegalArgumentException("remove index out of range");
    }
    //先保存要删除的值
    E ret = data[index];

    //移动元素
    for (int i = index + 1; i < size; i++) {
      data[i - 1] = data[i];
    }
    size--;

    //什么时候缩容
    //1.有效元素是容量的1/4
    //2.当前容量不得小于等于默认容量
    if (size == data.length / 4 && data.length > DEFAULT_CAPACITY) {
      resize(data.length / 2);
    }
    return ret;
  }

  @Override
  public E get(int index) {
    if (index<0||index>=size){
      throw new IllegalArgumentException("get index out of range");
    }
   return data[index];
  }

  @Override
  public E set(int index, E element) {
    if (index<0||index>=size){
      throw new IllegalArgumentException("set index out of range");
    }
    E ret=data[index];
    data[index]=element;
    return ret;
  }

  @Override
  public int size() {
    return size;
  }
  //添加一个函数，获取线性表中数组的容量
  private int getCapacity(){
    return data.length;
  }

  @Override
  public int indexOf(E element) {
    for (int i=0;i<size;i++){
      if (data[i].equals(element)){
        /*
        == 比的是啥？主要看等号的两边是啥
        == 两边是基本数据类型的话 比的是值
            byte short int long
            float double
            char boolean
        == 两边是引用数据类型的话 比的是地址
            数组 字符串 其他的类对象
        */
        return i;
      }
    }
    return -1;
  }

  @Override
  public boolean contains(E element) {
    return indexOf(element)!=-1;
  }

  @Override
  public boolean isEmpty() {
    return size==0;
  }

  @Override
  public void clear() {
    data= (E[]) new Object[DEFAULT_CAPACITY];
    size= 0;
  }

  @Override
  public void sort(Comparator<E> c) {
    if (c==null){
      throw new IllegalArgumentException("comparator can not be null");
    }
    for (int i = 1; i<size; i++){
      E e=data[i];
      int j=0;
      for (j=i; j > 0 && c.compare ( data [ j -1 ],e)>0; j--) {
        data[j] = data[j-1];
      }
      data[j]=e;
    }
  }

  @Override
  public List<E> subList(int fromIndex, int toIndex) {
    if (fromIndex<0|| toIndex >= size || fromIndex > toIndex){
      throw new IllegalArgumentException("must 0<= formIndex <= toIndex <= size-1");
    }
    ArrayList<E> list =new ArrayList<>();
    for (int i = fromIndex; i <= toIndex;i++){
      list.add(data[i]);
    }
    return list;
  }

  @Override
  public boolean equals(Object o) {
    //1.判空
    if (o == null) {
      return false;
    }
    //2.判自己
    if (this == o ){
      return  true;
    }
    //3.判类型
    if ( o instanceof ArrayList){
      //4.按照自己的逻辑进行比较
      ArrayList<E> other = (ArrayList<E>) o;
      //5.先比有效元素的个数
      if (size != other.size) {
        return false;
      }
      //6.有效元素个数相等的情况下逐个比较元素
      for ( int i = 0;i < size; i++) {
        if ( !data [i].equals( other.data[i]) ) {
          return false;
        }
      }
      return true;
    }
    return  false;
  }
  /*
  [1, 2, 3, 4, 5, 6]
  []
  Arrays.toString(arr);
  */

  @Override
  public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append('[') ;
    if ( isEmpty() ) {
      sb.append(']');
    } else {
      for (int i = 0; i < size; i++) {
        sb.append(data[i]);
        if (i == size - 1) {
          sb.append(']');
        } else {
          sb.append(',');
          sb.append(' ');
        }
      }
    }
    return sb.toString() ;
  }

  //获取当前这个数据结构/容器 的 迭代器
  //通过迭代器对象 更方便挨个取出每一个元素
  //同时 实现了Iterable 可以让当前的数据结构/容器 被foreach循环遍历
  @Override
  public Iterator<E> iterator() {
    return new ArrayListIterator();
  }

  // 创建一个属于ArrayList的迭代器
  class ArrayListIterator implements Iterator<E> {
    private int cur = 0;

    @Override
    public boolean hasNext() {
      return cur < size;
    }

    @Override
    public E next() {
      return data[cur++];
    }
  }
}

测试：

public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<>();
    System.out.println(list);
    Random random = new Random();//引入Random函数生成随机数生成数据元素
    for (int i = 0; i < 10; i++) {
      list.add(random.nextInt(100));
    }
    System.out.println(list);

    for (int i = 0; i < 10; i++) {//扩容测试
      list.add(0, i);
    }
    System.out.println(list);

    list.sort(new Comparator<Integer>() {//引入比较器进行排序测试
      @Override
      public int compare(Integer o1, Integer o2) {
        return o2 - o1;
      }
    });
    System.out.println(list);


    for (Integer num : list) {
      System.out.println(num);
    }

    Iterator<Integer> it = list.iterator();
    while (it.hasNext()) {
      System.out.print(it.next() + " ");
    }
  }
}
//输出结果
[]
[15, 47, 24, 40, 90, 35, 87, 84, 18, 17]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 15, 47, 24, 40, 90, 35, 87, 84, 18, 17]
[90, 87, 84, 47, 40, 35, 24, 18, 17, 15, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
  • 栈
    （1）栈是一种特殊的线性表，栈中的数据元素以及数据元素之间的逻辑关系和线性表相同，两者之间的区别主要在：
  • 线性表的插入和删除操作可以在任意指定位置进行，而栈只允许在末尾进行。
    （2）将插入行为称为入栈，删除行为称为出栈。
    （3） 栈的基本操作与线性表基本相同：
  • 取栈顶元素peek（）：读取栈顶元素并返回其值，若为空，则返回null
  • 入栈操作push（）：将数据元素压入栈顶
  • 出栈操作pop（）：删除并返回栈顶元素

（4）代码实现
创建接口

public interface Stack<E> extends Iterable {
  public int size();
  public boolean isEmpty();
  //入栈 出栈一个元素 再线性表的表尾添加一个元素
  public void push(E element);
  //出栈 弹出一个元素 在线性表的末尾删除一个元素
  public E pop();
  //查看当前栈顶元素
  public E peek();
  public void clear();
}

栈的简单实现

public class ArrayStack<E> implements Stack<E> {
  private ArrayList<E> list;

  public ArrayStack() {list = new ArrayList<>();}//引入线性表类

  public ArrayStack(int capacity) {list = new ArrayList<>(capacity);}


  @Override
  public Iterator<E> iterator() {
    return list.iterator();
  }

  @Override
  public int size() {
    return list.size();
  }

  @Override
  public boolean isEmpty() {
    return list.isEmpty();
  }

  @Override
  public void push(E element) {
    list.add(element);
  }

  @Override
  public E pop() {
    return list.remove(list.size() - 1 );
  }

  @Override
  public E peek() {
    return list.get(list.size() - 1 );
  }

  @Override
  public void clear() {
    list.clear();
  }

  @Override
  public String toString() {
    return list.toString();
  }

  @Override
  public boolean equals(Object o) {
    if (o == null ) {
      return false;
  }
    if (this == o) {
      return true;
    }
    if (o instanceof  ArrayStack) {
      ArrayStack other = (ArrayStack) o;
      return this.list.equals(other.list);
    }
    return false;
  }
}

测试

  public static void main(String[] args) {
    ArrayStack<Integer> stack01 = new ArrayStack<>();
    ArrayStack<Integer> stack02 = new ArrayStack<>(15);
    for (int i = 1; i <= 12; i++) {
      stack01.push(i);
      stack02.push(i);
    }
    System.out.println(stack01);
    System.out.println(stack02);
    System.out.println(stack01.equals(stack02));

    System.out.println(stack01.pop());//删除栈顶元素并返回其值
    System.out.println(stack01);
    System.out.println(stack01.peek());
  }
}
//输出结果
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
true
12
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
11
  1. 中缀计算
    中缀表达式：是一个通用的算术或逻辑公式表示方法， 操作符是以中缀形式处于操作数的中间（例：3 + 4），中缀表达式是人们常用的算术表示方法。
    与前缀表达式（例：+ 3 4）或后缀表达式（例：3 4 +）相比，中缀表达式不容易被计算机解析，但仍被许多程序语言使用，因为它符合人们的普遍用法。
    与前缀或后缀记法不同的是，中缀记法中括号是必需的。计算过程中必须用括号将操作符和对应的操作数括起来，用于指示运算的次序。

在这里插入图片描述

例如有这样一个字符串表达式:"(10+20/2*3)/2+8"
首先对它的运算符和提高优先级符号"()“的左右进行添加” "(空格)的操作，然后在运用java的split方法切割 ，就能实现对表达式的符号数字的分类识别，最后再用两个ArrayStack存放操作符和数字，最后根据不同的操作符与操作符栈栈顶遇到的几种情况分类，最后再书写每次计算，弹两个数字和一个操作符，结果放入数字栈的方法实现一个式子的计算。

public class InfixCalculator {
  public static void main(String[] args) {
    String expression = "(10+20/2*3)/2+8";
    try {
      int result = evaluateExpression(expression);
      System.out.println(result);
    }
    catch (Exception e)  {
      e.printStackTrace();
      System.out.println("Wrong expression : "+expression);
    }
  }

  private static int evaluateExpression(String expression) {
    //需要两个辅助栈
    ArrayStack<Character> operatorStack = new ArrayStack<>();
    ArrayStack<Integer> numberStack = new ArrayStack<>();

    //格式化表达式
    expression = insertBlanks(expression);
    String[] tokens = expression.split(" ");
    for (String token : tokens) {
      //过滤空串
      if (token.length() == 0) {
        continue;
      }
      //遍历到“+”“-”
      else if (token.equals("+") || token.equals("-")) {
        while (!operatorStack.isEmpty() && (operatorStack.peek() == '+' || operatorStack.peek() == '-'
            || operatorStack.peek() == '*' || operatorStack.peek() == '/')) {
          //如果之前是其他的+ - * / 就需要弹栈并计算
          processAnOperator(numberStack,operatorStack);
        }
        //如果操作符栈为空 或者为 （
        operatorStack.push(token.charAt(0));
      }
      //遍历到 * /
      else if (token.equals("*") || token.equals("/")) {
       while (!operatorStack.isEmpty() && (operatorStack.peek() == '*' || operatorStack.peek() == '/')) {
         //如果之前是其他的 * / 就需要弹栈并计算
         processAnOperator(numberStack,operatorStack);
       }
        //如果操作符栈为空 或者为 （
        operatorStack.push(token.charAt(0));
      }//遍历到（
      else if (token.equals("(")) {
        operatorStack.push(token.charAt(0));
      }//遍历到 ）
      else if (token.equals(")")) {
        //只要操作符栈顶不是 （ 就挨个弹栈计算即可
        while (operatorStack.peek() != '(') {
          processAnOperator(numberStack,operatorStack);
        }
        //清除 (
        operatorStack.pop();

      } //遍历到数字
      else {
        numberStack.push(new Integer(token));
      }
    }
    //处理最后的操作符
    while (!operatorStack.isEmpty()) {
      processAnOperator(numberStack,operatorStack);
    }
    return numberStack.pop();

  }
  //操作符栈弹栈一个元素 数字栈弹栈两个数字 进行计算 并将新的结果进栈到数字栈
  private static void processAnOperator(ArrayStack<Integer> numberStack, ArrayStack<Character> operatorStack) {
    char op = operatorStack.pop();
    int num1 = numberStack.pop();
    int num2 = numberStack.pop();
    //num2 op num1
    if (op == '+') {
      numberStack.push(num2+num1);
    } else if (op == '-') {
      numberStack.push(num2-num1);
    } else if (op == '*') {
      numberStack.push(num2*num1);
    } else  {
      numberStack.push(num2/num1);
    }
  }

  //对原表达式进行格式化处理 给所有的非数字字符两边添加空格
  private static String insertBlanks(String expression) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0;i < expression.length (); i++ ) {
      char c = expression.charAt(i);
      if (c == '(' || c == ')' || c == '+' || c == '-' || c == '*' || c == '/') {
        sb.append(' ');
        sb.append(c);
        sb.append(' ');
      } else {
      sb.append(c);
      }
    }
    return sb.toString();
  }
}
//输出结果
 28
数据结构笔记——线性结构
qq_51594995的博客
10-03 342
文章目录前言一、线性表的定义和特点1.线性表的定义2.线性表的逻辑关系3.线性表的类型定义3.线性表的存储结构二、使用步骤1.引入库2.读入数据总结 前言 数据结构笔记第二章 一、线性表的定义和特点 1.线性表的定义 线性表是具有相应特性数据元素的一个有限序列，由n个数据元素组成 其中数据元素的个数n定义为表的长度 当n=0时称为空表 同一线性表中的元素必定具有相同特性，数据元素间的关系是线性关系 2.线性表的逻辑关系 在非空的线性表，有且仅有一个开始结点a1，它没有直接前趋，而只有一个直接后继a2..
算法与数据结构考研试题精析
04-14
标题《算法与数据结构考研试题精析》和描述“算法与数据结构历年考研试题分析与答案解析。主要就是拿来练练手”表明本文将深入探讨算法与数据结构的核心知识点，并通过历年考研试题的形式加以练习和巩固。由于提供的...
数据结构与算法_线性表
weixin_44540195的博客
05-07 358
线性表_知识小结 线性表的定义：由n(n>=)个相同类型的数据元素（结点）a1,a2,…an组成的有限序列(a1,a2,…an)，生活中有很多都是线性表，例如说：字母表，九九表，扑克牌称为复合线性表。 线性表的特征： 在非空的线表，有且仅有一个一个开始结点a1,它没有直接前趋，仅有一个直接后继a2。 有且仅有一个终端结点an，它没有直接后继，而仅有一个直接前趋an-1， 其余的内...
10线性结构
Lance___的博客
11-09 421
概念 数据元素之间存在一对一的线性关系。 线性结构这种逻辑结构有着两种物理存储结构：顺序存储、链式存储； 顺序存储的线性表称为顺序表，存储的物理位置和逻辑一样连续串联； 链式存储的线性表称为链表，存储的物理位置不一定连续，靠元素结点即存储该数据元素的空间结点附带相邻元素的地址信息； 线性结构又存在两种操作受限的线性表：栈、队列； 栈只能在线性表一端操作，FILO,分别又有顺序栈和链栈两种物理存储； 队列只能在线性表一端输入而另一端输出，FIFO，分别又有顺序队列和链式队列两种物理存储。 另外再链表中
线性结构
weixin_30834019的博客
08-02 179
概述 　　线性结构是包含n个相同类型元素的优先序列。在线性结构中，数据元素的前后关系是“一对一”的，即线性关系。 　　对于线性结构L=(a1, a2, ..., an)： 　　　　a.当1≤i<n且i<j≤n时，aj是ai的后继。ai+1是ai的直接后继。 　　　　b.当1<i≤n且1≤j<i时，aj是ai的前驱。ai-1是ai的直接前驱。 　　　　c.a1是头元...
【数据结构领域】Top 50 数据结构面试题解析：涵盖线性与非线性结构、栈队列、树图及算法分析结构
04-03
文章涵盖了数据结构的基本概念、应用、分类（线性和非线性），以及各种具体数据结构（如栈、队列、链表、树、图等）的特性与操作。此外，还探讨了算法分析、排序算法、内存管理、图搜索算法等高级主题。每个问题都配...
精选资源
武汉理工大学数据结构与算法实验——欢乐连连看（非线性结构）
06-22
《武汉理工大学数据结构与算法实验——欢乐连连看（非线性结构）》是针对计算机科学教育的一项重要实践项目，旨在深化学生对数据结构与算法的理解和应用。在本实验中，核心关注的是非线性结构的运用，这通常涉及到树...
C#数据结构与算法揭秘二 线性结构
01-21
上文对数据结构与算法，有了一个简单的概述与介绍，这篇文章，我们介绍一中典型数据结构——线性结构。 什么是线性结构，线性结构是最简单、最基本、最常用的数据结构。线性表是线性结构的抽象(Abstract)， 线性结构...
数据结构与算法学习笔记.pdf
最新发布
06-18
系统讲解数据结构与算法核心知识，涵盖线性结构（顺序表、链表、栈、队列）、树形结构（二叉树、AVL树、红黑树、B树、哈夫曼树、堆）、散列表（哈希函数、冲突处理），并结合LeetCode实战题目（如二分搜索、二叉树...
数据结构简答题
王小瑞的学习博客
03-25 2767
树是一种非线性的数据结构，其元素之间有明显的层次关系，由结点和边组成且不存在环；在树的结构中，每个结点都只有一个前件称为父结点，没有前件的结点为树的根结点，简称为树的根；每个结点可以有多个后件成为结点的子结点，没有后件的结点称为叶子结点。
1.1线性表的逻辑结构
weixin_30646505的博客
09-23 184
线性结构的基本特征 线性结构是一个数据元素有序集 集合中必存在唯一一个“第一元素” 集合中必须存在唯一一个“最后元素” 除最后一个元素外所有元素都有一个后继 除第一个元素外所有元素都有一个前继 线性表的定义 线性表是一种线性结构，在一个线性表中数据元素的类型是相同的，或者说线性表是由 同一类型的数据元素构成的线性结构，定义如下：线性表是具有相同数据类型的n(...
数据结构-线性结构
TxyITxs的博客
10-03 1489
一.线性结构 1.顺序线性表 1.1 线性结构是一种基本的数据结构，具有单一前驱和后继的数据关系描述。 1.2 线性表的存储结构分为顺序存储和链式存储。 1.3 顺序线性表的元素间的逻辑关系无需占用额外的空间来存储。 1.4 一般地，以LOC(a1a_1a1​)表示线性表中第一个元素的存储位置，在顺序存储结构中，第ｉ个元素aia_iai​的存储位置为 LOC(ai)=LOC(a1)+(i−1)∗L LOC(a_i) = LOC(a_1) + (i-1)*L LOC(ai​)=LOC(a1​)+(i−1)∗L
逻辑结构的四种基本关系
Jasmine的博客
07-06 1万+
逻辑结构的四种基本关系 1集合结构：数据元素之间除了“属于同一集合”的关系外，没有其他关系 2线性结构：数据元素之间存在一对一的关系 3树结构：数据元素之间存在一对多的关系 4图结构：数据元素之间存在多对多的关系 ...
数据的逻辑结构（线性结构、非线性结构；集合结构、线性结构、树状结构、网状结构），数据的存储结构（顺序结构、链式结构、索引结构、散列结构）
热门推荐
wyqwilliam的博客
09-15 2万+
数据的逻辑结构 数据的逻辑结构指数据元素之间的逻辑关系（和实现无关）。 分类1：线性结构和非线性结构 线性结构：有且只有一个开始结点和一个终端结点，并且所有结点都最多只有一个直接前驱和一个直接后继。 线性表就是一个典型的线性结构，它有四个基本特征：   1．集合中必存在唯一的一个"第一个元素"； 2．集合中必存在唯一的一个"最后的元素"； 3．除最后元素之外，其它数据元素均有唯一的"后继"...
数据的逻辑结构
ZJSJKND
01-18 1万+
数据的逻辑结构                                                                                                                                                                版权归为数据结构标准教程 书籍 在上面提到数据分为逻辑结构和物
线性表的逻辑结构
bingXxx的博客
12-11 7916
线性表的定义:用数据元素的有限序列表示的表,我们称之为线性表 比如 a1,a2,a3,a4…an,其中a1就是线性表的起点,而a1中的下标1表示的就是元素的序号,它表示了这个元素在线性表中的位置,而相对a2来说它的直接前驱就是a1,而它的直接后继就是a3,而an中n表示的就是这个线性表的长度. 注意:同一个线性表具有相同的特性,相邻的数据元素之间是序偶关系(表示的就是有序成对的意思) 比如上面这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值