C++ 手写链表 最终更新

最新推荐文章于 2023-11-11 07:00:00 发布
最新推荐文章于 2023-11-11 07:00:00 发布
阅读量364 收藏
点赞数
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45686201/article/details/109037191
版权

历史更新内容：

  • v1.4.2 更新：添加对尾指针的支持以便PushBack()
  • v1.4.3 更新：添加对前向指针的支持，使之成为双链表以便PopBack()
  • v1.4.4 更新：紧急修复了空表PushFront()和PopFront()时，使用了空指针的（并不存在的）前向指针成员的bug，但代价是各添加了一个if块，会导致性能损失
  • v1.4.5 更新：添加对循环链表的支持使之成为循环双链表。

老目标：

  • 单链表基本实现
  • 单链表的构造函数
  • 完成Lab2_3
  • 尾指针
  • 双链表
  • 用单链表 (v1.4.4) 实现“快速找到未知长度单链表的中间节点”
  • 用单链表 (v1.4.4) 实现“链表的冒泡排序”
  • 循环双链表
  • 用循环(双)链表 (v1.4.5) 完成约瑟夫环问题的解决；
  • C++多文件
  • 越界异常处理
  • 学习真正的C++ STL Linked List；
  • 通过C++面向对象特性，实现链栈(与链队列)

重要提示：

  1. 如提示未定义nullptr，请将编译器设置为C++11或取消第5行语句的注释。
  2. 由于循环链表的特性（比如根据tail->nextfirst还是tail->nextnullptr判断尾端），为简单起见使用普通单链表 (v1.4.4) 实现冒泡排序和寻找中间节点的示例；约瑟夫环则使用循环链表。
  3. 本周将投入到链栈链队列（1天）以及图论与树（直到10.17）的工作中去，因此本更新为链表的最后更新，敬请留意新文章。

用单链表 (v1.4.4) 实现“快速找到未知长度单链表的中间节点”

//myLinkedList(TailInsert) v1.4.4 快速找到未知长度单链表的中间节点
// #define TT template <typename T>
// #define mll myLinkedList
#define N 5
//#define nullptr NULL
#include <iostream>
#include <algorithm>
using namespace std;

template <typename T>
struct Node
{
    T data;
    Node<T>* next;
    Node<T>* prev;
};

template <typename T>
class myLinkedList
{
public:
    myLinkedList();
    myLinkedList(T a[],int n);
    myLinkedList(const myLinkedList<T> & imyLinkedList);
	~myLinkedList();

    int Length();
    bool isEmpty();
    void PrintList();
    T Get(int pos);
    int Locate(T x);

    void Insert(int i,T x);
    T Delete(int i);

    void InsertX(int i,T x);
    T DeleteX(int i);

    T PopFront();
    void PushFront(T x);
    void Reverse();
    void Clear();
    void PushBack(T x);
    T PopBack();

    Node<T>* GetMiddleNode();

    int Test();
private:
    Node<T>* first;
    Node<T>* tail;
    int length;
    Node<T>* GetX(int pos);
};

template <typename T>
myLinkedList<T>::myLinkedList()
{
    first=new Node<T>;
    first->next=nullptr;
    first->prev=nullptr;
    length=0;
    tail=first;
}

template <typename T>
myLinkedList<T>::myLinkedList(T a[],int n)
{
    first=new Node<T>;
    first->next=nullptr;
    first->prev=nullptr;
    length=0;
	Node<T>* p=first;
    for (int i=0;i<n;i++)
    {
        Node<T>* s=new Node<T>;
		p->next=s;
		s->prev=p;
        s->next=nullptr;
        s->data=a[i];
		p=p->next;
        length++;
    }
    tail=p;
}

template <typename T>
myLinkedList<T>::myLinkedList(const myLinkedList<T> & imyLinkedList)
{
    first=new Node<T>;
    first->next=nullptr;
    length=imyLinkedList.length;
	Node<T>* p=first;
	Node<T>* ip=imyLinkedList.first->next;

	for (int i=0;i<length;i++)
    {
        Node<T>* s=new Node<T>;
        s->data=ip->data;
        s->next=nullptr;
        s->prev=p;
		p->next=s;
		p=p->next;
		ip=ip->next;
    }
    tail=p;
}

template <typename T>
myLinkedList<T>::~myLinkedList()
{
	while(first->next!=nullptr)
	{
		Node<T>* q=first->next;
		first->next=q->next;
		delete q;
	}
	delete first;
//	delete tail;
}

template <typename T>
int myLinkedList<T>::Length()
{
    return length;
}

template <typename T>
bool myLinkedList<T>::isEmpty()
{
    if (length==0)
        return true;
    else
        return false;
}

template <typename T>
void myLinkedList<T>::PrintList()
{
    Node<T>* p=first->next;
    while (p!=nullptr)
    {
        cout<<p->data<<' ';
        p=p->next;
    }
    cout<<endl;
}

template <typename T>
T myLinkedList<T>::Get(int pos)
{
    if ((pos>=1)&&(pos<=length))
    {
        Node<T>* p=first->next;
        int cnt=1;//absPOS
        //int cnt=0;//binPOS
        while (p!=nullptr)
        {
            if (cnt==pos)
            {
                break;
            }
            else
            {
                p=p->next;
                cnt++;
            }
        }
        return p->data;
    }
    else
    {
        return -1;
    }
}

template <typename T>
int myLinkedList<T>::Locate(T x)
{
    Node<T>* p=first->next;
    int pos=1;//absPOS
    while (p!=nullptr)
    {
        if (x==p->data)
        {
            return pos;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
    return -1;
}

template <typename T>
void myLinkedList<T>::Insert(int i,T x)//insert after absPOS(i)
{
    Node<T>* p=first->next;
    int pos=1;
    while (p!=nullptr)
    {
        if (pos==i)
        {
            Node<T>* s=new Node<T>;
            s->data=x;
            s->next=p->next;
            s->prev=p;
            p->next=s;
            length++;
            if (s->next==nullptr)
                tail=s;
            break;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
}

template <typename T>
T myLinkedList<T>::Delete(int i)//delete after absPOS(i)
{
    Node<T>* p=first->next;
    int pos=1;
    while (p!=nullptr)
    {
        if (pos==i)
        {
            Node<T>* s=p->next;
            p->next=s->next;
            s->next->prev=p;
            if (p->next==nullptr)
                tail=p;
            T temp=s->data;
            delete s;
            length--;
            return temp;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
}

template <typename T>
Node<T>* myLinkedList<T>::GetX(int pos)//get absPOS
{
    if ((pos>=1)&&(pos<=length))
    {
        Node<T>* p=first->next;
        int cnt=1;//absPOS
        //int cnt=0;//binPOS
        while (p!=nullptr)
        {
            if (cnt==pos)
            {
                return p;
            }
            else
            {
                p=p->next;
                cnt++;
            }
        }
    }
	else
	{
		return nullptr;
	}
}

template <typename T>
void myLinkedList<T>::InsertX(int i,T x)//insert after absPOS(i)
{
    Node<T>* p=GetX(i);
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=p->next;
    p->next=s;
    s->prev=p;
    length++;
    if (s->next==nullptr)
        tail=s;
}

template <typename T>
T myLinkedList<T>::DeleteX(int i)//delete after absPOS(i)
{
    Node<T>* p=GetX(i);
    Node<T>* s=p->next;
    p->next=s->next;
    s->next->prev=p;
    if (p->next==nullptr)
        tail=p;
    T temp=s->data;
    delete s;
    length--;
    return temp;
}

template <typename T>
T myLinkedList<T>::PopFront()
{
    Node<T>* s=first->next;
    T temp=s->data;
    first->next=s->next;
    if (first->next==nullptr)
        tail=first;
    else
        s->next->prev=first;//ERROR
    delete s;
    length--;
    return temp;
}

template <typename T>
void myLinkedList<T>::PushFront(T x)
{
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=first->next;
    if (first->next!=nullptr)
        s->next->prev=s;//ERROR
    if (s->next==nullptr)
        tail=s;
    first->next=s;
    length++;
}

template <typename T>
void myLinkedList<T>::Reverse()
{
    myLinkedList<T> temp(*this);
    Clear();
    while (!temp.isEmpty())
    {
        PushFront(temp.PopFront());
    }
}

template <typename T>
void myLinkedList<T>::Clear()
{
    while (!isEmpty())
    {
        PopFront();
    }
    tail=first;
}

template <typename T>
void myLinkedList<T>::PushBack(T x)
{
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=tail->next;
    s->prev=tail;
    tail->next=s;
    tail=s;
    length++;
}

template <typename T>
T myLinkedList<T>::PopBack()
{
    Node<T>* p=tail->prev;
    Node<T>* s=tail;
    T temp=s->data;
    p->next=s->next;

    s->prev=nullptr;
    tail=p;
    delete s;
    length--;
    return temp;
}

template <typename T>
Node<T>* myLinkedList<T>::GetMiddleNode()
{
    Node<T>* p=first->next;
    Node<T>* q=first->next;
//    while (p!=nullptr)
//    {
//        p=p->next->next;
//        q=q->next;
//    }
    while (true)
    {
        if ((p==nullptr)||(p->next==nullptr))
            break;
        else
        {
            p=p->next->next;
            q=q->next;
        }
    }
    return q;
}

template <typename T>
int myLinkedList<T>::Test()
{
    first->data=114514;
    int hahaha=first->data;
    return hahaha;
}

int main()
{
//    cout<<"根据数组初始化新链表myList："<<endl;
    cout<<"new myList:"<<endl;
    int arr[N]={1,2,3,4,5};
    myLinkedList<int> myList(arr,N);
    myList.PopBack();
	myList.PrintList();

	Node<int>* ansptr=myList.GetMiddleNode();
	cout<<ansptr->data;

    //cout<<"<Done.";
    return 0;
}

用单链表 (v1.4.4) 实现“链表的冒泡排序”

//myLinkedList(TailInsert) v1.4.4 链表的冒泡排序 Swap()
// #define TT template <typename T>
// #define mll myLinkedList
#define N 5
//#define nullptr NULL
#include <iostream>
#include <algorithm>
using namespace std;

template <typename T>
struct Node
{
    T data;
    Node<T>* next;
    Node<T>* prev;
};

template <typename T>
class myLinkedList
{
public:
    myLinkedList();
    myLinkedList(T a[],int n);
    myLinkedList(const myLinkedList<T> & imyLinkedList);
	~myLinkedList();

    int Length();
    bool isEmpty();
    void PrintList();
    T Get(int pos);
    int Locate(T x);

    void Insert(int i,T x);
    T Delete(int i);

    void InsertX(int i,T x);
    T DeleteX(int i);

    T PopFront();
    void PushFront(T x);
    void Reverse();
    void Clear();
    void PushBack(T x);
    T PopBack();

    void Swap(Node<T>* p,Node<T>* q);
    bool Compare(Node<T>* p,Node<T>* q);
    void BubbleSort();

    int Test();
private:
    Node<T>* first;
    Node<T>* tail;
    int length;
    Node<T>* GetX(int pos);
};

template <typename T>
myLinkedList<T>::myLinkedList()
{
    first=new Node<T>;
    first->next=nullptr;
    first->prev=nullptr;
    length=0;
    tail=first;
}

template <typename T>
myLinkedList<T>::myLinkedList(T a[],int n)
{
    first=new Node<T>;
    first->next=nullptr;
    first->prev=nullptr;
    length=0;
	Node<T>* p=first;
    for (int i=0;i<n;i++)
    {
        Node<T>* s=new Node<T>;
		p->next=s;
		s->prev=p;
        s->next=nullptr;
        s->data=a[i];
		p=p->next;
        length++;
    }
    tail=p;
}

template <typename T>
myLinkedList<T>::myLinkedList(const myLinkedList<T> & imyLinkedList)
{
    first=new Node<T>;
    first->next=nullptr;
    length=imyLinkedList.length;
	Node<T>* p=first;
	Node<T>* ip=imyLinkedList.first->next;

	for (int i=0;i<length;i++)
    {
        Node<T>* s=new Node<T>;
        s->data=ip->data;
        s->next=nullptr;
        s->prev=p;
		p->next=s;
		p=p->next;
		ip=ip->next;
    }
    tail=p;
}

template <typename T>
myLinkedList<T>::~myLinkedList()
{
	while(first->next!=nullptr)
	{
		Node<T>* q=first->next;
		first->next=q->next;
		delete q;
	}
	delete first;
//	delete tail;
}

template <typename T>
int myLinkedList<T>::Length()
{
    return length;
}

template <typename T>
bool myLinkedList<T>::isEmpty()
{
    if (length==0)
        return true;
    else
        return false;
}

template <typename T>
void myLinkedList<T>::PrintList()
{
    Node<T>* p=first->next;
    while (p!=nullptr)
    {
        cout<<p->data<<' ';
        p=p->next;
    }
    cout<<endl;
}

template <typename T>
T myLinkedList<T>::Get(int pos)
{
    if ((pos>=1)&&(pos<=length))
    {
        Node<T>* p=first->next;
        int cnt=1;//absPOS
        //int cnt=0;//binPOS
        while (p!=nullptr)
        {
            if (cnt==pos)
            {
                break;
            }
            else
            {
                p=p->next;
                cnt++;
            }
        }
        return p->data;
    }
    else
    {
        return -1;
    }
}

template <typename T>
int myLinkedList<T>::Locate(T x)
{
    Node<T>* p=first->next;
    int pos=1;//absPOS
    while (p!=nullptr)
    {
        if (x==p->data)
        {
            return pos;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
    return -1;
}

template <typename T>
void myLinkedList<T>::Insert(int i,T x)//insert after absPOS(i)
{
    Node<T>* p=first->next;
    int pos=1;
    while (p!=nullptr)
    {
        if (pos==i)
        {
            Node<T>* s=new Node<T>;
            s->data=x;
            s->next=p->next;
            s->prev=p;
            p->next=s;
            length++;
            if (s->next==nullptr)
                tail=s;
            break;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
}

template <typename T>
T myLinkedList<T>::Delete(int i)//delete after absPOS(i)
{
    Node<T>* p=first->next;
    int pos=1;
    while (p!=nullptr)
    {
        if (pos==i)
        {
            Node<T>* s=p->next;
            p->next=s->next;
            s->next->prev=p;
            if (p->next==nullptr)
                tail=p;
            T temp=s->data;
            delete s;
            length--;
            return temp;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
}

template <typename T>
Node<T>* myLinkedList<T>::GetX(int pos)//get absPOS
{
    if ((pos>=1)&&(pos<=length))
    {
        Node<T>* p=first->next;
        int cnt=1;//absPOS
        //int cnt=0;//binPOS
        while (p!=nullptr)
        {
            if (cnt==pos)
            {
                return p;
            }
            else
            {
                p=p->next;
                cnt++;
            }
        }
    }
	else
	{
		return nullptr;
	}
}

template <typename T>
void myLinkedList<T>::InsertX(int i,T x)//insert after absPOS(i)
{
    Node<T>* p=GetX(i);
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=p->next;
    p->next=s;
    s->prev=p;
    length++;
    if (s->next==nullptr)
        tail=s;
}

template <typename T>
T myLinkedList<T>::DeleteX(int i)//delete after absPOS(i)
{
    Node<T>* p=GetX(i);
    Node<T>* s=p->next;
    p->next=s->next;
    s->next->prev=p;
    if (p->next==nullptr)
        tail=p;
    T temp=s->data;
    delete s;
    length--;
    return temp;
}

template <typename T>
T myLinkedList<T>::PopFront()
{
    Node<T>* s=first->next;
    T temp=s->data;
    first->next=s->next;
    if (first->next==nullptr)
        tail=first;
    else
        s->next->prev=first;//ERROR
    delete s;
    length--;
    return temp;
}

template <typename T>
void myLinkedList<T>::PushFront(T x)
{
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=first->next;
    if (first->next!=nullptr)
        s->next->prev=s;//ERROR
    if (s->next==nullptr)
        tail=s;
    first->next=s;
    length++;
}

template <typename T>
void myLinkedList<T>::Reverse()
{
    myLinkedList<T> temp(*this);
    Clear();
    while (!temp.isEmpty())
    {
        PushFront(temp.PopFront());
    }
}

template <typename T>
void myLinkedList<T>::Clear()
{
    while (!isEmpty())
    {
        PopFront();
    }
    tail=first;
}

template <typename T>
void myLinkedList<T>::PushBack(T x)
{
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=tail->next;
    s->prev=tail;
    tail->next=s;
    tail=s;
    length++;
}

template <typename T>
T myLinkedList<T>::PopBack()
{
    Node<T>* p=tail->prev;
    Node<T>* s=tail;
    T temp=s->data;
    p->next=s->next;

    s->prev=nullptr;
    tail=p;
    delete s;
    length--;
    return temp;
}

template <typename T>
void myLinkedList<T>::Swap(Node<T>* p,Node<T>* q)
{
    T temp=p->data;
    p->data=q->data;
    q->data=temp;
}

template <typename T>
bool myLinkedList<T>::Compare(Node<T>* p,Node<T>* q)
{
    if ((p->data)>(q->data))
        return true;
    else
        return false;
}

template <typename T>
void myLinkedList<T>::BubbleSort()
{
    Node<T>* BBack=first;
    while (BBack->next!=nullptr)
    {
        BBack=BBack->next;
    }

    while (BBack!=first->next)
    {
        Node<T>* p=first->next;
        while (p->next!=BBack)
        {
            if (Compare(p,p->next))
                Swap(p,p->next);
            p=p->next;
        }
        if (Compare(p,p->next))
            Swap(p,p->next);
        BBack=p;
    }
}

template <typename T>
int myLinkedList<T>::Test()
{
    first->data=114514;
    int hahaha=first->data;
    return hahaha;
}

int main()
{
//    cout<<"根据数组初始化新链表myList："<<endl;
    cout<<"new myList:"<<endl;
    int arr[N]={5,4,3,2,1};
    myLinkedList<int> myList(arr,N);
    myList.PrintList();
    myList.BubbleSort();
    myList.PrintList();

    //cout<<"<Done.";
    return 0;
}

用循环(双)链表 (v1.4.5) 完成约瑟夫环问题的解决；

//myLinkedList(TailInsert) v1.4.5 约瑟夫环 lab3_3
// #define TT template <typename T>
// #define mll myLinkedList
#define N 6
#define MAXN 110
#define nullptr NULL
#include <iostream>
#include <algorithm>
using namespace std;

template <typename T>
struct Node
{
    T data;
    Node<T>* next;
    Node<T>* prev;
};

template <typename T>
class myLinkedList
{
public:
    myLinkedList();
    myLinkedList(T a[],int n);
    myLinkedList(const myLinkedList<T> & imyLinkedList);
	~myLinkedList();

    int Length();
    bool isEmpty();
    void PrintList();
    T Get(int pos);
    int Locate(T x);

    void Insert(int i,T x);
    T Delete(int i);

    void InsertX(int i,T x);
    T DeleteX(int i);

    T PopFront();
    void PushFront(T x);
    void Reverse();
    void Clear();
    void PushBack(T x);
    T PopBack();

    int Test();
//private:
public:
    Node<T>* first;
    Node<T>* tail;
    int length;
    Node<T>* GetX(int pos);
};

template <typename T>
myLinkedList<T>::myLinkedList()
{
    first=new Node<T>;
    tail=first;
    first->next=tail;
    first->prev=tail;
    length=0;
}

template <typename T>
myLinkedList<T>::myLinkedList(T a[],int n)
{
    first=new Node<T>;
    first->next=nullptr;
    first->prev=nullptr;
    length=0;
	Node<T>* p=first;
    for (int i=0;i<n;i++)
    {
        Node<T>* s=new Node<T>;
		p->next=s;
		s->prev=p;
        s->next=nullptr;
        s->data=a[i];
		p=p->next;
        length++;
    }
    tail=p;

    tail->next=first;
    first->prev=tail;
}

template <typename T>
myLinkedList<T>::myLinkedList(const myLinkedList<T> & imyLinkedList)
{
    first=new Node<T>;
    first->next=nullptr;
    length=imyLinkedList.length;
	Node<T>* p=first;
	Node<T>* ip=imyLinkedList.first->next;

	for (int i=0;i<length;i++)
    {
        Node<T>* s=new Node<T>;
        s->data=ip->data;
        s->next=nullptr;
        s->prev=p;
		p->next=s;
		p=p->next;
		ip=ip->next;
    }
    tail=p;

    tail->next=first;
    first->prev=tail;
}

template <typename T>
myLinkedList<T>::~myLinkedList()
{
//	while(first->next!=nullptr)
	while(first->next!=first)
	{
		Node<T>* q=first->next;
		first->next=q->next;
		delete q;
	}
	delete first;
//	delete tail;
}

template <typename T>
int myLinkedList<T>::Length()
{
    return length;
}

template <typename T>
bool myLinkedList<T>::isEmpty()
{
    if (length==0)
        return true;
    else
        return false;
}

template <typename T>
void myLinkedList<T>::PrintList()
{
    Node<T>* p=first->next;
//    while (p!=nullptr)
    while (p!=first)
    {
        cout<<p->data<<' ';
        p=p->next;
    }
    cout<<endl;
}

template <typename T>
T myLinkedList<T>::Get(int pos)
{
    if ((pos>=1)&&(pos<=length))
    {
        Node<T>* p=first->next;
        int cnt=1;//absPOS
        //int cnt=0;//binPOS
//        while (p!=nullptr)
        while (p!=first)
        {
            if (cnt==pos)
            {
                break;
            }
            else
            {
                p=p->next;
                cnt++;
            }
        }
        return p->data;
    }
    else
    {
        return -1;
    }
}

template <typename T>
int myLinkedList<T>::Locate(T x)
{
    Node<T>* p=first->next;
    int pos=1;//absPOS
//    while (p!=nullptr)
    while (p!=first)
    {
        if (x==p->data)
        {
            return pos;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
    return -1;
}

template <typename T>
void myLinkedList<T>::Insert(int i,T x)//insert after absPOS(i)
{
    Node<T>* p=first->next;
    int pos=1;
//    while (p!=nullptr)
    while (p!=first)
    {
        if (pos==i)
        {
            Node<T>* s=new Node<T>;
            s->data=x;
            s->next=p->next;
            s->prev=p;
            p->next=s;

            s->next->prev=s;
            length++;
//            if (s->next==nullptr)
//                tail=s;
            if (s->next==first)
            {
                tail=s;
                first->prev=tail;
            }

            break;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
}

template <typename T>
T myLinkedList<T>::Delete(int i)//delete after absPOS(i)
{
    Node<T>* p=first->next;
    int pos=1;
//    while (p!=nullptr)
    while (p!=first)
    {
        if (pos==i)
        {
            Node<T>* s=p->next;
            p->next=s->next;
            s->next->prev=p;
//            if (p->next==nullptr)
//                tail=p;
            if (p->next==first)
            {
                tail=p;
                first->prev=tail;
            }
            T temp=s->data;
            delete s;
            length--;
            return temp;
        }
        else
        {
            pos++;
            p=p->next;
        }
    }
}

template <typename T>
Node<T>* myLinkedList<T>::GetX(int pos)//get absPOS
{
    if ((pos>=1)&&(pos<=length))
    {
        Node<T>* p=first->next;
        int cnt=1;//absPOS
        //int cnt=0;//binPOS
//        while (p!=nullptr)
        while (p!=first)
        {
            if (cnt==pos)
            {
                return p;
            }
            else
            {
                p=p->next;
                cnt++;
            }
        }
    }
	else
	{
		return nullptr;
	}
}

template <typename T>
void myLinkedList<T>::InsertX(int i,T x)//insert after absPOS(i)
{
    Node<T>* p=GetX(i);
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=p->next;
    p->next=s;
    s->prev=p;
    length++;
    if (s->next==nullptr)
    {
        tail=s;
        first->prev=tail;
    }
}

template <typename T>
T myLinkedList<T>::DeleteX(int i)//delete after absPOS(i)
{
    Node<T>* p=GetX(i);
    Node<T>* s=p->next;
    p->next=s->next;
    s->next->prev=p;
//    if (p->next==nullptr)
//        tail=p;
    if (p->next==first)
    {
        tail=p;
        first->prev=tail;
    }
    T temp=s->data;
    delete s;
    length--;
    return temp;
}

template <typename T>
T myLinkedList<T>::PopFront()
{
    Node<T>* s=first->next;
    T temp=s->data;
    first->next=s->next;
//    if (first->next==nullptr)
//        tail=first;
    if (first->next==first)
    {
        tail=first;
        first->prev=tail;
    }
    else
        s->next->prev=first;//ERROR
    delete s;
    length--;
    return temp;
}

template <typename T>
void myLinkedList<T>::PushFront(T x)
{
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=first->next;
    if (first->next!=nullptr)
        s->next->prev=s;//ERROR
//    if (s->next==nullptr)
//        tail=s;
    if (s->next==first)
    {
        tail=s;
        first->prev=tail;
    }
    first->next=s;
    length++;
}

template <typename T>
void myLinkedList<T>::Reverse()
{
    myLinkedList<T> temp(*this);
    Clear();
    while (!temp.isEmpty())
    {
        PushFront(temp.PopFront());
    }
}

template <typename T>
void myLinkedList<T>::Clear()
{
    while (!isEmpty())
    {
        PopFront();
    }
    tail=first;

    tail->next=first;
    first->prev=tail;
}

template <typename T>
void myLinkedList<T>::PushBack(T x)
{
    Node<T>* s=new Node<T>;
    s->data=x;
    s->next=tail->next;
    s->prev=tail;
    tail->next=s;
    tail=s;
    length++;

    first->prev=tail;
}

template <typename T>
T myLinkedList<T>::PopBack()
{
    Node<T>* p=tail->prev;
    Node<T>* s=tail;
    T temp=s->data;
    p->next=s->next;

    //s->prev=nullptr;//No need to
    tail=p;
    delete s;
    length--;

    first->prev=tail;
    return temp;
}

template <typename T>
int myLinkedList<T>::Test()
{
    first->data=114514;
    int hahaha=first->data;
    return hahaha;
}

int main()
{
//    int arr[N]={1,2,3,4,5,6},m=3;
    int arr[MAXN],n=0,m=0;
    cout<<"How many soliders?"<<endl;
    cin>>n;
    cout<<"What are their codes?"<<endl;
    for (int i=0;i<n;i++)
    {
        cin>>arr[i];
    }
    myLinkedList<int> myl(arr,N);
    cout<<"They are:"<<endl;
    myl.PrintList();
    cout<<"What is the command?"<<endl;
    cin>>m;

    cout<<"The killing list:"<<endl;
    Node<int>* ptr=myl.first;
    Node<int>* ptrX=ptr;
    for (int i=0;i<N;i++)
    {
        for (int j=0;j<m;j++)
        {
            ptrX=ptr;
            ptr=ptr->next;
            if (ptr==myl.first)
                ptr=ptr->next;
        }
        int temp=ptr->data;
        ptrX->next=ptr->next;
        cout<<temp<<' ';
//        delete ptr;
    }
    return 0;
}

(全文完)

TommyBay
关注
C++ ——自己手写的一个简单的单向链表
幕子哥的万事屋
05-20 417
#include<bits/stdc++.h> using namespace std; template<class T> class List; //提前声明配合友元类 template<class T> class Node{ friend class List<T>;//友元类，方便表头操作节点私有成员 T data; //数据域 Node<T>*next; //指针域，下一个元素的地址 public:
LRU算法 C++实现（HashMap+双向链表）
weixin_45590210的博客
01-22 834
leetcode上测试代码的题目 LRU（最近最少使用算法），是缺页置换解决方法中的一种。时间复杂度优秀O（1），空间复杂度不算哈希表本身的消耗的话还会多出维护双向链表左右指针的2N大小的空间消耗。 具体实现方法就是在原有数据结构（一般是哈希表）的基础上套上一个双向链表。当操作（询问，修改，增加）某个链表中某个元素的时候把这个元素移动到链表头上。当缓存区满了的时候去掉链表尾上的那个元素即可。 代码实现（HashSet和双向链表都是自实现的）： class LRUCache { public: sta
c++手写链表
weixin_50547586的博客
11-18 597
c++手写链表 这个手写链表主要围绕紫书（刘汝佳著）上破损的键盘的题解进行讲解。 破损的键盘代码： #include<iostream> #include<cstdio> #include<string> #include<cstring> using namespace std; char s[100000+5]; int next[100000+5]; int now=last=0; int main() { while(scanf("%s",s+1)
【原】手写链表（C++）
diaopi5937的博客
12-08 357
1、链表基本概念以及注意事项 a、构造函数与析构函数 b、插入 c、重载运算符[] 2、打印链表 3、删除链表节点 4、链表中倒数第k个节点 5、反转链表 6、合并两个排序的链表 7、两个链表当中的第一个公共节点 【查看之前笔记】 在编写函数之前，请务必注意以下三点： i、输入的指针、各类容器可能是空的 ii、输入的...
手写实现单向链表 [ C++ ]
Slamer杨的博客
04-21 1097
#include <iostream> using namespace std; template<typename Type> class Node { public: Type date_; Node<Type>* next_; Node(const Type& date) :date_(date), next_(nullptr) {}; }; template<typename Type> class LinkedList { pr.
C++程序设计——手写链表（链表创建遍历与删除结点的相关源代码）
Mr_Fmnwon的博客
12-01 1629
一些手写链表的初阶程序源代码：一、链表的建立与访问二、链表添加与遍历三、 链表-正负值判断四、单向链表删除重复节点五、删除所有数据为e的元素
c++ 手写map链表类
05-19
以下是一个简单的基于链表实现的手写Map类示例，你可以参考一下： ```c++ #include #include using namespace std; template , typename ValueType> class Map { private: struct Node { KeyType key; Value...
C++手写简单STL(数组模拟实现STL)
处_的博客
04-14 889
C++手写STL库(通过数组模拟实现)，包括单链表、双链表、栈与队列、单调栈、单调队列、KMP、Trie、堆(大根堆、小根堆)、哈希表
（刷题学习）C++从翻转链表到k个一组翻转链表
weixin_51334923的博客
10-25 555
从翻转链表到k个一组翻转链表
手写链表C++
最新发布
整理ing
11-11 1340
c++ 手写链表
C++实现的一个简单链表
05-20
单链表的实现。以前都是用C语言实现的，今天用C++练一练手，做出来了。
手写简单单链表实现功能
03-31
手动实现简单单链表实现，有助于学习数据结构之单链表。其中实现的功能有增删改查功能。单链表的优点是插入删除效率高。但不支持随机查找，查找效率低。
手写邻接表
12-21
模拟指针链表的写法，操作速度比map 要快很多，而且写起来很好看。不理解的话，用手在纸上写写画画就明白了。
C++ 手写链表
远方
03-12 1313
很不错 https://www.cnblogs.com/winslam/p/10089004.html
c++链表(随手写的)
wayaoqiang的专栏
12-08 519
#include #include using namespace std; class CData { private:     int i;     string name;     CData *next; public:     CData():next(NULL), i(0){}     string getName(){ return this->name
《C++数据结构-快速拾遗》 手写链表
weixin_33845477的博客
01-14 100
注释：吕鑫老师C++对于找工作真的是很好的教程，基本什么方面都讲的很细致，但是对于大多数人只有快进快进再快进~~ 注释：基本链表信息自己百度，这里只是一个快速拾遗过程。 1.链表定义 1 typedef int DATA;//int的别名，为了便于管理 2 3 //定义链表一个链节点 4 typedef struct SNode 5 { 6 DATA dat...
在 O(1) 时间内删除链表节点、 删除链表中的重复的节点、正则表达式匹配
sunjiac的博客
09-09 279
在 O(1) 时间内删除链表节点 思路： 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 O(1)。 否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向 null，时间复杂度为 O(N)。 综上，如果进行 N 次操作，那么大约需要操作节点的次数为 N-1+N=2N-1，其中 N-1 表示 N-1 个不是尾节点的每个节点以 O(1) 的时间复杂度操作节点的总次数，N 表示 1 个尾节点以 O(N) 的时间复杂
C++ 手写链表数据结构
weixin_40480299的博客
10-30 93
c++ 学习
数据结构学习之——（c/c++实现）手写单链表（删除、插入、查找、建表）
dustnn的博客
02-15 750
在家整理了一下数据结构方面的知识，想自己动手实现一个单链表。主要实现操作有： 通过尾插法建立单链表 通过匹配的值开查找链表中的元素 通过序列来去链表中的元素 插入元素（前插、后插） 删除元素 遍历显示 下面就是代码了：首先是主函数 main.cpp #include <iostream> #include"lklist.h" using namespace std; int ma...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值