【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程序设计

题目:创建一个双链表,然后逆置双链表。程序分析:将双链表逆置,即是将双链表中的元素逆置,依次将双链表的结点按照头插法插入到一个新建链表的首位,即可实现双链表元素的逆置代码如下:#include#inc...
  • qiao_yuzhou
  • qiao_yuzhou
  • 2011年01月27日 10:21
  • 4877

将一个双向链表逆置的正确姿势

双向链表中含有数据成员_data,_prev,_next,也就是说数据节点前后都有一个指向前一个节点和后一个节点的指针。然而要想实现双向链表的逆置,首先我们先来了解一下单链表的逆置        单链...
  • leex_brave
  • leex_brave
  • 2016年05月24日 15:27
  • 1686

双向循环链表(插入,删除,就地逆置)

package design; import java.util.Scanner; //循环双链表 public class LinkedList { private int theSi...
  • u012116457
  • u012116457
  • 2014年01月02日 20:13
  • 2247

java数据结构之循环双链表

感谢tu451953337的分享 原文链接地址:点击打开链接 这个循环双链表写的相当不错,注释解析也很清晰。是个不错的博文! public class DbLinkedList  ...
  • linzhiqiang0316
  • linzhiqiang0316
  • 2016年05月31日 21:44
  • 873

java链表之--双向循环链表

在单链表中,查询下一个元素的时间是O(1)。查询上一个元素的时间却是O(n)。 为了克服这种缺点,有了双向链表----继而为了更加高效-----双向循环链表 此外引用不知哪位大神的一句话:...
  • basycia
  • basycia
  • 2016年07月06日 16:01
  • 1419

(C++版)链表(三)——实现双向链表的创建、插入、删除等简单操作

链表(三)
  • u011248694
  • u011248694
  • 2014年05月12日 19:43
  • 4697

C++实现双链表的基本功能

双链表:在单链表的每个结点中,再设置一个指向其前驱结点的指针域 线性表的双向链表存储结构: typedef struct Node { DataType _data; s...
  • qq_34328833
  • qq_34328833
  • 2016年08月23日 14:13
  • 1982

c++ 实现双链表基本操作

#include #include #include #include /*c++实现双链表的基本操作*/ using namespace std; typedef struct stude...
  • cfan0801
  • cfan0801
  • 2012年03月13日 21:02
  • 3893

双向链表反转

双向链表结构定义如下: struct ListNode { ListNode* pre; int data; ListNode* next; }; 先要实现...
  • ye405464136
  • ye405464136
  • 2014年04月11日 09:59
  • 2044

数据结构-【链表】单向链表的逆置和双向循环链表

单向链表的逆置 1、为什么不能用auto变量的地址去初始化static型指针? 因为Static是在编译时进行初始化的,而Auto是在运行时初始化的,在编译时,Auto变量还不存在呢,当然也就没有地址...
  • gogoky
  • gogoky
  • 2014年09月10日 20:26
  • 1164
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【C++】实现双向链表的所有操作,包括逆置双链表(三种方法)
举报原因:
原因补充:

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