【数据结构之线性表】

最新推荐文章于 2024-08-29 22:06:50 发布
最新推荐文章于 2024-08-29 22:06:50 发布
阅读量423 收藏 9
点赞数 6
分类专栏： 数据结构 文章标签： 数据结构 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66726657/article/details/141672886
版权

文章目录

一、线性表的基本概念

1. 定义

线性表是一种最基本的数据结构，它由相同类型的元素按顺序排列而成。在计算机内存中，这些元素被依次存放，形成一个线性序列。线性表可以用来表示一系列有序的数据，如整数、字符、对象等。

2. 特点

2.1 元素有序排列

线性表中的元素按照某种顺序依次排列。每个元素都有一个唯一的位置，通常从第一个元素到最后一个元素的顺序排列，这些位置用索引标识。在数组中，这种索引从0开始，而在链表中，则由节点指针来确定顺序。

2.2 元素类型相同

线性表中的所有元素必须是相同类型的。这种同质性保证了数据的一致性和操作的统一性。例如，一个整数型线性表只能存储整数，不能混合存储其他类型的数据。这个特点使得线性表在处理一类数据时具有很高的效率和简洁性。

2.3 元素之间存在一对一的关系

在线性表中，每个元素都有一个前驱（除了第一个元素）和一个后继（除了最后一个元素）。这种一对一的关系确保了线性表的结构简单明了。在内存中，这种关系可以通过数组的索引或者链表的节点指针来体现。这种特性使得线性表在执行插入、删除等操作时非常直观，但也使得某些操作（如中间插入和删除）可能比较耗时，特别是在顺序存储结构中。

二、线性表的实现方式（C++）

在C++中，线性表可以通过两种主要方式来实现：顺序表（数组）和链表。每种方式都有其独特的优点和缺点，根据不同的应用场景，选择合适的实现方式能够显著提高程序的效率和灵活性。

1. 顺序表（数组）

顺序表是一种使用连续的内存空间来存储数据的线性表。在C++中，顺序表通常通过数组来实现。

1.1 定义

顺序表通过一个数组来存储所有元素。每个元素都占据数组的一个位置，这些位置由连续的内存地址表示。顺序表的大小在初始化时确定，因此它的容量是固定的。

1.2 实现示例

#include <iostream>
using namespace std;

class SequenceList {
private:
    int *array;
    int capacity;
    int size;

public:
    SequenceList(int capacity) {
        this->capacity = capacity;
        size = 0;
        array = new int[capacity];
    }

    ~SequenceList() {
        delete[] array;
    }

    void insert(int value) {
        if (size < capacity) {
            array[size++] = value;
        } else {
            cout << "List is full" << endl;
        }
    }

    int get(int index) {
        if (index >= 0 && index < size) {
            return array[index];
        } else {
            throw out_of_range("Index out of range");
        }
    }

    void display() {
        for (int i = 0; i < size; ++i) {
            cout << array[i] << " ";
        }
        cout << endl;
    }
};

int main() {
    SequenceList list(10);
    list.insert(1);
    list.insert(2);
    list.insert(3);
    list.display();
    cout << "Element at index 1: " << list.get(1) << endl;

    return 0;
}

1.3 优点

  • 随机访问速度快: 由于数组中的元素具有连续的内存地址，可以通过元素的索引直接访问，这使得随机访问非常高效，时间复杂度为O(1)。

1.4 缺点

  • 插入和删除操作较慢: 由于数组大小固定，在进行插入或删除操作时，可能需要移动大量元素来腾出空间或填补空缺，这使得这些操作的时间复杂度为O(n)。
  • 固定大小: 数组的大小在创建时确定，如果需要存储的元素超过了数组的容量，就需要重新分配内存，这可能导致性能开销。

2. 链表

链表是一种使用节点存储数据的线性表，每个节点包含数据和指向下一个节点的指针。在C++中，链表通常通过类或结构体来实现。

2.1 定义

链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表的第一个节点称为头节点，最后一个节点的指针为NULL，表示链表的结束。

2.2 实现示例

#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* next;

    Node(int value) : data(value), next(nullptr) {}
};

class LinkedList {
private:
    Node* head;

public:
    LinkedList() : head(nullptr) {}

    ~LinkedList() {
        Node* current = head;
        Node* next;
        while (current != nullptr) {
            next = current->next;
            delete current;
            current = next;
        }
    }

    void insert(int value) {
        Node* newNode = new Node(value);
        newNode->next = head;
        head = newNode;
    }

    void display() {
        Node* current = head;
        while (current != nullptr) {
            cout << current->data << " ";
            current = current->next;
        }
        cout << endl;
    }
};

int main() {
    LinkedList list;
    list.insert(1);
    list.insert(2);
    list.insert(3);
    list.display();

    return 0;
}

2.3 优点

  • 插入和删除操作快: 链表中的插入和删除操作只涉及节点指针的修改，不需要移动其他元素，因此这些操作的时间复杂度为O(1)（假设已找到插入或删除位置）。

2.4 缺点

  • 随机访问速度慢: 链表不支持随机访问，要访问特定位置的元素，必须从头节点开始逐个遍历，时间复杂度为O(n)。
  • 内存占用多: 每个节点除了存储数据外，还需要存储一个指针，这会增加额外的内存开销。

三、线性表的操作

1. 增加操作

1.1 在顺序表中增加元素

在顺序表（数组）中增加元素通常涉及将新元素插入到现有数据的指定位置，并调整数组中的元素。

实现示例
#include <iostream>
using namespace std;

class SequenceList {
private:
    int *array;
    int capacity;
    int size;

public:
    SequenceList(int capacity) {
        this->capacity = capacity;
        size = 0;
        array = new int[capacity];
    }

    ~SequenceList() {
        delete[] array;
    }

    void insert(int value, int index) {
        if (index < 0 || index > size || size >= capacity) {
            cout << "Invalid index or list is full" << endl;
            return;
        }
        for (int i = size; i > index; --i) {
            array[i] = array[i - 1];
        }
        array[index] = value;
        ++size;
    }

    void display() {
        for (int i = 0; i < size; ++i) {
            cout << array[i] << " ";
        }
        cout << endl;
    }
};

int main() {
    SequenceList list(10);
    list.insert(1, 0);
    list.insert(2, 1);
    list.insert(3, 1);  // Insert 3 at index 1
    list.display();

    return 0;
}

1.2 在链表中增加节点

在链表中增加节点通常涉及创建一个新节点，并将其插入到链表的指定位置。

实现示例
#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* next;

    Node(int value) : data(value), next(nullptr) {}
};

class LinkedList {
private:
    Node* head;

public:
    LinkedList() : head(nullptr) {}

    ~LinkedList() {
        Node* current = head;
        Node* next;
        while (current != nullptr) {
            next = current->next;
            delete current;
            current = next;
        }
    }

    void insert(int value, int index) {
        Node* newNode = new Node(value);
        if (index == 0) {
            newNode->next = head;
            head = newNode;
            return;
        }
        Node* current = head;
        for (int i = 0; i < index - 1 && current != nullptr; ++i) {
            current = current->next;
        }
        if (current == nullptr) {
            cout << "Index out of bounds" << endl;
            delete newNode;
            return;
        }
        newNode->next = current->next;
        current->next = newNode;
    }

    void display() {
        Node* current = head;
        while (current != nullptr) {
            cout << current->data << " ";
            current = current->next;
        }
        cout << endl;
    }
};

int main() {
    LinkedList list;
    list.insert(1, 0);
    list.insert(2, 1);
    list.insert(3, 1);  // Insert 3 at index 1
    list.display();

    return 0;
}

2. 删除操作

2.1 删除顺序表中的元素

删除顺序表中的元素涉及将指定位置的元素移除，并调整其后的所有元素。

实现示例
#include <iostream>
using namespace std;

class SequenceList {
private:
    int *array;
    int capacity;
    int size;

public:
    SequenceList(int capacity) {
        this->capacity = capacity;
        size = 0;
        array = new int[capacity];
    }

    ~SequenceList() {
        delete[] array;
    }

    void remove(int index) {
        if (index < 0 || index >= size) {
            cout << "Invalid index" << endl;
            return;
        }
        for (int i = index; i < size - 1; ++i) {
            array[i] = array[i + 1];
        }
        --size;
    }

    void display() {
        for (int i = 0; i < size; ++i) {
            cout << array[i] << " ";
        }
        cout << endl;
    }
};

int main() {
    SequenceList list(10);
    list.insert(1, 0);
    list.insert(2, 1);
    list.insert(3, 2);
    list.remove(1);  // Remove element at index 1
    list.display();

    return 0;
}

2.2 删除链表中的节点

在链表中删除节点通常涉及调整指针以绕过被删除的节点。

实现示例
#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* next;

    Node(int value) : data(value), next(nullptr) {}
};

class LinkedList {
private:
    Node* head;

public:
    LinkedList() : head(nullptr) {}

    ~LinkedList() {
        Node* current = head;
        Node* next;
        while (current != nullptr) {
            next = current->next;
            delete current;
            current = next;
        }
    }

    void remove(int index) {
        if (index < 0 || head == nullptr) {
            cout << "Invalid index or list is empty" << endl;
            return;
        }
        Node* temp;
        if (index == 0) {
            temp = head;
            head = head->next;
            delete temp;
            return;
        }
        Node* current = head;
        for (int i = 0; i < index - 1 && current != nullptr; ++i) {
            current = current->next;
        }
        if (current == nullptr || current->next == nullptr) {
            cout << "Index out of bounds" << endl;
            return;
        }
        temp = current->next;
        current->next = temp->next;
        delete temp;
    }

    void display() {
        Node* current = head;
        while (current != nullptr) {
            cout << current->data << " ";
            current = current->next;
        }
        cout << endl;
    }
};

int main() {
    LinkedList list;
    list.insert(1, 0);
    list.insert(2, 1);
    list.insert(3, 2);
    list.remove(1);  // Remove element at index 1
    list.display();

    return 0;
}

3. 查询操作

3.1 顺序访问和随机访问

在顺序表中，可以通过索引进行随机访问，而在链表中只能顺序访问。

顺序访问示例（链表）
#include <iostream>
using namespace std;

// 链表节点类
class Node {
public:
    int data;
    Node* next;
    Node(int value) : data(value), next(nullptr) {}
};

// 链表类
class LinkedList {
private:
    Node* head;
public:
    LinkedList() : head(nullptr) {}

    // 添加节点到链表末尾
    void append(int value) {
        Node* newNode = new Node(value);
        if (head == nullptr) {
            head = newNode;
        } else {
            Node* current = head;
            while (current->next != nullptr) {
                current = current->next;
            }
            current->next = newNode;
        }
    }

    // 顺序访问链表中的元素
    void sequentialAccess(int position) {
        if (position < 0) {
            cout << "Invalid position." << endl;
            return;
        }
        Node* current = head;
        int index = 0;
        while (current != nullptr) {
            if (index == position) {
                cout << "Element at position " << position << ": " << current->data << endl;
                return;
            }
            current = current->next;
            index++;
        }
        cout << "Position out of range." << endl;
    }

    // 打印链表中的所有元素
    void printList() {
        Node* current = head;
        while (current != nullptr) {
            cout << current->data << " -> ";
            current = current->next;
        }
        cout << "null" << endl;
    }
};

int main() {
    LinkedList list;
    list.append(10);
    list.append(20);
    list.append(30);
    list.append(40);

    list.printList();  // 输出链表中的所有元素

    list.sequentialAccess(2);  // 顺序访问链表中的第2个元素
    list.sequentialAccess(5);  // 尝试访问链表中超出范围的元素

    return 0;
}
随机访问示例（顺序表）
#include <iostream>
using namespace std;

class SequenceList {
private:
    int *array;
    int capacity;
    int size;

public:
    SequenceList(int capacity) {
        this->capacity = capacity;
        size = 0;
        array = new int[capacity];
    }

    ~SequenceList() {
        delete[] array;
    }

    int get(int index) {
        if (index < 0 || index >= size) {
            throw out_of_range("Index out of range");
        }
        return array[index];
    }

    void display() {
        for (int i = 0; i < size; ++i) {
            cout << array[i] << " ";
        }
        cout << endl;
    }
};

int main() {
    SequenceList list(10);
    list.insert(1, 0);
    list.insert(2, 1);
    list.insert(3, 2);
    cout << "Element at index 1: " << list.get(1) << endl;

    return 0;
}

3.2 查找特定元素的位置

在顺序表中可以直接使用索引获取元素，而在链表中则需要遍历链表。

查找特定元素位置示例（链表）
#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* next;

    Node(int value) : data(value), next(nullptr) {}
};

class LinkedList {
private:
    Node* head;

public:
    LinkedList() : head(nullptr) {}

    ~LinkedList() {
        Node* current = head;
        Node* next;
        while (current != nullptr) {
            next = current->next;
            delete current;
            current = next;
        }
    }

    int find(int value) {
        Node* current = head;
        int index = 0;
        while (current != nullptr) {
            if (current->data == value) {
                return index;
            }
            current = current->next;
            ++index;
        }
        return -1;  // Element not found
    }

    void display() {
        Node* current = head;
        while (current != nullptr) {
            cout << current->data << " ";
            current =

 current->next;
        }
        cout << endl;
    }
};

int main() {
    LinkedList list;
    list.insert(1, 0);
    list.insert(2, 1);
    list.insert(3, 2);
    cout << "Index of element 2: " << list.find(2) << endl;

    return 0;
}

4. 修改操作

4.1 修改顺序表中某个位置的元素

在顺序表中，修改某个位置的元素非常简单，只需通过索引直接访问并赋值。

实现示例
#include <iostream>
using namespace std;

class SequenceList {
private:
    int *array;
    int capacity;
    int size;

public:
    SequenceList(int capacity) {
        this->capacity = capacity;
        size = 0;
        array = new int[capacity];
    }

    ~SequenceList() {
        delete[] array;
    }

    void set(int index, int value) {
        if (index < 0 || index >= size) {
            cout << "Index out of range" << endl;
            return;
        }
        array[index] = value;
    }

    void display() {
        for (int i = 0; i < size; ++i) {
            cout << array[i] << " ";
        }
        cout << endl;
    }
};

int main() {
    SequenceList list(10);
    list.insert(1, 0);
    list.insert(2, 1);
    list.set(1, 5);  // Change element at index 1 to 5
    list.display();

    return 0;
}

4.2 修改链表中某个位置的元素

在链表中，修改某个位置的元素需要遍历链表到达该位置，然后进行修改。

实现示例
#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* next;

    Node(int value) : data(value), next(nullptr) {}
};

class LinkedList {
private:
    Node* head;

public:
    LinkedList() : head(nullptr) {}

    ~LinkedList() {
        Node* current = head;
        Node* next;
        while (current != nullptr) {
            next = current->next;
            delete current;
            current = next;
        }
    }

    void set(int index, int value) {
        Node* current = head;
        for (int i = 0; i < index && current != nullptr; ++i) {
            current = current->next;
        }
        if (current != nullptr) {
            current->data = value;
        } else {
            cout << "Index out of range" << endl;
        }
    }

    void display() {
        Node* current = head;
        while (current != nullptr) {
            cout << current->data << " ";
            current = current->next;
        }
        cout << endl;
    }
};

int main() {
    LinkedList list;
    list.insert(1, 0);
    list.insert(2, 1);
    list.set(1, 5);  // Change element at index 1 to 5
    list.display();

    return 0;
}

四、线性表的优势与局限

1. 优势

1.1 简单易用

线性表的结构非常直观，尤其是顺序表（如数组）和链表，其概念易于理解和实现。

  • 顺序表: 使用连续的内存空间存储数据，数据存取简单，代码实现易于理解。
  • 链表: 使用节点链式连接，可以灵活管理内存，无需考虑数组的容量限制。

示例:

  • 顺序表：适用于对固定数量数据进行快速访问和操作的场景，如静态配置数据、日历数据等。
  • 链表：适用于动态数据管理，如动态队列、链式栈等。

1.2 适合存储和管理有序数据

线性表中的元素具有明确的顺序，适合用于存储和管理有序数据集。

  • 顺序性: 数据按照插入顺序存储，方便进行顺序遍历和操作。
  • 一致性: 数据类型一致，便于进行批量操作和处理。

应用场景:

  • 排序算法中的数据存储
  • 图形绘制中的点阵数据
  • 数据记录和日志管理

2. 局限

2.1 顺序表扩展性差

顺序表（数组）的大小通常是固定的，在插入新元素时可能需要重新分配内存空间，这会导致性能下降。

  • 内存管理: 扩展顺序表的容量时，需要重新分配更大的数组，并将原数据复制到新数组中。
  • 时间复杂度: 插入和删除操作可能导致大量数据移动，时间复杂度为 O(n)。

示例:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> vec;
    for (int i = 0; i < 100; ++i) {
        vec.push_back(i);  // 当容量不足时，vector 会自动扩展容量
    }
    cout << "Vector size: " << vec.size() << endl;
    return 0;
}

2.2 链表的随机访问效率低

链表不支持快速随机访问，需要从头节点开始顺序遍历到目标位置，访问效率较低。

  • 遍历性能: 由于链表的节点是链式存储，无法直接访问任意位置的节点，只能逐一遍历，时间复杂度为 O(n)。
  • 内存消耗: 链表的每个节点除了存储数据外，还需要存储指针信息，导致内存开销较大。

示例:

#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int value) : data(value), next(nullptr) {}
};

int main() {
    Node* head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(3);
    
    Node* current = head;
    int index = 0;
    int targetIndex = 2;
    while (current != nullptr && index < targetIndex) {
        current = current->next;
        index++;
    }
    if (current != nullptr) {
        cout << "Element at index " << targetIndex << ": " << current->data << endl;
    } else {
        cout << "Index out of range" << endl;
    }
    return 0;
}

五、线性表与其他数据结构的比较

线性表是基本的数据结构之一，在计算机科学中还有许多其他常用的数据结构，如栈、队列、树等。了解这些数据结构之间的差异和优缺点，可以帮助开发者在实际应用中选择最合适的结构。

1. 线性表 vs. 栈

线性表

  • 操作: 支持在任意位置进行插入、删除、查询和修改操作。
  • 访问: 可以随机访问任意位置的元素。
  • 实现: 顺序表（数组）和链表是线性表的常见实现。

栈

  • 操作: 仅支持在栈顶进行插入和删除操作，遵循后进先出（LIFO）的原则。
  • 访问: 只能访问栈顶的元素，不支持随机访问。
  • 实现: 通常使用数组或链表实现。

示例比较:

  • 线性表: 可以访问和操作任意位置的元素，如array[3] = 10。
  • 栈: 只能操作栈顶的元素，如stack.push(10)、stack.pop()。
// 栈的基本实现
#include <iostream>
#include <stack>
using namespace std;

int main() {
    stack<int> s;
    s.push(1);  // 压入栈顶
    s.push(2);
    cout << "Top element: " << s.top() << endl;  // 访问栈顶元素
    s.pop();  // 弹出栈顶元素
    cout << "Top element after pop: " << s.top() << endl;
    return 0;
}

2. 线性表 vs. 队列

线性表

  • 操作: 支持任意位置的插入、删除、查询和修改操作。
  • 访问: 可以随机访问任意位置的元素。

队列

  • 操作: 仅支持在队列两端进行操作：一端入队（enqueue），另一端出队（dequeue），遵循先进先出（FIFO）的原则。
  • 访问: 只能访问队头和队尾的元素，不支持随机访问。
  • 实现: 通常使用数组或链表实现。

示例比较:

  • 线性表: 可以对任意位置进行插入和删除，如list.insert(3, value)。
  • 队列: 只能进行队列头尾的操作，如queue.push(value)、queue.pop()。
// 队列的基本实现
#include <iostream>
#include <queue>
using namespace std;

int main() {
    queue<int> q;
    q.push(1);  // 入队
    q.push(2);
    cout << "Front element: " << q.front() << endl;  // 访问队头元素
    q.pop();  // 出队
    cout << "Front element after pop: " << q.front() << endl;
    return 0;
}

3. 线性表 vs. 树

线性表

  • 关系: 元素之间存在线性关系，只有前驱和后继元素。
  • 结构: 简单的线性结构，不支持分支或层次结构。

树

  • 关系: 支持层次和分支结构，节点之间有父子关系，可以有多个子节点。
  • 结构: 复杂的数据结构，常见的有二叉树、B树等，支持更复杂的数据关系。

示例比较:

  • 线性表: 用于存储简单的线性数据，如列表、队列。
  • 树: 用于表示层次化的数据，如组织结构、文件系统目录。
// 二叉树的基本节点定义
#include <iostream>
using namespace std;

struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int value) : data(value), left(nullptr), right(nullptr) {}
};

int main() {
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    cout << "Root node data: " << root->data << endl;
    cout << "Left child data: " << root->left->data << endl;
    cout << "Right child data: " << root->right->data << endl;
    return 0;
}
武帝为此
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构之线性表讲解，助力软件设计师考试
08-11
数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试...
数据结构之线性表.rar
04-07
在本资料“数据结构之线性表.rar”中，我们将探讨如何使用C++实现线性表，并涵盖增、删、改、查等基本操作。 1. **线性表的概念**： 线性表的每个元素都有一个唯一的序号，称为位置或者索引。元素之间存在一对一的...
数据结构之线性表
总结论文中的算法并给出论文的复现代码
02-09 4018
线性表是最基本且最常用的一种线性结构，同时也是其他数据结构的基础。本文首先介绍线性表的定义和特点，然后对线性表的主要操作用C语言程序进行实现，最后给出线性表的应用实例。
python数据结构之线性表
m0_71417856的博客
04-12 1349
python线性表的一些基本操作，包括顺序表和单链表
数据结构之线性表的应用——完整代码实现
weixin_64618739的博客
11-15 1412
数据结构之线性表的应用——完整代码实现
数据结构之线性表 Python实现
525小白菜的博客
07-12 2177
Python实现线性表
数据结构之线性表之线性表顺序存储结构
m0_74018560的博客
12-10 679
数据结构之线性表部分之线性表存储结构
数据结构之线性表教程3.zip
01-02
在这个“数据结构之线性表教程3.zip”压缩包中，很可能是对线性表的深入讲解和实践应用的资源集合。 线性表是一种一维数组结构，其中的元素按照特定顺序排列。每个元素都有一个唯一的索引，通常从0或1开始。线性表...
数据结构之线性表的实现.rar
07-27
在这个压缩包“数据结构之线性表的实现.rar”中，我们可以找到关于线性表实现的详细内容，特别是针对严蔚敏版数据结构的实现。 线性表的常见实现方式有两种：顺序表和链表。在顺序表中，元素在内存中是连续存储的，...
数据结构之线性表的定义 定义线性表节点的结构.pdf
04-18
数据结构之线性表的定义和结构 数据结构是计算机科学中的一门重要学科，它研究的是数据的存储、组织和操作，旨在提高数据处理的效率和性能。在数据结构中，线性表是最基本和最重要的一种数据结构形式。本文将详细...
数据结构之单向、双线链表
2301_78503818的博客
08-28 498
首先我们先定义链表节点的类型，以及里面包含的数据和存储下一个节点地址的指针，然后通过定义变量，使用malloc函数来申请一个头结点的空间，而后进行赋值操作即可完成对头结点的创建。链表大体可以分成有头链表（有头节点）和无头链表，今天主要记录一下单向链表和双线链表的一些基本操作。3.单向链表的遍历，寻找，删除，更改。6.链表的复杂操作（读者可酌情观看）链表空间的释放（链表的销毁）2.头插法插入链表节点。
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1231
数据结构-时间、空间复杂度-详解
浅谈【数据结构】树与二叉树之哈夫曼树
weixin_67526434的博客
08-26 633
浅谈【数据结构】树与二叉树之哈夫曼树
【Java & 数据结构】HashMap和HashSet介绍
qq_42150700的博客
08-29 506
Map 和 Set 是 Java 集合框架中的两个接口, 其分别对应着两种不同的搜索模型. 其中 一个是纯 key 模型, 另一个则是 key-value 模型.纯 key 模型就类似于一个集合, 里面装载着一些元素, 这些元素只包含其本身. 例如我有一个冰箱, 里面装着各式各样的饮料, 那么此时这个冰箱就可以看作是一个饮料的集合, 里面装载着饮料. 此时如果我要在里面找饮料, 找的就是饮料本身.
【数据结构】-----哈希
m0_73470633的博客
08-29 465
一文看懂哈希结构！
数据结构（邓俊辉）学习笔记】串 05——KMP算法：理解next[]表
weixin_44399845的博客
08-26 1031
KMP算法：理解next[]表
Redis八种数据结构简介
最新发布
m0_67496588的博客
08-29 599
Redis八种数据结构
【数据结构-二维前缀和】【含空间优化】力扣3070. 元素和小于等于 k 的子矩阵的数目
sjsjs11的博客
08-29 146
col_sum[j]在遍历行的时候，也会依次计算该列的元素和，要计算前缀和s，实际上就是目前该列的元素和逐列累加，当发现s大于k的时候，那么就停止该行接下来的前缀和，继续计算下一行第一列开始的前缀和，继续遍历行的某个位置的前缀和。这种方法就是传统的前缀和做法，在这道题中，如果group[i][j]小于k，则继续遍历，然后count增加，如果group[i][j]大于k，说明不需要继续遍历这一行接下来列的前缀和了，直接开始计算新一行每一列的前缀和。返回包含 grid 左上角元素、元素和小于或等于 k 的。
数据结构-线性表
zhoupenghui168的博客
08-29 583
好了,线性表相关数据结构就基本上差不多了, 从上面可知,线性表分为顺序表,链表(单向,双向),栈,队列等,他们存储的是单值情况,那么如果要存储多值情况,如:key-value情况,怎么办呢,这里就需要使用符号表了
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

武帝为此

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

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

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

打赏作者

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

抵扣说明：

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

余额充值