数据结构与算法：顺序表和链表

已于 2024-07-09 09:56:02 修改
阅读量933 收藏 10
点赞数 30
文章标签： 链表 数据结构
于 2024-07-09 09:29:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Crazy_Rabbits/article/details/140272542
版权

目录

一、线性表

二、顺序表

 三、链表

一、线性表

        线性表（ linear list ）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...

        线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

        其中数组（某种程度上可以认为是顺序表）在物理空间上是连续存储的，而链表是由不同的小块通过某些“记忆”顺次连接存储的，这些小块或连续，或不连续，但是在逻辑上都呈线性。

二、顺序表

         顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

顺序表一般又可以分为静态顺序表和动态数据表：

        静态数据表是用一段长度固定的物理空间来对数据进行存储，数组长度是固定的。堆开辟的数组在特殊情景下，使用比较多，尤其是动态顺序表。

// 静态顺序表：通过宏来替换定义一个数组
#define N 10
struct Arr
{
    public:
        int n;
        int arr[N];
};
// 动态顺序表：在数组长度不确定的时候，采用堆空间来创建顺序表
class Arr
{
    public:
        Arr(int _n):n(_n),arr(new int[n]){}
    protected:
        int n;
        int* arr;
};

        显然，通过宏替换或者是栈上直接开辟的数组对于长度是已经锁死了的，当数据足够庞大的时候，N为10不够，这时需要修改为比较大的值。如果是本来就给N定为比较大的数，在面对较少的数据时就会显得浪费空间。所以在实践中，我们更推荐使用的是动态数组。动态数组可以实现在数组长度达到最大时扩容继续添加数据的作用。
        下面是一串采用C++实现的顺序表的代码：

（1）SeqList.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cassert>
using namespace std;
class SeqList
{
public:
	//初始化
	SeqList();
	//销毁
	~SeqList();
	//头插
	void PushFront(int data);
	//头删
	void PopFront();
	//尾插
	void PushBack(int data);
	//尾删
	void PopBack();
	//打印
	void Print();
	//寻找
	int* Find(int data);
	//插入
	void Insert(int pos, int data);
	//清除
	void Erase(int data);
	//检查容量
	void Check();
private:
	int* ptr;
	int index;
	int capacity;
};

（2）SeqList.cpp

#include "SeqList.h"
SeqList::SeqList()
{
	ptr = nullptr;
	index = 0;
	capacity = 0;
}
SeqList::~SeqList()
{
	if (ptr!=nullptr)
	{
		delete[]ptr;
		ptr = nullptr;
		capacity = 0;
		index = 0;
		cout << "~SeqList Destroyed" << endl;
	}
}
void SeqList::PushFront(int data)
{
	Check();
	for (int i = index - 1; i >= 0; i--)
	{
		ptr[i + 1] = ptr[i];
	}
	ptr[0] = data;
	index++;
}
void SeqList::PopFront()
{
	for (int i = 1; i < index; i++)
	{
		ptr[i - 1] = ptr[i];
	}
	index--;
}
void SeqList::PushBack(int data)
{
	Check();
	assert(ptr);
	ptr[index++] = data;
}
void SeqList::PopBack()
{
	assert(index >= 0);
	index--;
}
void SeqList::Print()
{
	for (int i = 0; i < index; i++)
	{
		cout << ptr[i] << " ";
	}
	cout << endl;
}
int* SeqList::Find(int data)
{
	for (int i = 0; i < index; i++)
	{
		if (ptr[i] == data)
		{
			return ptr + i;
		}
	}
	return nullptr;
}
void SeqList::Insert(int pos, int data)
{
	assert(pos > 0);
	Check();
	for (int i = index - 1; i >= pos - 1; i--)
	{
		ptr[i + 1] = ptr[i];
	}
	ptr[pos-1] = data;
	index++;
}
void SeqList::Erase(int data)
{
	int flag = 1;
	for (int i = 0; i < index; i++)
	{
		if (ptr[i] == data)
		{
			for (int j = i; j <index; j++)
			{
				ptr[j] = ptr[j + 1];
			}
			index--;
			flag = 0;
		}
	}
	if (flag)
	{
		cout << "No Data" << endl;
	}
}
void SeqList::Check()
{
	if (ptr == nullptr || index == capacity)
	{
		int new_capcaity = (ptr == nullptr ? 4 : capacity * 2);
		if (capacity != new_capcaity && capacity != 0)
		{
			int* temp = new int[new_capcaity];
			for (int i = 0; i < index; i++)
			{
				temp[i] = ptr[i];
			}
			delete[] ptr;
			ptr = temp;
			assert(ptr);
			capacity = new_capcaity;
			return;
		}
		ptr = new int[new_capcaity];
		capacity = new_capcaity;
		assert(ptr);
	}
}

        值得注意的是，如果使用模板template不能将函数定义与声明分离放在两个文件中，否则会导致很多的麻烦。

        顺序表在实现上是比较简单的，但是在某些方面上效率是比较低的。比如在进行增加数据的操作时，如果数组已经满了，那么需要开辟新空间，并且将原先的数据挪到新空间，并释放旧空间；然后在进行扩容的操作时，一般是扩2倍，导致资源利用率会随着数据的减少而减少；在进行头插和中间位置的插入时，时间复杂度为O(N)。

 三、链表

        链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

1.单向不循环链表

// 不带哨兵位的单向链表
#include <iostream>
#include <cassert>
using namespace std;
template<class T>
struct Node
{
    Node<T> *next;
    T data;
    Node(T _data) : data(_data),next(nullptr){}
};
template<class T>
class SLTList
{
    protected:
    Node<T> *pHead;
    public:
    SLTList():pHead(nullptr){}
    void push_back(T data)
    {
        // 头为空就直接改变头指向
        if(!pHead)
            pHead = new Node<T>(data);
        // 头不为空就尾插
        else
        {
            Node<T> *tail = pHead;
            while(tail->next)
            {
                tail = tail->next;
            }
            tail->next = new Node<T>(data);
        }
    }
    void pop_back()
    {
        // 头为空就直接返回
        if(!pHead)
            return;
        // 只有一个头结点，就释放该节点的权限并置空
        if(!pHead->next)
        {
            delete pHead;
            pHead = nullptr;
            return;
        }
        Node<T> *fast = pHead;
        Node<T> *slow = pHead;
        while(fast->next)
        {
            slow = fast;
            fast = fast->next;
        }
        slow->next = nullptr;
        delete fast;
        fast = nullptr;
    }
    void push_front(T data)
    {
        // 头插 更改头指针的指向
        Node<T> *newNode = new Node<T>(data);
        newNode->next = pHead;
        pHead = newNode;
    }
    void pop_front()
    {
        // 如果头为空，就直接返回
        if(!pHead)
            return;
        // 只有一个头结点，那就删除头结点，并把pHead置为空
        if(!pHead->next)
        {
            delete pHead;
            pHead = nullptr;
            return;
        }
        // 头非空，就创建一个新头指针，释放旧头指针，最后改变指向
        Node<T> *newHead = pHead->next;
        delete pHead;
        pHead = newHead;
    }
    void print()
    {
        // 打印输出链表的元素
        Node<T> *tail = pHead;
        while(tail)
        {
            cout << tail->data << endl;
            tail = tail->next;
        }
    }
    Node<T>* find(T data)
    {
        Node<T> *tail = pHead;
        while(tail)
        {
            if(tail->data==data)
                return tail;
            tail = tail->next;
        }
        return nullptr;
    }
    void insert(Node<T>* pos,T data)
    {
        if(!pos&&pos!=pHead)
            return;
        if(pos==pHead)
        {
            push_front(data);
        }
        else
        {
            Node<T> *prePos = pHead;
            while(prePos->next!=pos)
            {
                prePos = prePos->next;
            }
            Node<T> *newNode = new Node<T>(data);
            prePos->next = newNode;
            newNode->next = pos;
        }
    }
    void erase(Node<T>* pos)
    {
        if(!pos)
            return;
        else
        {
            if(pos==pHead)
            {
                pop_front();
                return;
            }
            Node<T> *prePos = pHead;
            while(prePos->next!=pos)
            {
                prePos = prePos->next;
            }
            prePos->next = pos->next;
            delete pos;
        }
    }

};
// 带哨兵位的单向链表
#include <iostream>
#include <cassert>
using namespace std;
// 带有哨兵位的单向链表
template <class T>
struct Node
{
    T data;
    Node<T> *next;
    Node(T _data = 0) : data(_data), next(nullptr) {}
};
template <class T>
class SLTList
{
protected:
    Node<T> *pHead;

public:
    SLTList() : pHead(new Node<T>) {}
    ~SLTList()
    {
        Node<T> *tail = pHead;
        while (tail->next)
        {
            Node<T> *tmp = tail;
            tail = tail->next;
            delete tmp;
            tmp = nullptr;
        }
    }
    // 尾插
    void push_back(T _data)
    {
        assert(pHead);
        Node<T> *tail = pHead;
        while (tail->next != nullptr)
        {
            tail = tail->next;
        }
        tail->next = new Node<T>(_data);
    }
    // 尾删
    void pop_back()
    {

        Node<T> *fast = pHead;
        Node<T> *slow = pHead;
        while (fast->next != nullptr)
        {
            slow = fast;
            fast = fast->next;
        }
        // 不能删除哨兵位
        if (fast != pHead)
            delete fast;
        slow->next = nullptr;
    }
    // 头插
    void push_front(T _data)
    {
        if (pHead)
        {
            Node<T> *oldTail = pHead->next;
            pHead->next = new Node<T>(_data);
            pHead->next->next = oldTail;
        }
    }
    // 头删
    void pop_front()
    {
        if (pHead && pHead->next)
        {
            Node<T> *tmp = pHead->next;
            pHead->next = pHead->next->next;
            delete tmp;
        }
    }
    // 寻找_data的元素位置
    Node<T> *find(T _data)
    {
        assert(pHead);
        Node<T> *pos = pHead->next;
        while (pos)
        {
            if (pos->data == _data)
                return pos;
            pos = pos->next;
        }
        return nullptr;
    }
    // pos前面插入
    void insert(Node<T> *pos, T _data)
    {
        assert(pHead);
        Node<T> *prePos = pHead;
        while (prePos->next != pos)
        {
            prePos = prePos->next;
        }
        prePos->next = new Node<T>(_data);
        prePos->next->next = pos;
    }
    // 删除某个位置的元素
    void erase(Node<T> *pos)
    {
        assert(pHead);
        if (pos)
        {
            Node<T> *prePos = pHead;
            while (prePos->next != pos)
            {
                prePos = prePos->next;
            }
            prePos->next = pos->next;
            delete pos;
            pos = nullptr;
        }
    }
    void print()
    {
        assert(pHead);
        Node<T> *tail = pHead->next;
        while (tail)
        {
            cout << tail->data << endl;
            tail = tail->next;
        }
    }
};

2.带头双向循环链表

#include <iostream>
#include <cassert>
using namespace std;
struct ListNode
{
    ListNode *prev;
    ListNode *next;
    int data;
};
ListNode *ListCreate(int data)
{
    ListNode *newNode = new ListNode;
    if (newNode)
    {
        newNode->data = data;
        newNode->prev = nullptr;
        newNode->next = nullptr;
        return newNode;
    }
    return nullptr;
}
void ListPrint(ListNode *pHead)
{
    assert(pHead);
    ListNode *tmp = pHead->next;
    cout << "哨兵位<=>";
    while (tmp != nullptr && tmp != pHead)
    {
        cout << tmp->data << "<=>";
        tmp = tmp->next;
    }
    cout << endl;
}
void ListPushBack(ListNode *pHead, int data)
{
    assert(pHead);
    ListNode *tmp = ListCreate(data);
    if(pHead->next!=nullptr)
    {
        ListNode *tail = pHead->prev;
        tail->next = tmp;
        tmp->prev = tail;
        tmp->next = pHead;
        pHead->prev = tmp;
    }
    else
    {
        pHead->next = tmp;
        pHead->prev = tmp;
        tmp->next = pHead;
        tmp->prev = pHead;
    }
}
void ListPopBack(ListNode*pHead)
{
    assert(pHead);
    if(pHead->next==nullptr||pHead->next==pHead->prev&&pHead->next==pHead)
    {
        cout << "Doubly linked list is empty!" << endl;
        return;
    }
    ListNode* oldTail = pHead->prev;
    ListNode *newTail = oldTail->prev;
    newTail->next = pHead;
    pHead->prev = newTail;
    delete oldTail;
    oldTail = nullptr;
}
void ListPushFront(ListNode*pHead,int data)
{
    assert(pHead);
    if(pHead->next)
    {
        ListNode *newHead = ListCreate(data);
        ListNode *oldHead = pHead->next;
        newHead->next = oldHead;
        newHead->prev = pHead;
        oldHead->prev = newHead;
        pHead->next = newHead;
    }
    else
    {
        ListNode *newHead = ListCreate(data);
        pHead->next = newHead;
        pHead->prev = newHead;
        newHead->next = pHead;
        newHead->prev = pHead;
    }
}
void ListPopFront(ListNode*pHead)
{
    assert(pHead);
    if(pHead->next==nullptr||pHead->next==pHead->prev&&pHead->next==pHead)
    {
        cout << "Doubly linked list is empty!" << endl;
        return;
    }
    ListNode *oldHead = pHead->next;
    ListNode *newHead = oldHead->next;
    pHead->next=newHead;
    newHead->prev = pHead;
    delete oldHead;
    oldHead = nullptr;
}
ListNode* ListFind(ListNode* pHead, int x)
{
    assert(pHead);
    ListNode *tail = pHead->next;
    while(tail!=pHead)
    {
        if(tail->data==x)
        {
            return tail;
        }
        tail = tail->next;
    }
    return nullptr;
}
void ListInsert(ListNode* pos, int x)
{
    ListNode *newNode = ListCreate(x);
    ListNode *prevNode = pos->prev;
    prevNode->next = newNode;
    newNode->prev = prevNode;
    newNode->next = pos;
    pos->prev = newNode;
}
void ListErase(ListNode*pos)
{
    ListNode *prevNode = pos->prev;
    ListNode *nextNode = pos->next;
    prevNode->next = nextNode;
    nextNode->prev = prevNode;
    delete pos;
    pos = nullptr;
}

        对应STL里面的List： http://t.csdnimg.cn/xFva4 。

        单链表的实现相对容易一点，但是在实现尾插和尾删的效率上是比较低的。而双向带头循环链表虽然实现起来相对复杂，但是在使用上却展示出了许多的优势。

Crazy_Rabbits239
关注
  • 30
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法-顺序表（链表篇）
09-09
在IT领域，数据结构与算法是计算机科学的基础，它们直接影响到程序的效率和设计。本资源专注于"顺序表"中的"链表"部分，这是一组相关数据元素的集合，其内部组织方式不同于传统的数组。链表不依赖于内存中的连续空间...
数据结构和算法-2.顺序表与链表
08-10
这份笔记深入解析了计算机科学中两种最基本的数据结构——顺序表与链表的原理、实现以及实际应用。通过对比顺序表和链表的不同特点，你将了解到它们各自的优势与适用场景。例如，笔记详细阐述了顺序表的扩展机制、...
【数据结构-二位前缀和】【二分查找】【枚举优化】力扣1292. 元素和小于等于阈值的正方形的最大边长
sjsjs11的博客
09-04 888
这道题的精髓在于二分查找的使用，由于我们要找到最大的边长，那么我们是不是通常来想，需要遍历从1到矩阵较短边长度的正方形边长，然后把边长一个个去矩阵中寻找是否有合适的正方形。输入：mat = [[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2]], threshold = 1。输入：mat = [[1,1,3,2,4,3,2],[1,1,3,2,4,3,2],[1,1,3,2,4,3,2]], threshold = 4。
数据结构（五）----树（含堆）
weixin_73579966的博客
09-04 1048
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的.1.最上面的称为根结点，它没有前驱结点。2.除了根结点，其余结点被分成多个互不相交的集合，其中每个集合又是一棵子树，这些子树的根节点只有一个前驱，可以有0或多个后继3.树是递归定义的。一棵树：子树不能相交总的来说，二叉树的主要难点在于链式二叉树，而其中最重要的思想在于——递归，把大事化为一个重复递归的小事，而贯穿其中的方法是：画图。
数据结构(6.4_6)——拓扑排序
m0_65240792的博客
09-04 290
AOV网：用顶点表示活动的网。用DAG图(有向无环图)表示一个工程，顶点表示活动，有向边<Vi,Vj>表示活动Vi必须先于vj进行回顾：入度即为以顶点为终点的边的数目 代码思路：通过for循环将所有度为0结点的indgree[]下标压入栈中，并初始化print[]数组，使其所有元素为-1，方便记录，再将count指向第一个print数组元素，任何进行while判断，如果栈不为空，则将栈顶元素i弹出栈并进入print数组，count指向下一个数组元素，再通过for循环遍历图中i的所有邻结点，将其度-1，若
数据结构（1）数据结构基础（单向链表）
weixin_68239724的博客
09-03 655
数据结构是一组用来保存一种或多种特定关系的数据的集合。其主要目的是组织和存储数据，以便于高效的访问和修改。程序 = 数据结构 + 算法单向链表是一种线性数据结构，由一系列节点构成，每个节点包含数据部分和指向下一个节点的指针。它是一种灵活的存储方式，相比于数组，单向链表不需要连续的内存空间。
数据结构——单链表实现和注释浅解
最新发布
hedhjd的博客
09-07 199
【代码】数据结构——单链表实现和注释浅解。
考研系列-408真题数据结构篇(18-23)
Nelson_hehe的博客
09-04 177
此文章是本人在备考过程中408真题数据结构部分（2018年-2023年）的易错题及相应的知识点整理，后期复习也尝尝用到，对于知识提炼归纳理解起到了很大的作用，分享出来希望帮助到大家~
【高阶数据结构】B树、B+树、B*树
fight_p的博客
09-02 1184
内查找适合用于数据量相对不是很大，能够一次性存放在内存中，进行数据查找的场景。如果数据量很大，比如有100G数据，无法一次放进内存中，那就只能放在磁盘上了，如果放在磁盘上，有需要搜索某些数据，那么如何处理呢？那么我们可以考虑将存放关键字及其映射的数据的地址放到一个内存中的搜索树的节点中，找数据时比较关键字，找到关键字也就找到这个数据在磁盘的地址，然后去这个地址去磁盘访问数据。
数据结构--经典排序之选择排序（超详细！！）
2301_79381549的博客
09-04 596
它的工作原理是，首先在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。.如果在交换之前，max恰好是begin，那么由于begin位置的值已经被交换出去，我们需要更新max为min的位置。.接着，我们使用Swap函数将begin位置的值与最小值进行交换，这样确保了begin位置始终是已排序的最小值。.Swap 函数是一个简单的值交换函数，它接受两个整数的指针，并交换它们所指向的值。
数据结构串的模式匹配算法--BF暴力匹配
2305_78057683的博客
09-03 367
数据结构串的模式匹配算法--BF暴力匹配
数据结构07
m0_52024881的博客
09-04 370
条件1.vector或者List的长度小于当前的lever值的时候才将结点的值入vector或者List，这就保证了始终保留的是最右结点。不妨对照题干上的例子对照进行单步脑海运行一下。其中C++和java语言中都有一个重要的if筛选条件，还有一个条件是2.先遍历右孩子再遍历左孩子；
【数据结构】--时间和空间复杂度
2303_80341387的博客
09-03 519
两个标准来衡量：1. 时间复杂度 2. 空间复杂度。
数据结构可视化工具
晴山の博客
09-04 271
前期疑问：未完待续。
数据结构——单链表相关操作
xgshxjhs_的博客
09-03 495
定义链表节点和对象类型。
数据结构-复杂度
m0_73284013的博客
09-02 413
数据结构：在内存中管理数据，内存速度快，带电存储数据库：在磁盘中管理数据，磁盘速度慢，不带电存储。
【数据结构】Lambda表达式的应用
GGBond778的博客
09-04 1496
本期讲解了关于Lambda表达式的运用，关于它的语法，背景，基本使用，变量捕获，以及在集合当中的使用都有涉及，并且附加代码进行演示。
数据结构6—队列（附源码）
l1894的博客
09-05 292
只允许在一端插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO（First In First Out）进行插入操作的一端称为队尾进行删除操作的一端称为队头。
C++实现数据结构算法模板：顺序表、链表到图与排序
"该文档是关于数据结构各种算法的C++实现模板，涵盖了从基本的数据结构如顺序表、链表到复杂的数据结构如B+树、图以及各种排序算法的详细实现。每个数据结构都有相应的头文件（如Seqlist.h、ListNode.h等）和测试...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值