C++ 模板类链表迭代器与list.h迭代器基本介绍

C++ 模板类链表迭代器与迭代器基本介绍
本程序基于本博客C++模板类链表基础上实现
主程序 main.cpp

//Written by Xuebi
//本程序使用模板类创建链表，并实现添加数据，删除数据，反转链表，连接链表功能
//本程序在实现以上功能的前提下，一方面介绍了系统自带的list类，并演示了基本操作，另一方面，在上篇博客的基础上增加了自己设计的迭代器。
//系统的迭代器和额外编写的迭代器使得能对连边里面的数据进行具体的操作，值得注意的是，系统自带的list类功能当然更加完善
#include 
#include "List.h"
#include 
using namespace std;
int main()
{
    cout<<"The first part is the List class saved in the system: ";
    std:list ListSystem;
    ListSystem.push_front(10);//往链头输入数据interger 10
    ListSystem.push_front(20);//往链头输入数据interger 20
    ListSystem.push_front(30);//往链头输入数据interger 30
    ListSystem.push_front(40);//往链头输入数据interger 40
    ListSystem.push_back(0);//往链尾输入数据interger 0
    std::list::iterator i=ListSystem.begin();//讲链表开头的地址赋值与迭代器 i
    cout<<*i;
    i++;
    while(i!=(ListSystem.end()))
    {
        cout<<"->";
        cout<<*i;
        ++i;
    }
    cout< st;
    st.Insert(10);
    st.Insert(20);
    st.Insert(30);
    st.Insert(40);
    st.show();//40->30->20->10
    st.Invert();
    st.show();//10->20->30->40;
    List st1;
    st1.Insert(50);
    st1.Insert(60);
    st1.Insert(70);
    st1.Insert(80);
    st1.show();//80->70->60->50
    st1.Invert();
    st1.show();//50->60->70->80
    st.Connect(st1);
    st.show();//10->20->30->40->50->60->70->80
    st.Delete(60);
    st.show();//10->20->30->40->50->70->80
    cout<<"This is my iterator:"< Iterator_st(st);
    cout<<"The data in the first Node in st: "<<*Iterator_st.First()<";
            cout<<*Iterator_st.Next();//试试改成：cout<<10*(*Iterator_st.Next());
        }
    }
    else
    {
        return 0;
    }
    return 0;
}

头文件 List.h

#ifndef LIST_H
#define LIST_H
#include 
template class List;//声明List，方便ListNode声明为友元函数
template class Iterator;
template
class ListNode//链表节点
{
friend class Iterator;//友元函数
friend class List;//友元函数，List可以访问ListNode的私有成员 反思声明友元函数friend class List会报错
private:
    T data;//数据域
    ListNode*p;//ListNode类型指针
    ListNode(T element);//构造函数
};
template
class List
{
friend class Iterator;
private:
    ListNode*first;//List私有成员只有链表的头部
public:
    List();
    void Insert(T element);
    void Delete(T element);
    void Invert();
    void show();
    void Connect(List L);
};
template
class Iterator//新增加迭代器，
{
private:
    const List&Li_st;//引用传入一个List类
    ListNode*current;//当前的指向的ListNode
public:
    Iterator(const List&I):Li_st(I),current(I.first){};
    bool IfNonNull();//判断当前Node是不是空（空指针）
    bool IfNextNonNull();//判断下一个Node是不是空（指针
    T*First();//返回Li_st的一个节点的data的指针
    T*Next();//将指针沿着链表下移，然后返回相应的data的指针
};
template
List::List()//初始化链表时，为空链表
{
    first=0;
}
template
ListNode::ListNode(T element)
{
    data=element;
    p=0;
}
template
void List::Insert(T element)
{
    ListNode*A=new ListNode(element);//动态创建一个ListNode类型指针A
    A->p=first;//A指向的ListNode类里面的指针指向first，first目前仍是空指针
    first=A;//现在first
}
template
void List::show()
{
    ListNode*A;
    A=first;
    if(!first)
    {
        std::cout<<"This chaine is void!,cannot show()! "<p)
        {
            std::cout<data;
            if(A->p)
            {
                std::cout<<" -> ";
            }
        }
        std::cout<
void List::Delete(T element)
{
    if(!first)
    {
        std::cout<<"This chaine is void!,cannot Delete()! "<*current=first;
        ListNode*previous=0;
        for(current;current&&((current->data)!=element);previous=current,current=current->p)
        {
            ;
        }
        if(current)
        {
            if(previous)
            {
                previous->p=current->p;
            }
            else
            {
                first=first->p;
            }
            delete current;
        }
    }
}
template 
void List::Invert()//链表真是艺术！！！！本函数用于倒转链表
{
    ListNode*A=first;//A指针用于向下搜索
    first=0;
    while(A)
    {
        ListNode*FIRST=first;
        ListNode*B=A;//N用来暂时记录A
        A=A->p;
        B->p=FIRST;
        first=B;
    }
}
template 
void List::Connect(List L)//连接两链表
{
    if(!first)//如果本链表为空，则L链表直接接在first后面
    {
        first=L.first;
    }
    else
    {
        ListNode*A=first;
        for(A;A->p;A=A->p)//本链表非空，向下搜索，查找最后的ListNode
        {
            ;
        }
        A->p=L.first;
    }
}
template 
bool Iterator::IfNonNull()
{
    if(current)
        return 1;
    else return 0;
}
template 
bool Iterator::IfNextNonNull()
{
    if(current->p)
        return 1;
    else
        return 0;
}
template 
T*Iterator::First()
{
    if(Li_st.first)
        return &Li_st.first->data;//返回的是第一个节点的data的地址
    else
     std::cout<<"No first data in this list"<
T*Iterator::Next()
{
    if(IfNextNonNull())
    {
        current=current->p;
        return ¤t->data;
    }
    else
        std::cout<<"Next Node is NULL"<

本程序仅供学习参考之用，如若转载，请注明出处。
如果你对本程序感到满意，可点击关注本博客！！