C++实现链表

原创 2016年08月31日 10:53:43


#pragma once
#include<assert.h>
typedef int DataType;

class SListNode
{
           friend class SList;    //友元:Slist能访问SListNode
public:
          SListNode( DataType x )
                   :_data( x)
                   , _next( NULL)
          {}
          
private:
           DataType _data;
           SListNode* _next;//SListNode*
};


class SList
{
public:
          SList()
                   :_head( NULL)
                   , _tail( NULL)
          {}

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

           // old method
           //SList& operator=(const SList& s)
           //{
           //       if (this != &s)  //自己不能给自己赋值
           //       {
           //                 this->Clear();  //??????????
           //                 SListNode* cur = s._head;  //和上面差不多
           //                 while (cur)
           //                 {
           //                          this->PushBack(cur->_data);
           //                          cur = cur->_next;
           //                 }
           //       }
           //       return *this;
           //}

           //modern method
           SList& operator=(SList s)  //无const &  (SList s)
          {
                   swap(_head, s._head);
                   swap(_tail, s._tail);
                    return *this ;
          }

public:
           void PushBack(DataType x)
          {
                    //1.空
                    if (_head == NULL )
                   {
                              //new一个节点,利用SListNode构造函数进行初始化
                             _head = new SListNode (x);
                             _tail = _head;  //只有一个节点,_tail和_head都指向他
                   }
                    else
                   {
                              //tail->next 进行插入,再把tail移动
                             _tail->_next = new SListNode (x);
                             _tail = _tail->_next;   
                             _tail->_next = NULL; // 不知道用不用多此一举
                   }
          }
          
           void PopBack()
          {
                    //1.NULL 2.one  pop 3.more ->pop
                    if (NULL == _head)
                              return;
                    else if (_head==_tail)
                   {
                              delete _head;
                             _head = NULL;
                             _tail = NULL;
                   }
                    else
                   {
                              SListNode* tail = _head;
                              SListNode* prev = NULL ;
                              while (tail->_next)
                             {
                                      prev = tail;
                                      tail = tail->_next;
                             }
                              delete tail;
                             prev->_next = NULL;
                   }
          }
           void PushFront(DataType x)
          {
                    //1.judge 2.none 3.one 4.more
                    if (_head == NULL )
                   {
                             PushBack( x);
                   }
                    else if (_head == _tail)
                   {
                             _head = new SListNode (x);
                             _head->_next = _tail;
                   }
                    else
                   {
                              SListNode* tmp = new SListNode( x);
                             tmp->_next = _head;
                             _head = tmp;       
                   }
          }
           void PopFront()
          {
                    //judge 1.NULL 2.one 3.more
                    if (_head == _tail)
                   {
                              if (_head)
                             {
                                       delete _head;
                                      _head = NULL;
                                      _tail = NULL;
                             }
                   }
                    else
                   {
                              SListNode* del = _head;
                             _head = _head->_next;
                              delete del;
                   }
          }
           void Insert(SListNode * pos, DataType x )
          {
                    //judge position  1.head .tail 3.mid
                    assert(pos);
                    if (pos == _tail)
                   {
                             PushBack( x);
                   }
                    else
                   {
                              SListNode* tmp = new SListNode( x);
                             tmp->_next = pos->_next;
                              pos->_next = tmp;
                   }
          }
           SListNode* Find(DataType x)// SlistNode*
          {
                    SListNode* cur = _head;
                    while(cur)
                   {
                              if (cur->_data== x )
                             {        
                                       return cur;
                             }
                             cur = cur->_next;
                   }
                    return NULL ;
          }

           void Erase(SListNode * pos)
          {
                    //judge 1._head 2.tail 3.mid
                    if (pos == _head)
                   {
                             PopFront();
                   }
                    else if (pos == _tail)
                   {
                             PopBack();
                   }
                    else
                   {
                              //找前驱结点
                              SListNode* prev = _head; 
                              while(prev)
                             {
                                       if (prev->_next == pos )//如果前驱结点的后继等于Pos
                                      {
                                                 //prev->next=pos->next
                                                prev->_next = pos->_next;
                                                 delete pos ;
                                                 break;
                                      }
                                       //prev动起来
                                      prev = prev->_next;
                             }

                   }
          }
          



           void Clear()
          {
                    SListNode* cur = _head;
                    while (cur)
                   {
                              SListNode* del = cur;
                             cur = cur->_next ;   //_next为私有数据 应设置友元
                              delete del;
                   }
                   _head = NULL;
                   _tail = NULL;
          }


           void PrintSList()
          {
                    SListNode* cur = _head;
                    while (cur)
                   {
                             cout << cur->_data << "->" ;
                             cur = cur->_next;
                   }
                   cout << "NULL" << endl;
          }
private:
           SListNode* _head;//不带头结点
           //SListNode  head;//带头结点
           SListNode* _tail;
};



void TestSList1()
{
           SList s1;
          s1.PushBack(1);
          s1.PushBack(2);
          s1.PushBack(3);
          s1.PushBack(4);
          s1.PrintSList();
          s1.PopBack();
          s1.PopBack();
          s1.PrintSList();
           //SList s2(s1);  //s1,s2都指向 链表1->2->3   两次析勾会造成崩溃
           //s2.PrintSList();
           /*SList s3;
          s3 = s1;
          s3.PrintSList();*/
}


//test PushFront/PopFront
void TestSList2()
{
           SList s1;
          s1.PushFront(1);
          s1.PushFront(2);
          s1.PushFront(3);
          s1.PushFront(4);
          s1.PushFront(5);
          s1.PushFront(6);
          s1.PushFront(7);
          s1.PrintSList();
          s1.PopFront();
          s1.PopFront();
          s1.PopFront();
          s1.PopFront();
          s1.PopFront();
          s1.PrintSList();
}

//test Find/Insert
void TestSList3()
{
           SList s1;
          s1.PushBack(1);
          s1.PushBack(2);
          s1.PushBack(3);
          s1.PushBack(4);
          s1.PrintSList();

           SListNode* pos = s1.Find(2);
          s1.Insert(pos, 10);
          s1.PrintSList();
}
// Erase
void TestSList4()
{
           SList s1;
          s1.PushBack(1);
          s1.PushBack(2);
          s1.PushBack(3);
          s1.PushBack(4);
          s1.PrintSList();
           SListNode* pos = s1.Find(2);
          s1.Erase(pos);
          
          s1.PrintSList();
}


版权声明:本文为博主原创文章,未经博主允许不得转载。

C++实现链表基本操作

前几天找实习的时候,一个面试官给我留了一个题,做一个链表demo,要求实现创建、插入、删除等操作。 链表是一种常见的数据结构,它是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链...
  • Kevin_zhai
  • Kevin_zhai
  • 2016年01月10日 21:56
  • 37163

c++模板链表实现

简介:主要是利用模板实现链表的操作。模板的使用,使得程序的开发量大大地减少。 可以先定义一个链表LinkList,之后可以定义自己的类了(例如:Student类),使用时就可以这样调用了 LinkLi...
  • invisible_sky
  • invisible_sky
  • 2016年03月24日 17:48
  • 934

链表——用C++模板实现

LinkedList.h//单向链表的实现 //查找、插入和移除某个元素、复制、清空单向链表的时间复杂度均为O(n) //设计类时,应尽量减少类的成员函数之间的依赖关系 #ifndef LINK...
  • Microsues
  • Microsues
  • 2010年12月29日 20:02
  • 12423

基于链表的栈实现(c++)

#ifndef _STACK#define _STACK#include //节点类template class Node{ public: T data; Node * next; };//栈...
  • ericming200409
  • ericming200409
  • 2010年04月26日 20:13
  • 1617

单向链表之C++实现

单向链表是常用的数据结构,之前只是看过,没有自己动手实现过,现在来
  • KangRoger
  • KangRoger
  • 2014年07月01日 21:20
  • 8199

C++模板类实现单链表

c++模板类实现单链表#include using namespace std; #include #include template struct LinkNode { LinkNode*...
  • Nou_Camp
  • Nou_Camp
  • 2017年04月08日 17:15
  • 859

队列 queue 的链表实现操作 -C++

队列(queue) (像打饭的排队)掐头去尾 概念:只允许一端进行插入,另一端进行删除操作的线性表。 (先进先出:FIFO,插入的一端是队尾,删除的一端是对头)...
  • SUNSHANGJIN
  • SUNSHANGJIN
  • 2014年08月12日 14:36
  • 2787

c++单链表实现大数的求和运算

首先list.h #ifndef LIST_H #define LIST_H #include #include #include using namespace std; typedef ...
  • github_36186488
  • github_36186488
  • 2016年11月03日 13:36
  • 1213

数据结构和算法C++语言实现:链表的实现

链表使用面向对象的方法实现,C++
  • QQrenzai
  • QQrenzai
  • 2016年06月15日 17:37
  • 515

C++实现链表逆序

链表的结构
  • a1037488611
  • a1037488611
  • 2014年10月20日 14:34
  • 1404
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C++实现链表
举报原因:
原因补充:

(最多只允许输入30个字)