c++实现顺序表、单链表和双向链表

最新推荐文章于 2024-01-27 00:03:25 发布
最新推荐文章于 2024-01-27 00:03:25 发布
阅读量469 收藏 2
点赞数
文章标签： 顺序表 单链表 双向链表 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sakuramyb/article/details/75949306
版权

c++实现顺序表、单链表和双向链表

1.顺序表

//SeqList.h
#pragma once

#include<iostream>
#include<assert.h>
using namespace std;

typedef int DataType;

class SeqList
{
public:
    SeqList()
        :_array(NULL)
        ,_size(0)
        ,_capacity(0)
    {}
    SeqList(const SeqList& s)
    {
        _array=(DataType*)malloc(sizeof(DataType)*s._size);
        memcpy(_array,s._array,sizeof(DataType)*s._size);
        _size=_capacity=s._size;
    }


    SeqList& operator=(SeqList& s)
    {
        Swap(s);
        return *this;

    }

    void Swap(SeqList& s)
    {
        swap(_array,s._array);
        swap(_size,s._size);
        swap(_capacity,s._capacity);

    }

    ~SeqList()
    {
        if(_array)
        {
            free(_array);
            _size=_capacity=0;
            _array=NULL;
        }
    }

    void CheckCapcacity()
    {
        if(_size==_capacity)
        {
            _capacity=_capacity*2+3;
            _array=(DataType*)realloc(_array,_capacity*sizeof(DataType));
        }
    }

    void PushBack(DataType x)
    {
        CheckCapcacity();
        _array[_size++]=x;
    }

    void PopBack()
    {
        assert(_size);
        --_size;
    }

    void PushFront(DataType x)
    {
        CheckCapcacity();
        int end=_size-1;
        while(end>=0)
        {
            _array[end+1]=_array[end];
            --end;
        }
        _array[0]=x;
        ++_size;
    }

   void  PopFront()
   {
       assert(_size);
       for(size_t i=1;i<_size;++i)
       {
           _array[i-1] = _array[i];
       }
       --_size;  
   }

   inline void Insert(size_t pos, DataType x)
   {
       assert(pos<_size);
       for(int end=_size-1;(int)pos<end;--end)
       {
           _array[end+1]=_array[end];
       }
       _array[pos] = x;
       ++_size;
   }

   inline void Erase(size_t pos)
   {
       assert(pos<_size);
       for(size_t i=pos+1;i<_size;++i)
       {
           _array[i-1]=_array[i];
       }
       --_size;
   }

   void Print()
   {
       assert(_size);
       for(size_t i=0;i<_size;++i)
       {
           cout<<_array[i]<<" ";
       }
       cout<<endl;
   }

   inline DataType& operator[](size_t pos)
   {
       assert(pos<_size);
       return _array[pos];
   }

private:
    DataType* _array;
    size_t _size;
    size_t _capacity;

};
//SeqList.cpp
#include<iostream>
#include"SeqList.h"


using namespace std;


void TestSeqList()
{
    SeqList s1;

    s1.PushBack(1);
    s1.PushBack(2);
    s1.PushBack(3);
    s1.PushBack(4);
    s1.Print();

    s1.PushFront(0);
    s1.Print();

    s1.Insert(2,10);
    s1.Print();
    s1.Insert(0,20);
    s1.Print();

    s1.Erase(2);
    s1.Print();

    SeqList s(s1);
    s.PushBack(5);
    s.Print();

    s1=s;
    s1.Print();
}
int main()
{
      TestSeqList();
      return 0;
}

这里写图片描述

2.单链表

//SList.h
#pragma once

#include<iostream>
#include<assert.h>
using namespace std;

typedef int DataType;
struct SListNode
{
    DataType _data;
    SListNode* _next;

    SListNode(DataType x)
        :_data(x)
        ,_next(NULL)
    {

    }

};

class SList
{
 typedef SListNode Node;
public:
    SList()
        :_head(NULL)
        ,_tail(NULL)
    {

    }

    SList(const SList& s)
        :_head(NULL)
        ,_tail(NULL)
    {
        Node *cur=s._head;
        while(cur)
        {
             PushBack(cur->_data);
             cur=cur->_next;
        }
    }

    SList& operator=(SList s)
    {
        swap(_head, s._head);
        swap(_tail, s._tail);
        return *this;
    }

    ~SList()
    {
        Node *cur=_head;
        while(cur)
        {
            Node* next=cur->_next;
            delete cur;
            cur=next;
        }
        _head=_tail=NULL;
    }

    void PushBack(DataType x)
    {
        //链表为空
        //链表有一个以上节点
        if(_head==NULL)
        {
            _head=_tail=new Node(x);
        }
        else
        {
            _tail->_next=new Node(x);
            _tail=_tail->_next;
        }
    }

    void PopBack()
    {

        //无节点
        //有一个节点
        //有一个以上节点
        if(_head==NULL)
        {
            return;
        }
        else if(_head==_tail)
        {
            delete _head;
            _head=_tail=NULL;
        }
        else
        {
            Node* prev=_head;
            while(prev->_next!=_tail)
            {
                prev=prev->_next;
            }
            delete _tail;
            _tail=prev;
            _tail->_next=NULL;
        }
    }

void PushFront(DataType x) 
{
    //无节点
    //有一个以上节点
    if(_head==NULL)
    {
        _head=_tail=new Node(x);
    }
    else
    {
       Node* tmp=new Node(x);
       tmp->_next=_head;
       _head=tmp;
    }
}

void PopFront()
{
    //无节点
    //有一个节点
    //有一个以上节点
    if(_head==NULL)
    {
        return;
    }
    else if(_head==_tail)
    {
         delete _head;
         _head=_tail=NULL;
    }
    else
    {
        Node * tmp=_head;
        _head=_head->_next;
        delete tmp;
    }
}

 //插入一个节点在pos的前面 
void Insert(Node* pos, DataType x)
{
   assert(pos);
   if(pos==_head)
   {
       PushFront(x);
   }
   else
   {
       Node* prev=_head;
       while(prev->_next!=pos)
       {
           prev=prev->_next;
       }
       Node* tmp=new Node(x);
       prev->_next=tmp;
       tmp->_next=pos;
   }
}





void Erase(Node* pos)
{
    assert(pos);
    if(pos==_head)
    {
        PopFront();
    }
    else if(pos==_tail)
    {
        PopBack();
    }
    else
    {
        Node *prev=_head;
        while(prev->_next!=pos)
        {
            prev=prev->_next;
        }
        prev->_next=pos->_next;
        delete pos;
    }
}

SListNode* Find(DataType x)
{
  Node* cur=_head;
  while(cur)
  {
      if(cur->_data==x)
      {
          return cur;
      }
      cur=cur->_next;
  }
   return NULL;
}


void Print()
{
    Node* cur=_head;
    while(cur)
    {
        cout<<cur->_data<<" ";
        cur=cur->_next;
    }
    cout<<endl;
}

private:
    Node* _head;
    Node* _tail;

};
//SListNode.cpp
#include<iostream>
#include"SList.h"
using namespace std;


void TestSList1()
{
    SList s1;
    s1.PushBack(1);
    s1.PushBack(2);
    s1.PushBack(3);
    s1.PushBack(4);
    s1.Print();

    s1.PopBack();
    s1.PopBack();
    s1.PopBack();
    s1.PopBack();
    s1.PopBack();
    s1.Print();

    s1.PushFront(0);
    s1.PushFront(1);
    s1.PushFront(2);
    s1.PushFront(3);
    s1.Print();

    s1.PopFront();
    s1.PopFront();
    s1.PopFront();
    s1.PopFront();
    s1.PopFront();
    s1.Print();
}

void TestSList2()
{
    SList s2;
    s2.PushBack(1);
    s2.PushBack(2);
    s2.PushBack(3);
    s2.PushBack(4);
    s2.Print();

    SListNode* pos=s2.Find(2);
    s2.Insert(pos,10);
    s2.Print();

    s2.Erase(pos);
    s2.Print();

}

void TestSlist3()
{
    SList s1;
    s1.PushBack(1);
    s1.PushBack(2);
    s1.PushBack(3);
    s1.PushBack(4);
    s1.Print();

    SList s2(s1);
    s2.PushBack(10);
    s2.PushBack(11);
    s2.Print();

    s1 = s2;
    s1.Print();
}
int main()
{
    //TestSList1();
    //TestSList2();
    TestSlist3();
    return 0;
}

TestSList1()；
这里写图片描述
TestSList2()；
这里写图片描述
TestSList3()；
这里写图片描述

3.双向链表

//ListNode.h
#pragma once
#include<iostream>
#include<assert.h>
using namespace std;


typedef int DataType;

struct ListNode 
{ 
    ListNode* _next; 
    ListNode* _prev; 
    DataType _data; 
    ListNode(const DataType d)
    :_data(d)
    ,_next(NULL)
    ,_prev(NULL)
    {

    }
}; 

class List 
{ 
    typedef ListNode Node; 
public: 
    List();    //构造
    List(const List& d);  //拷贝构造
    List& operator=(const List& d); 
    ~List(); 

    void PushBack(DataType x); 
    void PopBack();
    void PushFront(DataType x); 
    void PopFront(); 
    // 在pos的前面插入一个 
    void Insert(Node* pos, DataType x); 
    void Erase(Node* pos); 
    Node* Find(DataType x); 
    void Reverse();
    void Print();
private: 
    Node* _head; 
    Node* _tail; 
};
//ListNode.cpp
#include"ListNode.h"
#include<iostream>

List::List()//构造
:_head(NULL)
,_tail(NULL)
{

}

List::List(const List& d)//拷贝构造
:_head(NULL)
,_tail(NULL)
{
    if(d._head==NULL)
    {
        return;
    }
    Node* tmp=d._head;
    while(tmp)
    {
        PushBack(tmp->_data);
        tmp=tmp->_next;
    }
}

//List& List::operator=(const List& d)//赋值运算符重载
//{
//  if(this!=&d)
//  {
//      swap(_head,d._head);
//      swap(_tail,d._tail);
//  }
//  return *this;
//}

List::~List()//析构
{
    Node* cur=_head;
    while(cur!=_tail)
    {
        _head=_head->_next;
        delete cur;
        cur=_head;
    }
    _head=NULL;
    _tail=NULL;
}

void List::PushBack( DataType d)//尾插
{
    if(_head==NULL)
    {
        _head=_tail=new Node(d);
    }
    else
    {
        Node* tmp=new Node(d);
        _tail->_next=tmp;
        tmp->_prev=_tail;
        _tail=_tail->_next;
    }
}

void List::PopBack() //尾删
{
     if(_head==NULL||_tail==_head)
     {
       delete _tail;
       _head=_tail=NULL;
     }
     else
     {
         _tail=_tail->_prev;
         _tail->_next=NULL;
     }
}

void List::PushFront(DataType x)//头插
{
   if(_head==NULL)
   {
        _head=_tail=new Node(x);
   }
   else
   {
       Node* tmp=new Node(x);
       tmp->_next=_head;
       _head->_prev=tmp;
       _head=tmp;
   }
}

void List::PopFront()  //头删
{
    if(_head==NULL||_head==_tail)
    {
        delete _tail;
        _head=_tail=NULL;
    }
    else
    {
        _head=_head->_next;
        delete _head->_prev; 
    }
}

void List::Insert(Node* pos, DataType x) //任意位置插入一个节点
{
    assert(pos);
    if(pos==_head)
    {
        PushFront(x);
    }
    else
    {
        Node* prev=_head;
        while(prev->_next!=pos)
        {
            prev=prev->_next;
        }
        Node* tmp=new Node(x);
        prev->_next=tmp;
        tmp->_next=pos;
    }
}


ListNode* List::Find(DataType x) //在链表中查找一个节点
{
    Node* cur=_head;
    while(cur)
    {
        if(cur->_data==x)
        {
            return cur;
        }
        cur=cur->_next;
    }
    return NULL;

}

void List::Erase(Node* pos) //删除任意节点
{
    assert(pos);
    if(pos==_head)
    {
        PopFront();
    }
    else if(pos==_tail)
    {
        PopBack();
    }
    else
    {
        Node* prev=_head;
        while(prev->_next!=pos)
        {
            prev=prev->_next;
        }
        prev->_next=pos->_next;
        delete pos;
    }
}

void List:: Reverse()//双向链表逆置
{
    if(_head==_tail)
    {
        return;
    }
    else
    {
        ListNode* cur=_head;
        ListNode* tmp=cur;
        ListNode* NewHead=NULL;
        while(cur)
        {
            tmp=cur;
            cur=cur->_next;
            tmp->_next=NewHead;
            tmp->_prev=cur;
            NewHead=tmp;
        }
        _head=NewHead;
    }
}

void List::Print()   //打印链表
{
   if(_head==NULL)
   {
      cout<<"The List is Empty"<<endl;
       return;
   }
   else
   {
       Node* tmp=_head;
       while(tmp)
       {
           cout<<tmp->_data<<"  " ;
         tmp=tmp->_next;
       }
       cout<<endl;
   }
}
//Test.cpp
#include"ListNode.h"
#include<stdlib.h>
#include<iostream>
using namespace std;


void test1()
{
   List list1;
   list1.PushBack(0);
   list1.PushBack(1);
   list1.PushBack(2);
   list1.PushBack(3);
   list1.Print();
   list1.PopBack();
   list1.Print();
   list1.PushFront(4);
   list1.Print();
   list1.PopFront();
   list1.Print();
   list1.Reverse();
   list1.Print();

}

void test2()
{
     List s1;
     s1.PushBack(1);
     s1.PushBack(2);
     s1.PushBack(3);
     s1.PushBack(4);
     s1.Print();
     ListNode* pos=s1.Find(2);
     s1.Insert(pos,10);
     s1.Print();
     s1.Erase(pos);
     s1.Print();
}


int main()
{
    //test1();
    test2();
    return 0;
}

text1();
这里写图片描述

test2();
Alt text

noCrayon
关注
C++实现顺序表与链表
honeyJ
11-05 912
C++实现顺序表与链表 一、顺序表 之前已经对顺序表有了了解，需要注意的是读者如果疑惑以下代码没有实现头插与头删，是因为代码中任意插入与删除这两个函数可以实现此功能。下面有测试代码，读者也可以自行测试。 代码如下： #include using namespace std; #include typedef int DataType; class SeqList { public:
【数据结构】第二章 线性表（时间复杂度、顺序表、链表、单链表、双向链表）代码分析详细
weixin_45991687的博客
04-01 3673
【数据结构】第二章 线性表（时间复杂度、顺序表、链表、单链表、双向链表）代码分析详细
数据结构图文解析之：数组、单链表、双链表介绍及C++模板实现
weixin_33713707的博客
02-01 416
0. 数据结构图文解析系列 数据结构系列文章 数据结构图文解析之：数组、单链表、双链表介绍及C++模板实现 数据结构图文解析之：栈的简介及C++模板实现 数据结构图文解析之：队列详解与C++模板实现 数据结构图文解析之：树的简介及二叉排序树C++模板实现. 数据结构图文解析之：AVL树详解及C++模板实现 数据结构图文解析之：二叉堆详解及C++模板实现 1....
C++模版类实现顺序表、单链表、双链表
10-28
压缩包内为线性表的工程包；工程内包括顺序表、单链表、双链表的类的定义与实现；附适当注释；完全面向对象，类封装；测试类中用（纯）虚函数实现多态。
c++顺序表与双向链表实现
zhang1308299607的博客
07-22 467
之前实现过c语言版本的顺序表和单向链表，现在实现c++版本的顺序表和双向链表： 再来看一下顺序表，单链表和双向链表的区别： 顺序表的c++实现： #define _CRT_SECURE_NO_DEPRECATE 1 #include #include #include using namespace std; typedef int Datatype; class SeqList
数据结构-顺序表与单链表的C++模板类实现
Alan_1550587588的博客
04-10 821
C++模板类实现顺序表 实现功能:  1.尾插，2.头插，3.显示，4.尾删，5.头删，6.按位置，7.插按值插，8.按位置删，9.按值删，10.按值查，11.求表长，12.清除数据，13.摧毁该顺序表，14.反转，15.冒泡排序。 顺序表模板类实现代码: //顺序表********************************************************
C++实现数据结构：顺序表、单链表、双向链表、循环链表算法模板
"该资源是一份使用C++实现的数据结构各种算法模板，涵盖了顺序表、单链表、双向链表和循环链表等基础数据结构的实现。通过这些模板，可以方便地理解和学习数据结构的相关操作，如插入、删除、遍历等。每个数据结构都...
顺序表，单链表，双向链表
01-04
本主题将深入探讨顺序表、单链表和双向链表的概念、实现以及它们之间的区别。 首先，顺序表是一种线性数据结构，它在内存中连续存储元素。这种存储方式使得随机访问变得高效，因为可以通过索引直接计算元素的地址。...
深入解析C++的循环链表与双向链表设计的API实现
09-02
在C++编程中，循环链表和双向链表是两种重要的数据结构，它们在处理动态数据集合时提供了灵活且高效的方式。循环链表是单链表的一种变体，它的最后一个节点指向链表的第一个节点，形成了一个逻辑上的环。双向链表则...
C++顺序表，单链表，循环双链表，栈，实例
03-22
本文将深入探讨C++中的四个关键数据结构：顺序表、单链表、循环双链表以及栈，并通过实例来阐述它们的实现与应用。 1. **顺序表**：顺序表是最基础的数据结构，它在内存中连续存储元素，通过索引来访问。在C++中，...
利用C++简单实现顺序表和单链表的示例代码
08-29
主要给大家介绍了关于利用C++简单实现顺序表和单链表的方法，文中给出了详细的示例代码供大家参考学习，需要的朋友可以参考借鉴，下面来跟着小编一起来学习学习吧。
用c++类模板，实现的单链表基本操作
05-14
#include "stdafx.h" #include #include using namespace std; template struct LNode { T data; LNode *next; }; template class LinkList { public: LinkList(){L = 0;}//构造函数 ~LinkList();//析构函数，销毁单链表 void CreateList_L(int n);//构造单链表 bool IsEmpty() const{return L->next == 0;}//判断单链表是否为空 int GetElem_L(int i,T &e) const;//当第i个元素存在时，其值赋给e int ListInsert_L(int i,T &e);//在第i个位置插入元素e ……………………
c/c++实现顺序表和单链表
min954584739的博客
03-18 598
实现基于C/C++的数据结构的顺序表，单链表等，此程序未经过严格实验，只是提供大概思路，供大家参考指正
C++实现顺序表和单链表
qing310820的专栏
10-17 317
创建文件命名为sqlist.h #ifndef SQLIST_H #define SQLIST_H typedef int ElemType; class SqList { public: SqList(); // 无参构造函数，建立空的顺序表 SqList(ElemType array[], int len); ...
数据结构学习笔记2_顺序表和链表（C++实现）
最新发布
must_Accepted的博客
01-27 460
【代码】数据结构学习笔记_顺序表和链表（C++实现）
顺序链表(C++)
weixin_34001430的博客
10-21 210
顺序表结构 struct Sq_list { int elem[Max_size+1]; int length; }; 创建并初始化顺序表 int Init_list(Sq_list *L) { L->length = 0; return 0; } 按序插入元素 int insert (Sq_lis...
C++实现顺序表->单链表->双向链表
Quinn0918的博客
07-20 1373
C++实现顺序表Seqlist.h#pragma once typedef int DataType; #include<assert.h> class Seqlist { public: Seqlist()//构造函数 :_data(NULL) , _size(0) , _capa(0) { } ~Seqlist()//
链表和顺序表的实现c++版（绝对能用）
改变世界的力量
03-13 231
最近在重新复习C++基础知识点，复习到链表和顺序表，把之前的代码整理出来给大家参考；   我的注释算是比较详细的，所以就不做过多解释了；   贴代码的话只把具体实现贴出来，如果想要完整代码的我已经提供下载链接了哦，希望对大家有帮助：   首先是纯虚函数，两个表都继承此函数：headlist.h #ifndef LISTHEAD_H #defineLISTHEAD_H   #...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值