链表以及链表的迭代器

List.h:

#pragma once 

template<class Type>
class List;

template<class Type>
class ListIterator;

//链表节点
template<class Type>
class ListNode
{
public:
    friend class List<Type>;
    friend class ListIterator<Type>;
private:
    Type data;
    ListNode *link;
    ListNode(Type);
};

template<class Type>
class List
{
    friend class ListIterator<Type>;
public:
    List();
    void Insert(Type);
    void Delete(Type);
    void Invert();
    void Concatenate(List<Type>);
    //void Show();//用于测试
private:
    ListNode<Type> *first;
};

template<class Type>
class ListIterator
{
public:
    ListIterator(const List<Type>& l) :list(l), current(l.first)
    {
    }
    //用来判断链表迭代器所指向的链表里的当前的节点是否为空
    bool NotNull();
    //用来判断当前节点的下一个节点是否为空
    bool NextNotNull();
    //指向链表的第一个节点，用来返回链表的第一个节点的指针
    Type* First();
    //返回当前节点的下一个节点的指针
    Type* Next();
private:
    //这个迭代器就是这个链表的迭代器
    const List<Type> &list;
    //指向链表中的一个节点(当前的节点）
    ListNode<Type>* current;

};

//用来判断链表迭代器所指向的链表里的当前的节点是否为空
template<class Type>
bool ListIterator<Type>::NotNull()
{
    if (current)
    {
        return true;
    }
    else
    {
        return false;
    }

}

//用来判断当前节点的下一个节点是否为空
template<class Type>
bool ListIterator<Type>::NextNotNull()
{
    if (current && current->link)
    {
        return true;
    }
    else
    {
        return false;
    }
}

//指向链表的第一个节点，用来返回链表的第一个节点的指针
template<class Type>
Type* ListIterator<Type>::First()
{
    if (list.first)
    {
        return &list.first->data;
    }
    else
    {
        return 0;
    }
}

//返回当前节点的下一个节点的指针
template<class Type>
Type* ListIterator<Type>::Next()
{
    if (current)//如果当前节点
    {
        current = current->link;
        return &current->data;
    }
    else
    {
        return 0;
    }
}

/
template<class Type>
ListNode<Type>::ListNode(Type element) :data(element)
{
    link = 0;
}

/
template<class Type>
List<Type>::List()
{
    first = 0;
}

template<class Type>
void List<Type>::Insert(Type k)
{
    ListNode<Type> *newnode = new ListNode<Type>(k);
    newnode->link = first;
    first = newnode;
}

//template<class Type>
//void List<Type>::Show()//用于测试
//{
//    for (ListNode<Type> *current = first; current; current = current->link)
//    {
//        std::cout << current->data;
//        if (current->link) std::cout << "->";
//
//    }
//    std::cout << std::endl;
//}

template<class Type>
void List<Type>::Delete(Type k)
{
    ListNode<Type> *previous = 0;//被删除的对象的前一个节点
    ListNode<Type> *current;//用来做循环
    for (current = first; 
        current && current->data != k; //循环条件：当前不是最后一个节点且当前节点data不等于要找的节点，则继续循环
        previous = current, current = current->link //步长，满足继续循环情况下，在增加步长之前，记录前一个节点
        )
    {
        //什么都不做，空循环。找到要被删除的节点
    }

    //如果找到了节点
    if (current)
    {
        if (previous)//如果要删除的节点不是第一个，则该节点有前一个
        {
            previous->link = current->link;//前一个的linK等于当前的下一个link
        }
        else
        {
            first = first->link; //如果要删除的节点是第一个，则将一个指向第一个的下一个
        }

        delete current;
    }
}

template<class Type>
void List<Type>::Invert()
{
    ListNode<Type> *p = first;//指向原始链表的开头
    ListNode<Type> *q = 0;//指向链表的结尾
    while (p)
    {
        ListNode<Type> *r = q;
        q = p;
        p = p->link;
        q->link = r;
    }
    first = q;
}

template<class Type>
void List<Type>::Concatenate(List<Type> b)
{
    if (!first) //如果第一个链表为空
    {
        first = b.first;
        return;
    }
    
    if (b.first)//如果第二个链表不为空，则找到第一个链表的结尾，然后把第二个链表头部接过来
    {
        ListNode<Type> *p;
        for (p = first; p->link; p = p->link)
        {
            //空循环，找到第一个链表的最后一个节点
        }

        p->link = b.first;
    }
}

 

Main.cpp:

#include <iostream>
#include "List.h"
#include <list>
using namespace std;

int main()
{
    List<int> intList;
    intList.Insert(5);
    intList.Insert(15);
    intList.Insert(25);
    intList.Insert(35);
    cout << "my iterator\n";
    ListIterator<int> li(intList);
    if (li.NotNull())//检查一下链表是否为空
    {
        cout << *li.First();
        while (li.NextNotNull())
        {
            cout << "->" << *li.Next();
        }
        cout << endl;
    }

    List<char> charList;
    charList.Insert('a');
    charList.Insert('b');
    charList.Insert('c');
    charList.Insert('d');
    //charList.Show();
    charList.Invert();
    //charList.Show();

    List<char> charList1;
    charList1.Insert('e');
    charList1.Insert('f');
    charList1.Invert();
    //charList1.Show();

    charList.Concatenate(charList1);
    //charList.Show();
    cout << "OK" << endl;

    //C++中的链表
    cout << "C++ iterator\n";
    list<int> listIntergers;
    listIntergers.push_front(5);
    listIntergers.push_front(15);
    listIntergers.push_front(25);
    listIntergers.push_front(35);

    list<int>::iterator iter = listIntergers.begin();
    
    while (iter != listIntergers.end())//listIntergers.end()为最后一个元素的下一个（可以认为是结束符）
    {
        cout << *iter << "->";
        iter++;

    }
    cout << endl;;
    return 0;
}