数据结构：线性结构之线性表

最新推荐文章于 2022-12-23 15:53:13 发布
最新推荐文章于 2022-12-23 15:53:13 发布
阅读量598 收藏 4
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 链表 java c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42080839/article/details/103969621
版权 
就算没有天分，只要你愿意每天花一点时间，做同样一件事情，不知不觉间，你就会走得很远。

什么是线性表？

线性表是n（n>= 0）个元素的有限序列。在表中，元素之间存在这线性的逻辑关系：
（1）表中有且仅有一个开始结点；
（2）有且仅有一个终端结点；
（3）除开始结点外，表中的每一个结点均只有一个前驱结点；
（4）除终端结点外，表中的每一个结点均只有一个后继结点；
根据他们之间的关系可以排成一个现线性序列，记作：（a1，a2，...，an）
例如：26个英文字母表（A,B,C,...,X,Y,Z）就是一个线性表
这里的ai（1<=i<=n）属于同一数据对象，具有相同的数据类型。线性表中的数据元素
个数n就是线性表的长度，称作表长，n=0时为空表。i则是数据元素ai的位序。

线性表的存储方式

线性表有两种存储方式：顺序存储和链式存储

（一）顺序表

顺序存储是在内存中用一块地址连续的存储空间按顺序存储线性表的各个数据元素。
采用顺序存储结构的性表称为顺序表，顺序表中逻辑上相邻的数据元素在物理存储位置上也是相邻的。
只要确定了存储线性表的起始位置，线性表中的任意一个数据都可随机存取：
第i个元素的地址为：Loc(ai) = Loc(a1) + size * (i - 1)  其中size是每个元素所占的空间大小。
C语言版的实现
#include <stdio.h>
#include <stdlib.h>
#define ERROR 0
#define OK 1
#define TRUE 1
#define FALSE 0
#define NOTFOUND -1
#define MAXSIZE 100
#define seqNodeDataType int
//结构体定义
typedef struct seqNode{

    seqNodeDataType data[MAXSIZE];
    int length;

}SeqNode;
//初始化
void Init_SeqList(SeqNode * L){
    L->length = 0;
}
//判空
int IsEmpty_SeqList(SeqNode L){

    if (L.length == 0) {
        return TRUE;
    } else {
        return FALSE;
    }
}
//判满
int IsFull_SeqList(SeqNode L){

    if (L.length == MAXSIZE - 1) {
        return TRUE;
    } else {
        return FALSE;
    }
}
//获取真实长度
int GetListLength_SeqList(SeqNode L){
    return L.length;
}
//获得index处的元素
seqNodeDataType GetElem_SeqList(SeqNode L, int index){

    if (index < 0 || index >= L.length) {
        return ERROR;
    }

    return L.data[index];
}
//按值查找
int IndexOf_SeqList(SeqNode L, seqNodeDataType elem){

    for (int i = 0; i < L.length; ++i) {

        if (L.data[i] == elem) {
            return i;
        }
    }

    return NOTFOUND;
}
//打印输出
void Print_SeqList(SeqNode L){

    printf("[");
    for (int i = 0; i < L.length; ++i) {

        if (i == L.length - 1) {
            printf("%d", L.data[i]);
        } else {
            printf("%d,", L.data[i]);
        }
    }
    printf("]\n");
}
//在index处插入元素
int InsertOfIndex_SeqList(SeqNode *L, int index, seqNodeDataType elem){

    if (index < 0 || index > L->length) {
        return ERROR;
    }
    
    if (IsFull_SeqList(*L)) {
        return ERROR;
    }
    for (int i = L->length; i > index; --i) {

        L->data[i] = L->data[i - 1];

    }

    L->data[index] = elem;
    L->length++;

    return OK;
}
//首部添加元素
int InsertFirst_SeqList(SeqNode *L, seqNodeDataType elem){
    InsertOfIndex_SeqList(L, 0, elem);
}
//尾部添加元素
int InsertLast_SeqList(SeqNode *L, seqNodeDataType elem){
    InsertOfIndex_SeqList(L, L->length, elem);
}
//删除元素
int DeleteOfIndex_SeqList(SeqNode *L, int index, seqNodeDataType *result){

    if (index < 0 || index > L->length) {
        return ERROR;
    }

    if (IsEmpty_SeqList(*L)) {
        return ERROR;
    }

    for (int i = index; i < L->length - 1; ++i) {
        L->data[i] = L->data[i + 1];
    }

    L->length--;

    return OK;
}
//清空数据
int Clear_SeqList(SeqNode *L){
    L->length = 0;
    return OK;
}
缺点在哪里
由于顺序表底层实现是一个数组，而数组的容量无法改变，因而存在的最大问题就是空间分配多大才合适呢？
过小导致数据无法继续存放，而过大则造成空间的浪费。可以使用高级语言来优化顺序表，实现动态数组扩容。
Java版实现
package cn.boom.list;

public class SeqList<T> {

    private T[] data;
    private int size;

    //无参构造
    public SeqList(){
        data = (T[]) new Object[10];
        size = 0;
    }

    //带参构造 ：参数 容量
    public SeqList(int capacity) {
        data = (T[]) new Object[capacity];
        size = 0;
    }

    /**
     * 获取真实长度（数据个数）
     * @return size
     */
    public int getSize(){
        return this.size;
    }

    /**
     * 获取index索引位置的元素
     * @param index
     * @return data[index]
     * @throws IllegalArgumentException 参数不合法异常
     */
    public T getIndexOf(int index) throws IllegalArgumentException{
        //参数合法性校验
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Illegal Index ！");
        }
        return this.data[index];
    }

    //修改值
    public void set(int index, T elem) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Illegal Index ！");
        }
        data[index] = elem;
    }

    /**
     * 按值查找 返回elem第一次出现的下标 未找到返回-1
     * @param elem
     * @return index
     */
    public int locationElem(T elem){

        for (int i = 0; i < this.size; i++) {

            if (elem.equals(this.data[i])) {
                return i;
            }
        }
        return -1;
    }

    //是否存在元素
    public boolean contains(T elem){
        return locationElem(elem) != -1;
    }

    //表是否为空
    public boolean isEmpty(){
        return (size == 0);
    }

    //表是否为空
    public boolean isFull(){
        return (size == data.length);
    }

    //获取容量
    public int getCapacity(){
        return data.length;
    }

    //在 index处插入一个元素
    public void add(int index, T elem) {

        //参数合法性校验

        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Illegal Index ! index is " + index);
        }

        if (isFull()) {
            updateCapacity(data.length * 2);
        }

        //在 index 后的数据后移
        for (int i = size; i > index; i--) {
            this.data[i] = this.data[i - 1];
        }

        this.data[index] = elem;

        size++;
    }

    //在数组首部添加元素
    public void addFirst(T elem) {
        add(0, elem);
    }

    //在数组尾部添加元素
    public void addLast( T elem){
        add(this.size,elem);
    }


    //更新数组容量
    public void updateCapacity(int newCapacity) {

        T[] newArray = (T[]) new Object[newCapacity];

        for (int i = 0; i < size; i++) { // copy原数组中的数据
            newArray[i] = data[i];
        }

        this.data = newArray;

    }

    //删除下标为index的元素并返回
    public T remove(int index){

        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Illegal Index ! index is " + index);
        }

        T elem = data[index];

        for (int i = index; i < size - 1; i++) {
            data[i] = data[i + 1];
        }

        size--;

        if (size < data.length / 2) { //缩容
            updateCapacity(data.length / 2);
        }

        return elem;
    }

    //删除第一个元素
    public T removeFirst() {
        return remove(0);
    }

    //删除最后一个元素
    public T removeLast() {
        return remove(size - 1);
    }

    @Override
    public String toString() {

        StringBuilder res = new StringBuilder();

        res.append("SeqList{");

        res.append(" data=[");

        for (int i = 0; i < this.size; i++) {

            res.append(this.data[i].toString());

            if (i != size - 1) {
                res.append(',');
            }
        }
        res.append("], size=" + size +  ", capacity=" + getCapacity() + " }");

        return res.toString();
    }
}


以上的代码虽然实现了数组空间的动态扩容和缩容，但顺序表依然是一种非动态的存储结构。
下面介绍动态存储结构的链表。
（二）单链表
链表是通过一组任意的存储单元来存储线性表中的数据元素。这组存储单元可以是连续的，也可以是不连续的。
为建立起数据元素之间的线性关系，对于每个数据元素an,除了存放数据元素自身的信息外，还必须有包含指示该元素直接后继元素存储位置的信息，
这两部分信息组成个“结点”，即每个结点都至少包括两个域，一个域存储数据 元素信息，称为数据域;另一个域存储直接后继元素的地址，称为指针域。

在这里插入图片描述
有时为了操作方便，在单链表的第一个结点之前附加一 个结点， 称为头结点。头结点的数据域可以存储标题、表长等信息，也可以不存储任何信息，其指针域存储第个结点的首地址， 头结点由头指针指向。
在这里插入图片描述

单链表C语言版
#include <stdio.h>
#include <stdlib.h>
#define ERROR 0
#define OK 1
#define TRUE 1
#define FALSE 0
#define NOTFOUND -1
#define linkedListDataType int

typedef struct linkedNode{

    linkedListDataType data;
    struct linkedNode* next;

}LNode;

//头插法建立单链表
int CreateHead_LinkedList(LNode ** H){

    (*H)->next = NULL;

    int elem;

    scanf("%d",&elem);

    while (elem != -1) {

        LNode* s = (LNode *) malloc(sizeof(LNode));
        s->data = elem;

        s->next = (*H)->next;
        (*H)->next = s;

        scanf("%d", &elem);

    }

    return OK;
}
//初始化链表
LNode *Init_LinkedList() {

    LNode *H = (LNode *) malloc(sizeof(LNode));

    if (H == NULL) {
        return ERROR;
    }

    H->next = NULL;
    return H;
}

//尾插法建立单链表
int CreateTail_LinkedList(LNode ** H){

    (*H)->next = NULL;

    LNode *p = *H;
    int elem;

    scanf("%d",&elem);

    while (elem != -1) {

        LNode* s = (LNode *) malloc(sizeof(LNode));
        s->data = elem;
        s->next = NULL;
        p->next = s;
        p = s;

        scanf("%d", &elem);

    }

}
//获取链表长度
int GetSize_LinkedList(LNode *H){

    LNode *p = H;
    int size = 0;

    while (p->next != NULL) {
        size++;
        p = p->next;
    }

    return size;

}
//判断链表是否为空
int IsEmpty(LNode *H){
    if ( H == NULL || GetSize_LinkedList(H) == 0) {
        return 1;
    }
    return 0;
}

//输出打印链表
void Print_LinkedList(LNode *H){

    LNode *p = H;
    printf("head -> ");

    while (p->next != NULL) {

        printf("%d -> ", p->next->data);

        p = p->next;
    }

    printf("NULL\n");

}
//获取索引结点
LNode* GetNode_LinkedList(LNode *H, int index) {

    if (index == -1) {
        return H;
    }

    LNode *p = H;
    int count = 0;

    while (p->next != NULL) {

        p = p->next;

        if (index == count) {
            return p;
        }
        count++;
    }
    return NULL;

}

//通过索引删除结点
int DeleteNodeByIndex_LinkedList(LNode *H, int index) {

    LNode *p = GetNode_LinkedList(H, index - 1);
    LNode *q = p->next;
    p->next = p->next->next;
    free(q);
    return OK;
}
//在索引处插入一个结点
int InsertNodeIndexOf_LinkedList(LNode *H, int index, linkedListDataType elem) {

    if (index > GetSize_LinkedList(H)) {
        return ERROR;
    }

    LNode *p = GetNode_LinkedList(H, index - 1);

    LNode* s = (LNode *) malloc(sizeof(LNode));

    if (s == NULL) {
        return ERROR;
    }

    s->data = elem;

    s->next = p->next;
    p->next = s;

    return OK;
}
//在链表尾部插入一个元素
int InsertNodeTail_LinkedList(LNode *H, linkedListDataType elem) {

    InsertNodeIndexOf_LinkedList(H,GetSize_LinkedList(H),elem);
    return OK;
}

//修改索引处结点的值
int UpdateNodeByIndex_LinkedList(LNode *H, int index, linkedListDataType elem){

    LNode *p = GetNode_LinkedList(H, index);
    p->data = elem;
    return OK;

}
//删除重复元素结点
void DeleteRepeatElem(LNode *H){

    if (H == NULL) {
        return;
    }

    LNode *p = H->next;

    if (p == NULL) {
        return;
    }

    while (p->next != NULL) {

        LNode *q = p->next;

        while (q != NULL) {

            if (p->data == q->data) {
                //删除q结点
                LNode *t = q;
                q = q->next;
                free(t);
                p->next = q;

            } else {
                q = q->next;
            }

        }
        p = p->next;
    }

}
Java实现单链表
package cn.boom.list;

public class LinkedList<T> {

    private Node head;//虚拟头结点
    private int size;//表长

    private class Node {

        private T data;
        private Node next;

        public Node() {
            this.data = null;
            this.next = null;
        }

        public Node(T data) {
            this.data = data;
            this.next = null;
        }

        public Node(T data, Node node) {
            this.data = data;
            this.next = node;
        }

    }

    public LinkedList() {
        this.head = new Node();
        this.size = 0;
    }

    /**
     * 获取链表长度
     * @return
     */
    public int getSize() {
        return this.size;
    }

    /**
     * 判断链表是否为空
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 在链表的index(0-size)位置添加新的元素
     * @param index
     * @param elem
     */
    public void add(int index, T elem) {

        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Index Is Illegal Argument ! index = " + index);
        }

        Node node = this.head;

        for (int i = 0; i < index ; i++) { //找到待插入下标的前一个结点
            node = node.next;
        }

        Node e = new Node(elem);
        //插入结点
        e.next = node.next;
        node.next = e;

        this.size++;
    }

    /**
     * 在链表首部位置添加新的元素
     * @param elem
     */
    public void addFirst(T elem) {
        add(0,elem);
    }

    /**
     * 在链表尾部位置添加新的元素
     * @param elem
     */
    public void addLast(T elem) {
        add(size,elem);
    }

    /**
     * 获得链表的第index(0-size)个位置的元素
     * @param index
     * @return
     */
    public T get(int index) {
    
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Index Is Illegal Argument ! index = " + index);
        }

        Node node = this.head.next;

        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node.data;
    }

    /**
     * 修改链表的第index(0-size)个位置的元素
     * @param index
     * @param elem
     */
    public void set(int index, T elem) {

        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Index Is Illegal Argument ! index = " + index);
        }

        Node node = this.head.next;

        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        node.data = elem;
    }

    /**
     * 查询表中是否包含该元素
     * @param elem
     * @return
     */
    public boolean contains(T elem) {

        Node node = this.head.next;

        while (node != null) {

            if (node.data.equals(elem)) {
                return true;
            }
            node = node.next;
        }
        return false;
    }

    /**
     * 删除index(0-size)处的结点并返回数据
     * @param index
     * @return
     */
    public T remove(int index) {

        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Index Is Illegal Argument ! index = " + index);
        }

        Node node = this.head;

        for (int i = 0; i < index - 1; i++) { //找到要删除节点的前一个结点
            node = node.next;
        }
        Node s = node.next;
        node.next = s.next;
        s.next = null;
        this.size--;

        return s.data;
    }

    /**
     * 从表中删除元素e
     * @param elem
     */
    public void removeElement(T elem) {

        Node preNode = this.head;
        Node node = preNode.next;

        while (node != null) {

            if (node.data.equals(elem)) {
                preNode.next = node.next;
                node.next = null;
                node = preNode.next;
                this.size--;
                continue;
            }

            preNode = node;
            node = node.next;
        }
    }

    @Override
    public String toString() {

        Node node = this.head.next;
        StringBuilder res = new StringBuilder();
        res.append("head -> ");
        for (int i = 0; i < this.size; i++) {
            res.append(node.data.toString() + " -> ");
            node = node.next;
        }
        res.append("NULL");
        return res.toString();
    }
}
顺序表和链表的优缺点
顺序表优点：
(1)用数组存储数据元素，操作方法简单，容易实现。
(2)无须为表示结点间的逻辑关系而增加额外的存储开销。
(3)存储密度高。
(4)顺序表可按元素位序随机存取结点。
缺点：
(1)做插入、删除操作时，须大量地移动数据元素，效率比较低。
(2)要占用连续的存储空间，存储分配只能预先进行。如果估计过大，可能导致后部大量空闲置;如果预先分配过小，又会造成数据溢出。
链表的优缺点刚好和顺序表相反。
参考文献
[1]王曙燕.数据结构与算法:人民邮电出版社
白日梦想家　
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[数据结构]线性结构——线性表
超越
11-12 2405
概述
【数据结构】1.线性结构：线性表
深思深练 厚积薄发
10-21 828
# 一、什么是线性表？ 线性表（Linear List）是一种由**同类型数据元素**构成的**有序序列**的线性结构。 表中元素个数称为长度；无元素时称为空表；表的起始位置为表头，结束位置为表尾。
线性结构之线性表
Black_carbon的博客
07-17 498
线性结构的特点： 存在唯一的一个被称做“第一个”的数据元素； 存在唯一的一个被称做“最后一个”的数据元素； 除第一个之外，集合中的每个数据元素均只有一个前驱； 除最后一个之外，集合中每个数据元素均只有一个后继； 线性表：一个线性表是n个数据元素的有限序列。 线性表再物理结构的表示上可以分为（1）顺序表示和（2）链式表示。 （1）线性表的顺序表示：线性表的顺序表示指的是用一组地址连续的存...
线性结构—线性表
Dear_Mr的博客
04-13 939
线性结构之线性表线性结构：线性表、栈、队列、串和数组线性结构的特点：除了第一个元素和最后一个元素外，每个数据元素有一个前驱和一个后继，线性表是最简单、最基本、最常用的数据结构，它有顺序存储和链式存储两种存储方案1. 线性表线性表是n个数据元素的有限序列，在表中，元素之间存在着线性的逻辑关系特点：同一性（线性表由同类元素组成，每一个ai必须属于同一数据对象）​ 有穷性（线性表是由有限个数
数据结构之线性表
大数据跟我学i
04-20 236
文章目录基本概念线性表的存储结构线性表的特点线性表的基本操作 基本概念 线性表，就是将数据排成像一条长线一样的结构，数组，链表，栈，队列都 是线性表结构，线性表上的数据最多只有前后两个方向，下面以一幅图的形式来展现一下线性表结构 补充： 与这种线性结构对应的就是非线性结构，比如后续要学习的数，堆，图等，在这些非线性数据结构 中，数据之间并不是简单的前后关系，如下图： 线性表的存储结构 线性表在计算机中可以用顺序存储和链式存储两种存储结构来表示： 顺序存储结构的线性表：顺序表 链式存储结构的线性表
数据结构：线性表(顺序存储).ppt
06-19
数据结构：线性表（顺序存储） 线性表是具有相同属性的数据元素的一个有限序列。线性表中的各元素都具有同种数据类型，表的长度可用 n（n>=0）表示，表中所含元素个数即为线性表的长度。特殊情况 n=0，且线性表的...
数据结构之线性表的实现.rar
07-27
在这个压缩包“数据结构之线性表的实现.rar”中，我们可以找到关于线性表实现的详细内容，特别是针对严蔚敏版数据结构的实现。 线性表的常见实现方式有两种：顺序表和链表。在顺序表中，元素在内存中是连续存储的，...
c语言数据结构线性表创建删除插入
06-30
本主题聚焦于C语言中的数据结构——线性表，这是数据结构的基础概念之一，适用于初学者学习。线性表是一种逻辑上一维、元素之间具有线性关系的数据结构。下面将详细阐述线性表的创建、删除和插入操作。 1. **线性表...
Java数据结构之线性表
08-31
Java中的线性表是一种基本的数据结构，它由一系列具有线性关系的元素构成，这些元素在逻辑上形成一个序列。线性表支持多种操作，包括获取元素、设置元素值、遍历、插入、删除、查找、替换和排序。线性表的存储方式有...
用C#学习数据结构之线性表
12-22
线性表是线性结构的抽象(Abstract)，线性结构的特点是结构中的数据元素之间存在一对一的线性关系。这种一对一的关系指的是数据元素之间的位置关系，即：（1）除第一个位置的数据元素外，其它数据元素位置的前面都...
数据结构：线性表
y_h_k_666的博客
03-28 2767
线性表是基本的数据结构之一，是一组元素的抽象。 线性表包含顺序表和链接表（简称链表），顺序表在C语言中一般使用数组去实现，链表使用结构体去实现。在Python中，list对象是采用顺序表实现的。 1. 顺序表 顺序表是将表中的元素顺序的存储在连续的内存里。 优点： 查询速度快，时间复杂度为O(1) 缺点： 插入元素速度慢，时间复杂度为O(n) 表中元素个数需要提前定义 2. 链表 链表：通过链接各个结点实现的技术就叫做链表。链表中的结点分为指针域和数据域，具体见下图。结点中的data用来存放数据
数据结构-线性表
qq_36417330的博客
03-25 316
线性表是n个数据特性相同的元素的组成有限序列，是最基本且常用的一种线性结构(线性表，栈，队列，串和数组都是线性结构），同时也是其他数据结构的基础。线性表有以下特点： 由0个或多个数据元素组成的有限序列 是一个序列 第一个无前驱，最后一个无后续 元素有限 1 顺序表 用一段地址连续的存储单元依次存储线性表的数据结构。顺序存储结构封装的三个属性 起始位置 最大存储容量 MaxSize 当前长度 ...
数据结构——线性表
qq_52434831的博客
04-24 2893
数据结构线性表的基础知识及常用算法的总结
数据结构（二） 线性结构之线性表
jianguo798937767的博客
03-17 454
线性表（linear list） 表格 n个数据元素的有限序列。 数据元素类型不局限于数字。如：字母表一个数据元素可以由若干项（item）组成。此时，将数据元素称为记录(record)，含大量记录的线性表称为文件（file）。同一线性表的元素具有相同特性。序偶性。 将线性表记为（a1,a2,......,ak,......an） 其中n（n>=0）定义为线性表的程度，
数据结构与算法基础04-- 线性结构及线性表
Techblog of HaoWANG
11-08 463
【摘要】线性表是一种常用的线性结构，诸如堆栈、队列和串也都属于线性结构。非空线性结构具有两个特点：它具有唯一的第一个数据元素和最后一个数据元素；并且除了第一个元素和最后一个元素以外，其他元素都只有一个直接前驱和一个后继。线性表主要的存储结构有两种：顺序存储结构和链式存储结构。本文总结了线性表的定义、存储方式的描述和基本运算操作以及基于C语言的算法实现。 1. 线性表(Linear L...
数据结构与算法3：线性结构与线性表-链表
游龙YoooLong
12-09 682
链表
线性数据结构（线性表、链表、栈、队列、散列表）
上帝已逝，自求多福
04-16 4105
线性表 栈 队列 散列表（Hash）
【数据结构】线性表——建表
隰有芦荻的博客
03-24 349
目录建表算法代码顺序表功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 建表算法代码 顺序表 顺序表建表算法代码 /*变...
线性表（数据结构）
最新发布
ttdffmm的博客
12-23 447
线性表是最基本最简单，也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。如果把线性表用数学语言来定义，则可以表示为(a1,...ai-1,ai,ai+1,...an)，ai-1领先于ai,ai领先于ai+1，称ai-1是ai的前驱元素，ai+1是ai的后继元素。
数据结构：线性表查找优化算法详解
本文档主要针对数据结构的学习者提供了一组关于线性表的练习题和相关概念解析，着重于数据结构的第一章绪论和第二章线性表。以下是详细的知识点： 1. 数据结构概论： - 数据结构是一门研究数据的组织、存储以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值