深入浅出数据结构实现-链表(Linked_list)

视频出现的都手动实现了，只多不少，仅供参考 

视频地址

【强烈推荐】深入浅出数据结构 - 顶尖程序员图文讲解 - UP主翻译校对 (已完结) 

---

单向链表 

//
// Created by 86151 on 2024/7/22.
//

#ifndef DATA_STRUCTURE_DS_CPP
#define DATA_STRUCTURE_DS_CPP
#include "iostream"
#include "memory"
using namespace std;


struct Node{//自己实现链表类
    int data;//节点存放的数据
    shared_ptr<Node> next;//节点存放的下个节点的地址
};
shared_ptr<Node> pop_front(shared_ptr<Node>& head,int x)//插入链表头部
{

    shared_ptr<Node> temp= make_shared<Node>();//智能指针捆绑新建节点
    temp->data=x;
    temp->next=head;//让自己的next指针指向下一个元素
    head=temp;//让上一个指针指向自己
    return head;//重置头指针

}
shared_ptr<Node> pop_back(shared_ptr<Node>& head,int x)//尾插
{
    shared_ptr<Node> temp_2 = make_shared<Node>();
    temp_2->data=x;
    if(head== nullptr)
    {
        temp_2->next=head;//让自己的next指针指向null
        head=temp_2;//让头指针指向自己
        return head;//重置头指针
    }
    shared_ptr<Node> temp_1=head;
    while(temp_1->next!= nullptr)
    {
        temp_1=temp_1->next;//找到最后一个节点
    }
    temp_2->next=temp_1->next;
    temp_1->next=temp_2;
    return head;
}
void reverseNode_2(shared_ptr<Node> current,shared_ptr<Node>& head)//递归逆序
{
    if (current->next == nullptr)//递归结束条件，到达尾部，让head指向尾部节点
    {
        head=current;
        return ;
    }
    reverseNode_2(current->next,head);
    auto cur_next=current->next;//下一个节点的next指向本节点
    cur_next->next=current;
    current->next= nullptr;
}

void reverseNode(shared_ptr<Node>& head)//循环实现反转
{
    shared_ptr<Node> current,prev,next;//分别对应前，当前，和下个节点
    current=head;//标记当前节点指针初始化
    prev = nullptr;//前节点指针初始化
    while (current!= nullptr)//条件 此时到链表尾部,循环结束,current指向null
    {
        next=current->next;//next指针赋值
        current->next=prev;//让当前节点指向前一个节点（反转核心思想)
        prev=current;//前节点后移
        current=next;//当前节点后移,为下一次循环做准备

    }
    head=prev;//反转结束，此时prev指向正序时最后一个节点，让head指向prev，即反转后的头部

}
shared_ptr<Node> insert(shared_ptr<Node>& head,int insert_data,int insert_pos){
    //4 2 3 1-》4 5 2 3 1 5插入到第二个的位置，实际上是[2-1]，所以插入到n-1位置
    //考虑特殊情况,首先是两端，插入尾部时不影响，插入头部时
    shared_ptr<Node> temp_2= make_shared<Node>();//创建指针捆绑新建节点
    temp_2->data=insert_data;//插入节点赋值
    if(insert_pos==1)
    {
        temp_2->next=head;//头指针指向下个元素的指针赋值给该节点(如果是null同样也为null)
        head=temp_2;//头指针重置
        return head;
    }
    //否则，如果要插入中间，必须找到上一个节点，由于链表的特殊性，只能遍历寻找[n-1-1]节点的位置
    shared_ptr<Node> temp_1= head;
    for(int i=0;i<insert_pos-2;i++)
    {
        temp_1=temp_1->next;//找到pos-1处节点
    }
    temp_2->next=temp_1->next;
    temp_1->next=temp_2;
    return head;
}
shared_ptr<Node> Delete_pos(shared_ptr<Node>& head,int insert_pos)//位置删除
{
    //找位置->删除
    shared_ptr<Node> temp_1=head;
    if(insert_pos==1)
    {
        head=head->next;
        return head;
    }
    for(int i=0;i<insert_pos-2;i++)
    {
        temp_1=temp_1->next;//要删除的上一个节点
    }
    shared_ptr<Node> temp_2=temp_1->next;//要删除的节点
    temp_1->next=temp_2->next;

    return head;
}
void print_plus(shared_ptr<Node>(head))//递归输出链表
{
    if(head== nullptr)
    {
        cout<<endl;
        return;
    }
    cout<<head->data<<"  ";
    print_plus(head->next);
}
void print(shared_ptr<Node> head)//遍历输出链表
{
    while (head!= nullptr)
    {
        cout<<head->data<<"  ";
        head=head->next;
    }
    cout<<endl;
}
int main()
{

    shared_ptr<Node> head= nullptr;//头指针先置空
    int n;//要插入元素个数,插入元素个数
    cout<<"请输入要插入元素个数"<<endl;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cout<<"请输入第"<<i+1<<"个插入链表的元素"<<endl;
        int x;
        cin>>x;
        head=pop_back(head,x);

    }
    cout<<"插入完成，结果是"<<endl;
    print(head);

    reverseNode_2(head,head);
    print(head);
    return 0;
}
#endif //DATA_STRUCTURE_DS_CPP

双向链表

//
// Created by 86151 on 2024/7/27.
//
#include "iostream"
#include "memory"
using namespace std;
struct Node{
    explicit Node(int i) {
        data=i;
    }

    int data;
    shared_ptr<Node> prev;
    shared_ptr<Node> next;
};
void pop_back(shared_ptr<Node>& head,int x)
{
    shared_ptr<Node> newNode= make_shared<Node>(x);

    newNode->prev= nullptr;
    newNode->next= nullptr;
    if(head== nullptr)//如果链表内没有节点
    {
        head= newNode;
        return;
    }
    shared_ptr<Node> last=head;
    while(last->next!= nullptr)
    {
        last=last->next;//找到最后一个节点
    }
    newNode->next=last->next;
    last->next=newNode;
    newNode->prev=last;
}
void Print(shared_ptr<Node> head)
{
    while (head!= nullptr)
    {
        cout<<head->data<<" ";
        head=head->next;
    }
    cout<<endl;
}
void ReversePrint_recursive(const shared_ptr<Node>& head)//递归反向
{
    //假设head默认指向正向
    if(head==nullptr)
    {
        
        return;
    }
    ReversePrint_recursive(head->next);
    cout<<head->data<<" ";
}
void ReversePrint(const shared_ptr<Node>& head)//循环反向
{
    //假设head默认指向正向
    shared_ptr<Node> temp=head;
    while (temp->next!= nullptr)
    {
        temp=temp->next;//找到最后一节点
    }
    while (temp!= nullptr)
    {
        cout<<temp->data<<" ";
        temp=temp->prev;
    }
    cout<<endl;
}
int main()
{
    shared_ptr<Node> head= nullptr;//头指针初始化
    int n;//要插入元素个数,插入元素个数
    cout<<"请输入要插入元素个数"<<endl;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cout<<"请输入第"<<i+1<<"个插入链表的元素"<<endl;
        int x;
        cin>>x;
        pop_back(head,x);

    }
    cout<<"插入完成，结果是"<<endl;
    Print(head);
    ReversePrint(head);
    return 0;
}