线性表的C++实现

最新推荐文章于 2022-11-10 20:31:54 发布
最新推荐文章于 2022-11-10 20:31:54 发布
阅读量799 收藏 10
点赞数 1
分类专栏： 数据结构 文章标签： 链表 线性表 C++实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43207320/article/details/88910967
版权

一、实现基础

  • 代码基于C++的模板类实现，这样就能够自由选择链表的数据类型。
  • 使用指针实现有头结点的单链表。
  • 在链表类Node中只定义了数据结构和功能函数，head头结点在主函数中定义并作为函数参数，这一点较常用的链表实现有所区别。

二、实现功能

  • 创建链表
  • 返回链表长度
  • 在链表尾部添加元素
  • 插入元素
  • 删除结点并返回该结点的值
  • 清空链表
  • 按链表值从尾到头的顺序打印链表（附加功能）

三、各功能详解

1、链表类 class Node
template <class T>
class Node
{
    public:
        T val;
        Node *next;

        Node(T x):val(x), next(NULL) {}                	  // 构造函数
        void SetList(Node** head );                       // 创建链表
        int length(Node* head);                           // 返回链表长度
        void append(T element, Node* head);               // 在链表尾部添加元素
        void insert(int pos, T element, Node* head);      // 插入元素
        T remove(int pos, Node* head, T errorFlag);       // 删除结点并返回该结点的值
        void clear(Node** head);                          // 清空链表
        vector<int> printListFromTailToHead(Node* head);  // 按链表值从尾到头的顺序打印

};
  • 链表的结点值val为模板T类型的，这样自己在创建链表时，就可以指定结点值为int/char等各种类型，比较灵活。
2、创建链表
template <class T>
void Node<T>::SetList(Node** head){
    Node <int> *cur, *temp;
    *head = cur = temp = NULL;
    
    for(int i = 0; i < Length; i++)
    {
        int t;
        cin >> t;

        temp = new Node<int>(0);
        temp->val = t;
        temp->next = NULL;

        if(*head == NULL)
            *head = temp;
        else
            cur->next = temp;

        cur = temp;
    }
}

  • 为什么传参是Node**类型？

    head在主函数中的定义是 Node *head，如果传参为*head，会出现在SetList()中head指向的地址有变，但是在主函数中head指向的地址没有变的情况。由于在主函数中初始化时head = NULL，所以，如果传参为*head，那么在SetList()中确实head指向了下一个结点的地址，但是主函数中head指向的地址仍然为空，也就是没有创建链表。

    这是因为，函数参数传递的只能是数值，所以当指针作为函数参数传递时，传递的是指针的值，而不是地址，所以在函数中不能改变实际的指针指向的地址，解决该问题，将指针指向的地址作为参数传给函数即可，也就是传参为Node**。

3、返回链表长度
template <class T>
int Node<T>::length(Node* head){
	Node<int> *cur = head; 
    int len = 0;

    if(head == NULL)
        return -1;

    while(cur){
        len++;
        cur = cur->next;
    }

    return len;
}
4、在链表尾部添加元素
template <class T>
void Node<T>::append(T element, Node* head){

    Node *temp, *cur = head;

    temp = new Node<T>(0);
    temp->val = element;
    temp->next = NULL;

    while(cur->next)
        cur = cur->next;
    cur->next = temp;
}
  • 当找到链表的最后一个元素tail时（tail->next == NULL），将原本tail指向为空替换为指向新增加的结点temp，再将temp->next赋值为NULL，即temp成为了新的tail。
5、插入元素
template <class T>
void Node<T>::insert(int pos, T element, Node* head){
    Node *temp, *cur;

    cur = new Node<T>(0);
    temp = new Node<T>(0);

    if((pos >= head->length(head)) || (pos <= 0)){
        cout << "Invalid operate!" << endl;
        return ;
    }
    else{
        for(int i = 0; i < pos; i++){
            cur = head;
            head = head->next;
        }
        temp->val = element;
        cur->next = temp;
        temp->next = head;
    }
}
  • 插入元素和在链表尾部添加元素的原理是一样的，只不过多了temp->next指向下一个结点的步骤。
  • 要注意判断插入元素的位置是否为合法位置。
  • 这里没有讨论插入到最开始的情况，原理其实一样的，只不过要改变head指向的地址。对于一般的线性表，head是作为类成员定义的，实现起来与插入操作大同小异，而本代码要实现插入到最开始的情况，将head以Node** head的形式传参即可。
6、删除结点并返回该结点的值
/* 返回被删除结点的val值 */
template <class T>
T Node<T>::remove(int pos, Node* head, T errorFlag){
    Node<T> *temp, *cur = head;
    temp = new Node<T>(0);

    if((pos <= 0) || (pos >= head->length(head))){
        cout << "pos error!" << endl;
        return errorFlag;
    }
    
    for(int i = 1; i < pos; i++){
        cur = cur->next;
    }
    temp = cur->next;
    cur->next = cur->next->next;
    return temp->val;
}
  • 要注意判断删除的位置是否合法。
  • 函数参数中有一个T errorFlag，这是因为函数的返回值类型为T类型的结点值，所以当位置不合法时，也必须返回一个T类型的值。比如T为int时，errorFlag = -1；T为char时，errorFlag = 'F'。
7、清空链表
template <class T>
void Node<T>::clear(Node** head){

    Node *temp;
    temp = *head;

    while(*head){
        temp = *head;
        *head = (*head)->next;
        delete temp;
        temp = NULL;
    }
    delete *head;
    *head = NULL;
}
  • 这里之所以传参为Node** head与前面一样。
  • 有一个比较细微的知识点：如果只是delete指针，而不把指针指向NULL，那么该指针会成为野指针，指向内存中的任意空间，所以最好在delete之后把指针指向NULL。
8、按链表值从尾到头的顺序打印链表
template <class T>
vector<int> Node<T>::printListFromTailToHead(Node* head) {
    vector<int> ArrayList;
    Node *temp = head;
	
    ArrayList.clear();

    while(temp != NULL){
        ArrayList.insert(ArrayList.begin(),temp->val);
        temp = temp->next;
    }

    return ArrayList;
}
  • 原理很简单，用到了vector。

四、完整代码

#include <iostream>
#include <cstdio>
#include <vector>

using namespace std;

#define Length 10 /* 链表长度 */

template <class T>
class Node
{
    public:
        T val;
        Node *next;

        Node(T x):val(x), next(NULL) {}                	  // 构造函数
        void SetList(Node** head );                       // 创建链表
        int length(Node* head);                           // 返回链表长度
        void append(T element, Node* head);               // 在链表尾部添加元素
        void insert(int pos, T element, Node* head);      // 插入元素
        T remove(int pos, Node* head, T errorFlag);       // 删除元素
        void clear(Node** head);                          // 清空链表
        vector<int> printListFromTailToHead(Node* head);  // 按链表值从尾到头的顺序打印

};

template <class T>
void Node<T>::SetList(Node** head){
    Node <int> *cur, *temp;
    *head = cur = temp = NULL;

    for(int i = 0; i < Length; i++)
    {
        int t;
        cin >> t;

        temp = new Node<int>(0);
        temp->val = t;
        temp->next = NULL;

        if(*head == NULL)
            *head = temp;
        else
            cur->next = temp;

        cur = temp;
    }
}

template <class T>
int Node<T>::length(Node* head){
	Node<int> *cur = head; 
    int len = 0;

    if(head == NULL)
        return -1;

    while(cur){
        len++;
        cur = cur->next;
    }

    return len;
}

template <class T>
void Node<T>::append(T element, Node* head){
    Node *temp, *cur = head;

    temp = new Node<T>(0);
    temp->val = element;
    temp->next = NULL;

    while(cur->next)
        cur = cur->next;
    cur->next = temp;
}

template <class T>
void Node<T>::insert(int pos, T element, Node* head){
    Node *temp, *cur;

    cur = new Node<T>(0);
    temp = new Node<T>(0);

    if((pos >= head->length(head)) || (pos <= 0)){
        cout << "Invalid operate!" << endl;
        return ;
    }
    else{
        for(int i = 0; i < pos; i++){
            cur = head;
            head = head->next;
        }
        temp->val = element;
        cur->next = temp;
        temp->next = head;
    }
}

/* 返回被删除结点的val值 */
template <class T>
T Node<T>::remove(int pos, Node* head, T errorFlag){
    Node<T> *temp, *cur = head;
    temp = new Node<T>(0);

    if((pos <= 0) || (pos >= head->length(head))){
        cout << "pos error!" << endl;
        return errorFlag;
    }

    for(int i = 1; i < pos; i++){
        cur = cur->next;
    }
    temp = cur->next;
    cur->next = cur->next->next;
    return temp->val;
}

template <class T>
void Node<T>::clear(Node** head){
    Node *temp;
    temp = *head;

    while(*head){
        temp = *head;
        *head = (*head)->next;
        delete temp;
        temp = NULL;
    }
    delete *head;
    *head = NULL;
}

template <class T>
vector<int> Node<T>::printListFromTailToHead(Node* head) {
    vector<int> ArrayList;
    Node *temp = head;
	
    ArrayList.clear();

    while(temp != NULL){
        ArrayList.insert(ArrayList.begin(),temp->val);
        temp = temp->next;
    }

    return ArrayList;
}

int main(int argc, char *argv[])
{
    Node <int> *head, *cur, *temp;
    head = cur = temp = NULL;

    /* 创建链表 */
    head->SetList(&head);
    /* DEBUG START 测试链表是否创建成功 */
    printf("\nSet a list:\n");
    temp = head;
    while(temp != NULL)
    {
        cout << temp->val << " ";
        temp = temp->next;
    }
    printf("\nlength of the list is : %d\n",head->length(head));
    /* DEBUG END */


    /* 在链表尾部插入元素 */
    printf("\nAppend the element 11 in the tail of the list:\n");
    head->append(11,head);
    /* DEBUG START */
    temp = head;
    while(temp != NULL)
    {
        cout << temp->val << " ";
        temp = temp->next;
    }
    printf("\nlength of the list is : %d\n",head->length(head));
    /* DEBUG END */

    /* 插入元素到不合法位置--大于链表长度 */
    printf("\nInsert the element 21 in the position out of the list(position 11):\n");
    head->insert(head->length(head),21,head);
    /* DEBUG START */
    temp = head;
    while(temp != NULL)
    {
        cout << temp->val << " ";
        temp = temp->next;
    }
    printf("\nlength of the list is : %d\n",head->length(head));
    /* DEBUG END */


    /* 插入元素到合法位置 */
    printf("\nInsert the element 21 in a right position(position 7):\n");
    head->insert(7,21,head);
    /* DEBUG START */
    temp = head;
    while(temp != NULL)
    {
        cout << temp->val << " ";
        temp = temp->next;
    }
    printf("\nlength of the list is : %d\n",head->length(head));
    /* DEBUG END */


    /* 插入元素到不合法位置--链表头部 */
    printf("\nInsert the element 21 in position 0: \n");
    head->insert(0,21,head);
    /* DEBUG START */
    temp = head;
    while(temp != NULL)
    {
        cout << temp->val << " ";
        temp = temp->next;
    }
    printf("\nlength of the list is : %d\n",head->length(head));
    /* DEBUG END */


    /* 删除元素 */
    printf("\ndelete the element in position length/2: \n");
    int delete_value = head->remove((head->length(head))/2,head,-1);
    /* DEBUG START */
    printf("The value of the delete Node is : %d\n",delete_value);
    temp = head;
    while(temp != NULL)
    {
        cout << temp->val << " ";
        temp = temp->next;
    }
    printf("\nlength of the list is : %d\n",head->length(head));
    /* DEBUG END */


    /* 按链表值从尾到头的顺序打印 */
    vector<int> vec;
    printf("\nprint List From Tail To Head: \n");
    vec = head->printListFromTailToHead(head);
    /* DEBUG START */
    for (int i = 0; i < vec.size(); i++) {
        cout << vec[i] << " ";
    }
    /* DEBUG END */


    /* 清空链表 */
    printf("\n\nClear the list:\n");
    head->clear(&head);
    cout << "head = " << head <<endl;
    printf("length of the list is : %d\n",head->length(head));


    return 0;
}
/*
样例 
1 2 3 4 5 6 7 8 9 10 
*/
  • 在主函数中写了各个函数的测试代码，代码最后面给出了测试样例，编译运行程序，直接输入样例就可以查看结果。
  • 前面提到的野指针可以通过删除clear()函数中的指针指向NULL，然后输出指针地址，来查看实际现象。
  • 同样的指针的传参是值传参也可以通过将SetList()函数或者clear()函数中的Node** head参数改为Node* head并在定义函数和主函数中分别输出指针地址来查看实际现象。
C137_98
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++实现线性表完整代码
11-07
c++实现线性表完整代码，内涵注释，可视化操作线性表。
c++实现线性表
05-21
线性表的实现代码 #include<iostream> using namespace std; template <class Telem> class List { public: virtual void clear()=0;//清空 virtual int leng()=0;//求线性表的长度 virtual Telem gete(int loc,Telem &el;)=0;//返回第i个元素的值 virtual int loct(Telem& el)=0;//查找，若找到返回元素的值，否则返回0 virtual bool insert(int loc,Telem& el)=0;//将el插入在loc的位置上 virtual Telem dele(int loc)=0;//删除loc位置的值 virtual bool full()=0;//判断线性表是否为满 virtual bool empt()=0;//判断线性表是否为空 virtual void print_SqList()=0;//显示表中的元素 virtual void inver()=0;//表的逆置 virtual void sort()=0;//表的排序 virtual ~List(){};//释放动态空间 };
线性表(C++实现)
努力学习UE5ing。。。为了自己梦中的游戏而努力中
11-07 2657
具有相同数据类型的n个数据元素的有限序列，n是表长，当n为0的时候线性表是一个空表。如果用L命名线性表，那么其一般表示为L=(a1，a2，...，ai，ai+1，...，an)L=(a1​，a2​，...，ai​，ai+1​，...，an)式中，a1a_1a1​是唯一的"第一个"数据元素，称为表头元素，而ana_nan​是唯一的"最后一个元素"，称为表尾元素。
线性表(C++)
lovecontry
09-07 147
复习一下线性表的简单操作，以数组为存储结构 文件"sqlist.h" #include &lt;istream&gt; using namespace std; const int LIST_INIT_SPACE=50; //存储空间初始分配量 const int LIST_INC_SPACE=10; //分配增量 template &lt;class T&gt; class Sq_lis...
C++ 线性表实现
weixin_30478619的博客
05-18 244
List.h #pragma once #include "targetver.h" #include <stdio.h> #include <tchar.h> #define LIST_INIT_SIZE 100 #define MAXSIZE 100 typedef int ElemType; typedef struct S...
C++通过类实现线性表
08-19
主要为大家详细介绍了C++通过类实现线性表，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C++实现动态线性表
08-19
主要为大家详细介绍了C++实现动态线性表，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C++ 链式线性表 类方式实现
07-29
C++ 链式线性表，以类的方式实现
c++ 数据结构线性表代码实现
10-17
c++ 线性表代码实现（个人学习代码），上传仅做备份
【C++】c++实现线性表、链表
SuLiJuan66的专栏
10-02 1659
C++
用C++语言实现线性表
qq_45234177的博客
04-20 1543
1.用数组实现 #include<iostream> #include "utility.h" using namespace std; const int max_list = 5000; template <class List_entry> //模板 class List { public: List(); //构造函数 int size() co...
数据结构之线性表实现（C++）
wqingwu的专栏
05-31 828
#include "stdafx.h" using namespace std; #include "iostream" #include "stdlib.h" #include "stdio.h" #define maxSize 10 #pragma region 定义顺序表 typedef struct { int data[maxSize]; int length; }S...
C++ 实现线性表算法
m0_56644364的博客
05-12 858
C++ 实现线性表算法
C++实现线性表
twg123456的专栏
10-22 1119
-------------------------SqList.h------------------------------------/*构造线性表*/#include#ifndef SqList_H_#define SqList_H_//定义头文件#define initSize 100//初始化大小#define increment 10//增长步长typedef int ElemType
C++ 线性表（Array）实现
qq_53745697的博客
11-21 748
C++线性表的实现
C/C++线性表的实现
m0_54202580的博客
09-26 8476
新手出路，多多请教！！ 线性表的定义： 线性表（linear list）是最基本、最简单、最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的，但这只适用大部分线性表，而不是全部。在数据结构逻辑层次上细分，线性表可分为一般线性表和受限线性表。 线性表的功能以下： ======1.输入数据====== ======2.输出数据====== ======3.插入数据====== ======4.查找指定位置的元素====== =
C++实现数据结构——线性表
qq_63058205的博客
11-10 1652
本次实验主要采用顺序表中的线性表的知识来进行实验，运用了线性表相关操作的声明和实现，如增删改查等。
c++线性表的数组实现
最新发布
05-31
C++中可以使用数组来实现线性表。以下是一个简单的示例代码： ```cpp #include using namespace std; const int MAXSIZE = 100; // 线性表最大长度 class ArrayLinearList { private: int data[MAXSIZE]; // ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值