【C++】实现双向链表的所有操作,包括逆置双链表(三种方法)

原创 2016年05月30日 17:17:48

建立源文件List.cpp

include "List.h"

int main()
{
    Test();
    system("pause");
    return 0;
}

建立头文件List.h

#ifndef __LISH_H__
#define __LISH_H__
#include<iostream>
using namespace std;

typedef int DataType;

struct ListNode
{
    ListNode(DataType x)
    :_next(NULL)
    , _prev(NULL)
    , _data(x)
    {}

    ListNode* _next;
    ListNode* _prev;
    DataType _data;
};


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

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

    List& operator= (const List& s)
    {
        //先删除节点,再插入节点
        if (&s != this)
        {
            ListNode* pcur = _head;
            while (pcur)
            {
                ListNode* del = pcur;
                pcur = pcur->_next;
                delete del;
                del = NULL;
            }
            ListNode* cur = s._head;
            while (cur)
            {
                this->PushBack(cur->_data);
                cur = cur->_next;
            }
        }
        return *this;
    }

    ~List()
    {
        ListNode* cur = _head;
        while (cur)
        {
            ListNode* del = cur;
            cur = cur->_next;
            delete del;
            del = NULL;
        }
    }

    //尾插
    void PushBack(DataType x)
    {
        //分:0节点   1、多节点两种情况
        if (_head == NULL)
        {
            _head = new ListNode(x);
            _tail = _head;
            _tail->_next = NULL;
        }
        else
        {
            ListNode* cur = new ListNode(x);
            _tail->_next = cur;
            cur->_prev = _tail;
            _tail = cur;
            _tail->_next = NULL;
        }
    }

    //尾删
    void PopBack()
    {
        if (_head == _tail)
        {
            if (_head != NULL)
            {
                delete _head;
                _head = NULL;
                _tail = NULL;
            }
            else
            {
                return;
            }
        }
        else
        {
            ListNode* prev = _tail->_prev;
            delete _tail;
            _tail = NULL;
            _tail = prev;
            _tail->_next = NULL;
        }
    }

    //头插
    void PushFront(DataType x)
    {
        if (_head == NULL)
        {
            PushBack(x);
        }
        else
        {
            ListNode* index = new ListNode(x);
            index->_next = _head;
            _head->_prev = index;
            _head = index;
            _head->_prev = NULL;
        }
    }

   //头删
    void PopFront()
    {
        if (_head == _tail)
        {
            PopBack();            
        }
        else
        {
            ListNode* del = _head;
            ListNode* next = _head->_next;
            _head = next;
            _head->_prev = NULL;
            delete del;
            del = NULL;
        }
    }
    
    //插入元素
    void Insert(size_t pos, DataType x)
    {
        //分:是尾插   不是尾插    两种情况
        ListNode* cur = _head;
        while (--pos)
        {            
            cur = cur->_next;        
        }
        if (cur == _tail)
        {
            PushBack(x);
        }
        else
        {
            ListNode* index = new ListNode(x);
            ListNode* prev = cur->_prev;
            index->_next = cur;
            cur->_prev = index;
            prev->_next = index;
            index->_prev = prev;
        }
    }

    //查找元素
    ListNode* Find(DataType x)
    {
        ListNode* cur = _head;
        while (cur)
        {
            if (cur->_data == x)
            { 
                return cur;
            }
            cur = cur->_next;
        }
        return NULL;
    }

    //删除元素
    void Erase(ListNode* pos)
    {
        if (pos == _head)
        {
            PopFront();
        }
        else if (pos == _tail)
        {
            PopBack();
        }
        else
        {
            ListNode* prev = pos->_prev;
            ListNode* next = pos->_next;
            prev->_next = next;
            next->_prev = prev;
            delete pos;
            pos = NULL;
        }
    }
    
    //逆置方法一:从两头走,交换数据
    /*void Reverse()
    {
        ListNode* begin = _head;
        ListNode* end = _tail;
        while (!((begin == end) || (end->_next == begin)))
        {
            swap(begin->_data, end->_data);
            begin = begin->_next;
            end = end->_prev;
        }
    }*/


    //逆置方法二:交换节点的前驱和后继
    /*void Reverse()
    {
        ListNode* cur = _head;
        while (cur)
        {
            swap(cur->_prev, cur->_next);
            cur = cur->_prev;
        }
        swap(_head, _tail);
    }*/

    
    //逆置方法三:摘节点,头插该节点
    void Reverse()
    {
        ListNode* cur = _head;
        ListNode* newhead = NULL;
        while (cur)
        {
            ListNode* tmp = cur;
            cur = cur->_next;
            if (newhead == NULL)
            {
                newhead = tmp;

                newhead->_next = NULL;
                newhead->_prev = NULL;
                _head = _tail = newhead;
            }
            else
            {
                newhead->_prev = tmp;
                tmp->_next = newhead;            
                newhead = tmp;
                _head = newhead;
                _head->_prev = NULL;
            }        
        }
    }

    //打印
    void PrintList()
    {
        ListNode* cur = _head;
        while (cur)
        {
            cout << cur->_data << "->";
            cur = cur->_next;
        }
        cout << "NULL" << endl;
    }
private:
    ListNode* _head;
    ListNode* _tail;
};


void Test()
{
    List s;
    s.PushBack(1);
    s.PushBack(2);
    s.PushBack(3);
    s.PushBack(4);
    s.PushBack(5);
    s.PrintList();

    s.PopBack();
    s.PrintList();

    s.PushFront(0);
    s.PrintList();

    s.PopFront();
    s.PrintList();

    s.Insert(2, 10);
    s.PrintList();

    s.Reverse();
    s.PrintList();

}

#endif //__LIST_H__


本文出自 “Han Jing's Blog” 博客,请务必保留此出处http://10740184.blog.51cto.com/10730184/1747880

【C++】模版实现双向链表的各种操作(如:逆置、去重Unique、分类(冒泡)、合并)

在cplusplus.com里,我们可以搜索list来查看库是如何实现双向链表的。当然,我们也可以在平时使用时包上头文件list来调用C++里的list库。在这里,我今天就不再赘述用C语言或者C++未...

用C++实现双链表的增删查改以及双向链表的逆转

在我们实现双向链表的增删查改时一定要注意各种情况 分析各种情况我们才能更好的掌握增删查改以下是双向链表增删查改的代码。#include #include #include using namespa...

数据结构——双向链表实现,基本操作的C++版

对于循环双向链表 判断一个链表是否为空的条件为:head->next==head (头指针) 判断*p为最后一个节点的条件为:p->next=head [cpp] v...

数组、单链表和双链表介绍 以及 双向链表的C/C++/Java实现

概要 线性表是一种线性结构,它是具有相同类型的n(n≥0)个数据元素组成的有限序列。本章先介绍线性表的几个基本组成部分:数组、单向链表、双向链表;随后给出双向链表的C、C++和Java三种语言的...

双向链表基础操作C++实现

Node.h:template struct Node { T val; Node* next; Node* prev; Node(T nVal) { ...

数组、单链表和双链表介绍 和 双向链表的C/C++/Java实现

概要 线性表是一种线性结构,它是具有相同类型的n(n≥0)个数据元素组成的有限序列。本章先介绍线性表的几个基本组成部分:数组、单向链表、双向链表;随后给出双向链表的C、C++和Java三种语言的...

用C++实现双向链表

  • 2008年11月14日 23:13
  • 3KB
  • 下载

C++ 双向链表的简单操作

最近有一点懂链表的知识了,记录下来多复习巩固。
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【C++】实现双向链表的所有操作,包括逆置双链表(三种方法)
举报原因:
原因补充:

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