【C++习题集】-- 顺序表、链表

已于 2023-09-02 17:47:40 修改
阅读量333 收藏 1
点赞数
分类专栏： C++刷题集 文章标签： c++ 算法 开发语言
于 2023-09-02 17:47:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64609308/article/details/132391769
版权

（用于复习）

目录

线性表

顺序表

链表

单链表

单向 \ 双向

带哨兵位 \ 不带哨兵位

循环 \ 非循环

无头单向非循环链表实现

oj题

203. 移除链表元素

206. 反转链表

快慢指针

141.环形链表

【解题思路】

带头双向循环链表

顺序表和链表的区别

线性表

        常见的线性表：顺序表、链表、栈、队列、字符串...。

  • 逻辑上： 线性结构
  • 物理上： 不一定是连续

顺序表

#include <iostream>
#include <cassert>
#include <malloc.h>
#include <cstdlib>

namespace qcr_vector
{
    typedef int VectorType;

    struct Vector
    {
        VectorType* _array;  // 指向动态开辟的数组
        uint64_t _size;        // 有效数据个数
        uint64_t _capacity;    // 容量空间的大小
    };
    /*****************
     * 顺序表初始化
     *****************/
    void VectorInit(Vector* vector)
    {
        assert(vector);

        vector->_array = nullptr;
        vector->_capacity = vector->_size = 0;
    }

    /*****************
     * 检查空间，如果满了，进行增容
     *****************/
    void VectorCapacity(Vector* vector)
    {
        assert(vector);

        if(vector->_capacity == vector->_size)
        {
            uint64_t new_capacity = vector->_capacity == 0 ? 5 : vector->_capacity * 2;
            VectorType* tmp = (VectorType*)realloc(vector->_array, new_capacity * sizeof(VectorType));
            if(tmp == nullptr)
            {
                perror("VectorCapacity::realloc");
                exit(-1);
            }
            vector->_array = tmp;
            vector->_capacity = new_capacity;
        }
    }

    // 顺序表在pos位置插入element
    void VectorInsert(Vector *vector, uint64_t pos, VectorType element)
    {
        assert(vector);
        assert(pos < vector->_size);

        VectorCapacity(vector);
        for(int i = vector->_size; i > pos; i--)
        {
            vector->_array[i] = vector->_array[i - 1];
        }
        vector->_array[pos] = element;
        (vector->_size)++;
    }

    // 顺序表删除pos位置的值
    void VectorErase(Vector *vector, uint64_t pos)
    {
        assert(vector);
        assert(pos < vector->_size);

        for(int i = pos; i < vector->_size - 1; i--)
        {
            vector->_array[i] = vector->_array[i + 1];
        }
        (vector->_size)--;
    }

    // 顺序表尾插
    void VectorPushBack(Vector* vector, VectorType element)
    {
        VectorInsert(vector, vector->_size, element);
        // assert(vector);

        // VectorCapacity(vector);
        // vector->_array[vector->_size] = element;
        // (vector->_size)++;
    }

    // 顺序表尾删
    void VectorPopBack(Vector* vector)
    {
        VectorErase(vector, vector->_size - 1);
        // assert(vector);

        // (vector->_size)--;
    }

    // 顺序表头插
    void VectorPushFront(Vector* vector, VectorType element)
    {
        VectorInsert(vector, 0, element);
        // assert(vector);

        // VectorCapacity(vector);
        // for(int i = vector->_size; i > 0; i--)
        // {
        //     vector->_array[i] = vector->_array[i - 1];
        // }
        // vector->_array[0] = element;
        // (vector->_size)++;
    }

    // 顺序表头删
    void VectorPopFront(Vector* vector)
    {
        VectorErase(vector, 0);
        // assert(vector);

        // for(int i = 0; i < vector->_size - 1; i--)
        // {
        //     vector->_array[i] = vector->_array[i + 1];
        // }
        // (vector->_size)--;
    }

    // 顺序表查找
    int64_t VectorFind(Vector *vector, VectorType element)
    {
        assert(vector);

        for(int i = 0; i < vector->_size; i++)
        {
            if(vector->_array[i] == element)
            {
                return i;
            }
        }
        return -1;
    }

    // 顺序表销毁
    void VectorDestory(Vector *vector)
    {
        assert(vector);
        
        vector->_size = vector->_capacity = 0;
        if(vector->_array)
            free(vector->_array);
        vector->_array = nullptr;
    }

    // 顺序表打印
    void VectorPrint(Vector *vector)
    {
        assert(vector);

        for(uint64_t i = 0; i < vector->_size; i++)
        {
            std::cout << vector->_array[i] << " ";
        }
        std::cout << std::endl;
    }
};

链表

单链表

单向 \ 双向

带哨兵位 \ 不带哨兵位

循环 \ 非循环

最常用还是两种结构:

  • 无头单向非循环链表
  • 带头双向循环链表

  1. 无头单向非循环链表：一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。（笔试面试出现很多）
  2. 带头双向循环链表：一般用在单独存储数据。

无头单向非循环链表实现

#include <iostream>
#include <cassert>

namespace qcr_single_list
{
    typedef int SingleListType;

    struct SListNode
    {
        SingleListType _data;
        SListNode *_next;
    };

    /****************
     * 动态申请一个结点
     ****************/
    SListNode *BuySListNode(SingleListType data)
    {
        SListNode *single_list = (SListNode *)malloc(sizeof(SListNode));
        if (single_list == nullptr)
        {
            perror("BuySListNode::malloc");
            exit(-1);
        }
        single_list->_data = data;
        single_list->_next = nullptr;
        return single_list;
    }

    /****************
     * 单链表在pos位置之后插入data
     ****************/
    void SListInsertAfter(SListNode *pos, SingleListType data)
    {
        assert(pos);

        SListNode *single_list = BuySListNode(data);
        single_list->_next = pos->_next;
        pos->_next = single_list;
    }

    /****************
     * 单链表删除pos位置之后的值
     ****************/
    void SListEraseAfter(SListNode *pos)
    {
        assert(pos);
        assert(pos->_next);
        SListNode *erase = pos->_next;
        pos->_next = pos->_next->_next;
        free(erase);
    }

    /****************
     * 单链表头插
     ****************/
    void SListPushFront(SListNode **single_list, SingleListType data)
    {
        SListNode *new_SListNode = BuySListNode(data);
        new_SListNode->_next = (*single_list);
        *single_list = new_SListNode;
    }

    /****************
     * 单链表尾插
     ****************/
    void SListPushBack(SListNode **single_list, SingleListType data)
    {
        SListNode *new_SListNode = BuySListNode(data);
        if (*single_list) // 尾插
        {
            SListNode *cur = *single_list;
            while (cur->_next)
            {
                cur = cur->_next;
            }
            cur->_next = new_SListNode;
        }
        else // 头插
        {
            *single_list = new_SListNode;
        }
    }

    /****************
     * 单链表头删
     ****************/
    void SListPopFront(SListNode **single_list)
    {
        assert(*single_list);

        SListNode *erase = *single_list;
        *single_list = (*single_list)->_next;
        free(erase);
    }

    /****************
     * 单链表尾删
     ****************/
    void SListPopBack(SListNode **single_list)
    {
        assert(*single_list);

        if (nullptr == (*single_list)->_next)
        {
            free(*single_list);
            *single_list = nullptr;
        }
        else
        {
            SListNode* cur = *single_list;
            while (cur->_next->_next)
            {
                cur = cur->_next;
            }

            SListNode *erase = cur->_next;
            cur->_next = nullptr;
            free(erase);
        }
    }

    /****************
     * 单链表查找
     ****************/
    SListNode *SListFind(SListNode *single_list, SingleListType data)
    {
        assert(single_list);
        SListNode *cur = single_list;
        while (cur)
        {
            if (cur->_data == data)
                return cur;
            cur = cur->_next;
        }
        return nullptr;
    }

    /****************
     * 单链表打印
     ****************/
    void SListPrint(SListNode *single_list)
    {
        SListNode *cur = single_list;
        while (cur != nullptr)
        {
            printf("%d->", cur->_data);
            cur = cur->_next;
        }
        printf("nullptr\n");
    }

    /****************
     * 单链表销毁
     ****************/
    void SListDestory(SListNode** single_list)
    {
        assert(*single_list);
	    SListNode* cur = *single_list;
	    while (cur)
	    {
		    SListNode* next = cur->_next;
		    free(cur);
		    cur = _next;
	    }
	    *single_list = nullptr;
    }
}

oj题

203. 移除链表元素

203. 移除链表元素 - 力扣（LeetCode）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* cur = head;
        ListNode* prev = nullptr;
        while(cur)
        {
            if(cur->val == val)
            {
                if(prev == nullptr)
                {
                    head = head->next;
                    cur = head;
                }
                else
                {
                    prev->next = cur->next;
                    cur = cur->next;
                }
            }
            else
            {
                prev = cur;
                cur = cur->next;
            }
        }
        return head;
    }
};

206. 反转链表

206. 反转链表 - 力扣（LeetCode）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head)
    {
        ListNode* ret = nullptr;
        ListNode* cur = head;
        while(cur)
        {
            ListNode* next = cur->next;

            cur->next = ret;
            ret = cur;

            cur = next;
        }
        return ret;
    }
};

链表中倒数第k个结点_牛客题霸_牛客网 (nowcoder.com)
 

        双指针实现。

易错：
        两个临界需要全部关注到。

  • 1,{1,2,3,4,5}
  • 5,{1,2,3,4,5}
/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
#include <asm-generic/errno.h>
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
		ListNode* cur = pListHead;
		while(k--)
		{
			if(cur)
				cur = cur->next;
			else
			 	return nullptr;
		}

		ListNode* prev = pListHead;

		while(cur)
		{
			cur = cur->next;
			prev = prev->next;
		}
		return prev;
    }
};

(链表OJ题一定要确定边界，防止使用nullptr指针)

快慢指针

141.环形链表

141. 环形链表 - 力扣（LeetCode）

【解题思路】
        让一个指针从链表起始位置开始遍历链表，同时让一个指针从判环时相遇点的位置开始绕环
运行，两个指针都是每次均走一步，最终肯定会在入口点的位置相遇。

带头双向循环链表

#include <iostream>
#include <malloc.h>
#include <cassert>

namespace qcr_list
{
    typedef int ListDataList;
    struct ListNode
    {
        ListDataList _data;
        ListNode* _next;
        ListNode* _prev;
    };

    // 带头+双向+循环链表增删查改实现
    ListNode* Init()
    {
        ListNode* head_node = (ListNode*)malloc(sizeof(ListNode));
        head_node->_prev = head_node;
        head_node->_next = head_node;
        return head_node;
    } 

    // 创建新结点
    ListNode* ListCreate(ListDataList data)
    {
        ListNode* new_node = (ListNode*)malloc(sizeof(ListNode));
        if(nullptr == new_node)
            perror("ListCreate::malloc");
        new_node->_data = data;
        new_node->_prev = new_node->_next = nullptr;
        return new_node;
    }

    // 双向链表尾插
    void ListPushBack(ListNode* pHead, ListDataList data)
    {
        assert(pHead);

        ListNode* tail = pHead->_prev;
        ListNode* new_node = ListCreate(data);
        tail->_next = new_node;
        new_node->_next = pHead;

        new_node->_prev = tail;
        pHead->_prev = new_node;
    }   

    // 双向链表头插
    void ListPushFront(ListNode* pHead, ListDataList data)
    {
        assert(pHead);

        ListNode* next = pHead->_next;
        ListNode* new_node = ListCreate(data);
        pHead->_next = new_node;
        new_node->_next = next;

        new_node->_prev = pHead;
        next->_prev = new_node;
    }

    // 双向链表尾删
    void ListPopBack(ListNode* pHead)
    {
        assert(pHead);

        if(pHead->_next == pHead)
            return;

        ListNode* erase = pHead->_prev;
        erase->_prev->_next = pHead;
        pHead->_prev = erase->_prev;

        erase->_next = erase->_prev = nullptr;
        free(erase);
        erase = nullptr;
    }

    // 双向链表头删
    void ListPopFront(ListNode* pHead)
    {
        assert(pHead);

        if(pHead->_next == pHead)
            return;

        ListNode* erase = pHead->_next;
        erase->_next->_prev = pHead;
        pHead->_next = erase->_next;

        erase->_next = erase->_prev = nullptr;
        free(erase);
        erase = nullptr;
    }

    // 双向链表插入
    void ListInsert(ListNode* pos, ListDataList data)
    {
        assert(pos);

        ListNode* new_node = ListCreate(data);
        ListNode* prev = pos->_prev;
        prev->_next = new_node;
        new_node->_next = pos;

        new_node->_prev = prev;
        pos->_prev = new_node;
    }

    // 双向链表删除
    void ListErase(ListNode* pos)
    {
        assert(pos);
        ListNode* prev = pos->_prev;
        ListNode* next = pos->_next;

        pos->_next = pos->_prev = nullptr;
        free(pos);
        pos = nullptr;

        prev->_next = next;
        next->_prev = prev;
    }

    // 双向链表打印
    void ListPrint(ListNode* pHead)
    {
        assert(pHead);

        ListNode* cur = pHead->_next;
        while(pHead != cur)
        {
            std::cout << cur->_data << "->";
            cur = cur->_next;
        }
        std::cout << "nullptr" << std::endl;
    }

    // 双向链表查找
    ListNode* ListFind(ListNode* pHead, ListDataList data)
    {
        assert(pHead);
        
        ListNode* cur = pHead->_next;
        while(pHead != cur)
        {
            if(data == cur->_data)
            {
                return cur;
            }
            cur = cur->_next;
        }
        return nullptr;
    }


    // 双向链表销毁
    void ListPrint(ListNode* pHead)
    {
        assert(pHead);
        
        ListNode* cur = pHead;
        while(nullptr != cur)
        {
            if(cur == pHead)
            {
                cur->_prev->_next = nullptr;
            }
            ListNode* next = cur->_next;
            cur->_next = cur->_prev = nullptr;
            free(cur);
            cur = next;
        }
    }
}

顺序表和链表的区别

顺序表和链表的区别
不同点
顺序表
链表
存储空间上
物理上一定连续
逻辑上连续，但物理上不一定连续
随机访问
支持O(1)
不支持：O(N)
任意位置插入 \ 删除元素
可能需要搬移元素，效率低O(N)
只需修改指针指向
插入
动态顺序表，空间不够时需要扩容
没有容量的概念
应用场景
元素高效存储+频繁访问
任意位置插入和删除频繁
缓存利用率
高
低
川入
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言习题集以及答案（完整版）
12-21
C语言习题集以及答案（完整版） 本资源摘要信息提供了一个完整的C语言习题集，涵盖了C语言的基本概念、数据类型、运算符、控制结构、函数、数组、指针、结构体和文件操作等方面的知识点。该资源适合C语言的初学者和...
IOI国家集训队论文集1999-2019
09-20
+ [块状链表](#块状链表) + [动态树](#动态树) + [左偏树](#左偏树) + [跳表](#跳表) + [SBT](#sbt) + [线段树](#线段树) + [单调队列](#单调队列) + [哈希表](#哈希表) + [Splay](#splay) * [图论](#图论...
链表和顺序表习题（一）
centor的博客
06-15 1925
1.比较顺序表和链表的优缺点，说说它们分别在什么场景下使用？ 链表 顺序表 每个元素的访问 每个节点都需要通过指针找到内存然后加载到缓存中 内存访问时，不需要多次从内存到缓存的步骤 头插，头删，中间位置 直接增加或删除节点 在插入或删除之前要先对之后的数据进行挪动 尾插，尾删 需要对空间进行操作 直接对数据进行操作，空间是之前一次性开辟好的 空间操
顺序表和链表面试题（练习题）
baotu的博客
10-22 506
解析：链表的插入和删除不是所有情况下都比顺序表快，比如尾插尾删，顺序表的时间复杂度为O（1），并且如果是单链表，如果要在中间某个节点的前面插入/删除一个节点，则需要遍历。B错误：链表中的元素在内存中不一定连续，因为new的时候，会从堆上分配空间，具体分配出来的空间是否每次都连续，这个不一定。A正确：链表中节点之间是通过next引用相互指向的，故插入或者删除元素时只需要修改几个引用的指向即可，不需要搬移元素。C错误：链表的空间不连续，插入时也不需要扩容之类的，因此不需要事先预估存储空间大小。
＜顺序表—链表＞题目练习《数据结构(C语言版)》
m0_57859086的博客
06-03 849
＜顺序表—链表＞题目练习《数据结构(C语言版)》 ——By 作者：新晓·故知
链表面试题（1）----顺序表和链表的区别及其优缺点
baidu_39630193的博客
08-01 1万+
1.顺序表存储（典型的数组）      原理：顺序表存储是将数据元素放到一块连续的内存存储空间，相邻数据元素的存放地址也相邻（逻辑与物理统一）。      优点：（1）空间利用率高。（局部性原理，连续存放，命中率高）             （2）存取速度高效，通过下标来直接存储。      缺点：（1）插入和删除比较慢，比如：插入或者删除一个元素时，整个表需要遍历移动元素来重新排一次顺序
【C++习题集】-- 堆
weixin_64609308的博客
08-20 539
用于复习堆 - 模拟实现
【数据结构与算法-链表经典例题汇总】
是小武呀
03-01 1633
【数据结构与算法-链表经典例题汇总】典例1、链表逆序-a（easy）典例1、链表逆序-b（medium）典例2、求两个链表的交点-（easy）典例3、链表求环 - （medium）典例4、链表划分- (medium)典例5、复杂链表的深度拷贝 - (hard)典例6、排序链表的合并a-两个（easy）典例6、排序链表的合并b-多个（hard） 典例1、链表逆序-a（easy） 题目描述： 思路：依次遍历链表的节点，每遍历一个节点就逆置一个节点 。 LeetCode提交OJ测试链接: OJ
c语言习题集-----收藏归纳版
热门推荐
北慕辰的博客，欢迎各位大佬光临！！
04-25 1万+
C语言习题集收藏归纳 第一单元 程序设计和Ｃ语言 一、选择题 1．C语言的基本构成单位是： 。 A. 函数 B. 函数和过程 C. 超文本过程 D. 子程序 2．一个C语言程序总是从 开始执行。 A. 主过程 B. 主函数 C. 子程序 D.主程序 3．C语言的程序一行写不下时，可以 。 A. 用逗号换行 B. 用分号换行 C. 在任意一空格处换行 D. 用回车符换行 4．以下叙述不正确的是： 。 A. 在C程序中，语句之间必.
PTA题目：顺序表基本操作
Tajang的大千世界
10-18 4123
实现顺序表的基本操作，如初始化、插入、删除、输出等。 注意：顺序表中可有重复元素值。 要求：写出三个基本操作函数ListInsert，ListDelete，ListDeleteElem。 顺序表结构与操作函数接口定义： typedef char ElemType; typedef struct //定义顺序表结构 { ElemType data[MaxSize]; int length; } SqList; void InitList(SqList *&L); //初始化线性表 voi
【C++刷题】习题集
Shun_Hua的博客
08-19 323
经典习题。
数据结构c++版课后习题集解析.doc
09-28
- **本章导学**: 线性表是最基础的数据结构，包括顺序表和链表。讲解线性表的操作，如插入、删除、查找及其时间复杂度分析。 - **习题解析**: 习题可能涉及创建和操作线性表的C++代码实现，以及对线性表特性的理解...
数据结构算法与应用-C++语言描述
06-19
11.4.1 索引顺序访问方法 344 11.4.2 m 叉搜索树 345 11.4.3 m 序B－树 346 11.4.4 B－树的高度 347 11.4.5 B－树的搜索 348 11.4.6 B－树的插入 348 11.4.7 B－树的删除 350 11.4.8 节点结构 353 11.5 应用 354 ...
数据结构习题集答案（C语言版严蔚敏）1
08-04
本习题集主要围绕严蔚敏教授的《数据结构》一书，使用C语言进行阐述。以下是对相关知识点的详细解释： 1. 数据：数据是客观事物的符号表示，是计算机程序处理的基本单元，可以是数字、文字、图像等各种形式。 2. ...
C++回溯算法(2)
最新发布
BanyeBirth的博客
06-19 82
【代码】C++回溯算法(2)
【C++】list 容器的增删改查---模拟实现（图例超详细解析！！！）
weixin_45031801的博客
06-12 1370
STL 中的 list 是一个带头双向循环链表，作为链表的终极形态，各项操作性能都很优秀，尤其是 list 中迭代器的设计更是让人拍案叫绝，如此优秀的容器究竟是如何实现的呢？本文将会带大家一起从0~1 去模拟实现STL库中的 list 容器，以便于让大家更好的巩固之前学习过的 缺省参数、封装、类的6大默认函数等。
4 最简单的 C 程序设计—顺序程序设计-4.6 顺序结构程序设计举例
qq_43071699的博客
06-12 160
【代码】4 最简单的 C 程序设计—顺序程序设计-4.6 顺序结构程序设计举例。
C++|哈希结构封装unordered_set和unordered_map
weixin_68201503的博客
06-11 874
上一篇章，学习了unordered系列容器的使用，以及哈希结构，那么这一篇章将通过哈希结构来封装unordered系列容器，来进一步的学习他们的使用以及理解为何是如此使用。其实，哈希表的封装方式和红黑树的封装方式形式上是差不多的，如果有了红黑树的封装理解经验，我相信在理解哈希封装的过程会减少负担的。当然，在使用哈希结构中采用的是更具代表的哈希桶，接下来进行封装。
算法2.1-算法2.12顺序表和链表模拟
10-02
在引用中，第6章到第9章介绍了序列和集合的算法、图算法、几何算法、代数和数值算法。...关于算法2.1-算法2.12的顺序表和链表模拟的详细内容，我无法提供具体信息，因为引用的内容并没有涉及到这方面的内容。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

川入

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

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

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

打赏作者

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

抵扣说明：

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

余额充值