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

最新推荐文章于 2019-06-10 11:14:05 发布
最新推荐文章于 2019-06-10 11:14:05 发布
阅读量437 收藏 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
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
双向链表操作
10-28
内容：双向链表创建，遍历，删除，插入。自己看图写代码，只是随写，本人初学者。
顺序链表与单链表的C++实现
zcawesome的博客
04-08 808
对于顺序链表的实现：//顺序表 # include &lt;iostream&gt; # include &lt;cstring&gt; using namespace std; class orderlink{ private: int data[100]; int length; public: orderlink(){ length=0; memset(data...
C++模版类实现顺序表、单链表、双链表
10-28
压缩包内为线性表的工程包；工程内包括顺序表、单链表、双链表的类的定义与实现；附适当注释；完全面向对象，类封装；测试类中用（纯）虚函数实现多态。
用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++简单实现顺序表和单链表的示例代码
08-29
主要给大家介绍了关于利用C++简单实现顺序表和单链表的方法，文中给出了详细的示例代码供大家参考学习，需要的朋友可以参考借鉴，下面来跟着小编一起来学习学习吧。
顺序表，单链表，双向链表
01-04
本主题将深入探讨顺序表、单链表和双向链表的概念、实现以及它们之间的区别。 首先，顺序表是一种线性数据结构，它在内存中连续存储元素。这种存储方式使得随机访问变得高效，因为可以通过索引直接计算元素的地址。...
深入解析C++的循环链表与双向链表设计的API实现
09-02
在C++编程中，循环链表和双向链表是两种重要的数据结构，它们在处理动态数据集合时提供了灵活且高效的方式。循环链表是单链表的一种变体，它的最后一个节点指向链表的第一个节点，形成了一个逻辑上的环。双向链表则...
C++实现双向循环链表
08-19
在C++编程中，双向循环链表是一种高级数据结构，它允许从...通过使用双向链表，程序员可以更高效地执行这些任务，因为无需像在单链表中那样从头开始搜索。这种数据结构的灵活性和效率使其成为C++中常用的一种数据结构。
C++顺序表，单链表，循环双链表，栈，实例
03-22
本文将深入探讨C++中的四个关键数据结构：顺序表、单链表、循环双链表以及栈，并通过实例来阐述它们的实现与应用。 1. **顺序表**：顺序表是最基础的数据结构，它在内存中连续存储元素，通过索引来访问。在C++中，...
C++模板的实现（模板函数和模板类，附带模板实现顺序表和链表代码）
龙跃十二
05-05 3129
模板 一、模板函数 模板函数的格式： 模板参数隐式实例化 模板参数显示实例化 二、模板类 模板类的格式 模板类示例 模板  当我们实现一个交换函数时，我们可以写成如下。 void Swap(int&amp; x, int&amp; y) { int tmp = x; x = y; y = tmp; }  这里只能交换两个整数...
C++模板及用模板实现双向循环链表，顺序表
zhuohaiyy的博客
08-04 488
模板是泛型编程的基础。 所谓泛型编程就是编写与类型⽆关的逻辑代码，是⼀种复⽤的⽅式。 模板分为模板函数和模板类。函数模板格式: template <class 形参名1, class 形参名2, class 形参名n> 返回类型 函数名(参数列表) { ... } 模板形参的定义既可以使⽤class，也可以使⽤typename，含义是相同的。 注:模板未实例化时，代码内部的语法错误检测不
C++实现顺序表和单链表
chuxinlgz的博客
07-27 502
顺序表：顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。 确定了起始位置，就可通过公式计算出表中任一元素的地址：LOC（ai）=LOC（a1）+（i-1）*L 　1≤i≤n （L是元素占用存储单元的长度） 顺序表的实现一般是实现连续开辟一段空间，然后在进行数据的增删查改（静态顺序表） 其代码实现如下： #include #in
C++实现顺序表和链表
zhangye3017的博客
04-22 419
更多C++知识：c++目录索引 顺序表： Vector.h #pragma once typedef int DataType; class Vector { public: Vector();//构造 Vector( const Vector&amp; v);//拷贝构造 Vector&amp; operator=(const Vector&amp; v...
数据结构图文解析之：数组、单链表、双链表介绍及C++模板实现
weixin_33713707的博客
02-01 403
0. 数据结构图文解析系列 数据结构系列文章 数据结构图文解析之：数组、单链表、双链表介绍及C++模板实现 数据结构图文解析之：栈的简介及C++模板实现 数据结构图文解析之：队列详解与C++模板实现 数据结构图文解析之：树的简介及二叉排序树C++模板实现. 数据结构图文解析之：AVL树详解及C++模板实现 数据结构图文解析之：二叉堆详解及C++模板实现 1....
利用智能指针实现双链表的增删查
NO_小贾的专栏
10-28 1862
通过了解智能指针的使用以及原理之后，写了一个很奇葩的shared_ptr版本的双链表实现。虽然误打误撞没有在关键的问题上产生循环引用，但是这个实现也非常巧妙的避开了智能指针的智能管理内存，还是在手动的管理着分配的空间。 再有甚是感觉代码写的不够精炼，贴出来供大家指正。希望能有所收获。 #include #include using namespace std;templatestruct LN
如何使用一个指针来实现双向链表操作
chiichen的专栏
08-08 6915
1、使用的数学基础和基本数据结构及关系： x ^ y ^ y = x ^ ( y ^ y ) = x ^ 0 = x 双指针双向链表结点： struct double_link_list { struct double_link_list *next;
c/c++实现顺序表和单链表
min954584739的博客
03-18 575
实现基于C/C++的数据结构的顺序表，单链表等，此程序未经过严格实验，只是提供大概思路，供大家参考指正
c++实现双向链表，类模板双向链表
热门推荐
hugang的博客
09-06 1万+
c++实现双向链表的思想和c很类似，不同的是c++是将实现的函数放在类中，这样就可以由类实例化出对象再调用类中的函数进行添加、删除、查找、插入元素等功能。类模板实现双向链表在最后进行说明和实现，方法依然类似。 c++实现双向链表 #include #include using namespace std; typedef int Datatype; typedef
智能指针+模板实现链表
lancelot0902的博客
06-10 553
/*List.h*/ #ifndef LIST_H #define LIST_H #include <iostream> #include <memory> using namespace std; template<typename T> struct Node { public: T data; shared_ptr<Node<T>&g...
单链表和双向链表使用场景
最新发布
09-03
双向链表相对于单链表在插入和删除节点时更加灵活，因为可以通过修改前后节点的指针来实现。 使用场景示例： - 单链表适用于实现队列、栈等数据结构，因为在这些数据结构中插入和删除元素是常见操作。 - 双向链表...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值