C++数据结构 单链表(模板类)

利用模板类实现单链表及其功能

需要实现的操作:

[1] push_back       [2] push_front

[3] show_list       [0] quit_system

[4] pop_back        [5] pop_front

[6] insert_val      [7] delete_val

[8] find            [9]length

[10] clear          [11]destroy

[12] reserv         [13]sort

头文件源代码:

#ifndef LIST_H_INCLUDED
#define LIST_H_INCLUDED

#include <iostream>
using namespace std;

template<class Type>
class List;

template<class Type>
class ListNode
{
	friend class List<Type>;
public:
	ListNode():data(Type()),next(NULL)
	{}
	ListNode(Type d, ListNode<Type> *n=NULL)
		:data(d),next(n)
	{}
	~ListNode()
	{}
public:
	void SetData(Type d)
	{data = d;}
	Type GetData()const
	{return data;}
private:
	Type data;
	ListNode<Type> *next;
};

template<class Type>
class List
{
public:
	List()
	{
		first = last = Buynode();
	}
	~List()
	{
	    List<Type>::destroy();
	}
public:
	void push_back(const Type &x);
	void push_front(const Type &x);
	void show_list()const;
	void pop_back();
	void pop_front();
	void insert_val(const Type &x);
	void delete_val(const Type &x);
	bool find(const Type &x);
	Type length();
	void clear();
	void destroy();                        //摧毁该顺序表
	void reserv();                         //反转
	void sort();
protected:
	ListNode<Type>* Buynode(Type x = Type())
	{
		ListNode<Type> *p = new ListNode<Type>(x);
		return p;
	}
private:
	ListNode<Type> *first;
	ListNode<Type> *last;
};

template<class Type>
void List<Type>::push_back(const Type &x)
{
    ListNode<Type> *s = Buynode(x);
    last->next = s;
    last = s;
    first->data++;
}

template<class Type>
void List<Type>::push_front(const Type &x)
{
    ListNode<Type> *s = Buynode(x);
    s->next=first->next ;
    first->next=s;
    if(first == last)
        last = s;
    first->data++;
}

template<class Type>
void List<Type>::show_list()const
{
    ListNode<Type> *p = first->next;
    while(p != NULL)
    {
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

template<class Type>
void List<Type>::pop_back()
{
    if(first->data == 0)
        return;
    ListNode<Type> *p = first;
    while(p->next != last)
        p = p->next;
    ListNode<Type> *q = p->next;
    p->next = NULL;
    last = p;
    delete q;
    first->data--;
}

template<class Type>
void List<Type>::pop_front()
{
    ListNode<Type> *p = first->next;
    first->next = p->next;
    p = NULL;
    delete p;
    if(first->data == 1)
        last = first;
    first->data--;
}

template<class Type>
void List<Type>::insert_val(const Type &x)
{
    ListNode<Type> *s =  Buynode(x);
    ListNode<Type> *p =  first->next;
    if(p->data > s->data)
    {
        push_front(s->data);
    }
    else if(first->data < s->data)
    {
        push_back(s->data);
    }
    else
        {
            while((p->data < x )&& (p->next->data<x))
            {
                p = p->next;
            }
            s->next=p->next ;
            p->next = s;
            first->data++;
        }
}

template<class Type>
void List<Type>::delete_val(const Type &x)
{
    ListNode<Type> *p = first->next;
    ListNode<Type> *s =  Buynode(x);
    if(x == p->data)
    {
        pop_front();
    }
    else
    {
         while((p->data != x) && (p->next->data != x))
        {
            p = p->next;
        }
        p->next = p->next->next;
        ListNode<Type> *q = p->next;
        delete q;
        first->data--;
    }
}

template<class Type>
bool List<Type>::find(const Type &x)
{
    ListNode<Type> *p = first->next;
    while(p!=NULL && p->data!=x)
        p = p->next;
        return p;
    }

template<class Type>
Type List<Type>::length()
{
    cout<<"length = "<<first->data<<endl;
    return first->data;
}

template<class Type>
void List<Type>::clear()
{
  while(first->data >0)
    pop_front();
}

template<class Type>
void List<Type>::destroy()//摧毁该顺序表
{
    clear();
    delete first;
    first = last = NULL;
}

template<class Type>
void List<Type>::reserv() //反转，将整个表空间逆置
{
    ListNode<Type> *p = first->next;
    ListNode<Type> *curr = p->next;
    ListNode<Type> *tmp = NULL;

    first->next->next = NULL;
    while (curr)   //将将直接后继指向当前指针的next
    {
        tmp = curr->next;
        curr->next = p;
        p = curr;
        curr = tmp;
    }
    first->next = p;
}

template<class Type>
void List<Type>::sort()
{
    ListNode<Type> *s = first->next;
    while (s->next)
    {
        ListNode<Type> *p = s;
        while(p->next)
        {
             if(s->data > p->next->data)
                {
                    Type tmp = s->data;
                    s->data = p->next->data;
                    p->next->data = tmp;
                }
                p = p->next;
        }
        s = s->next;
    }
}

#endif // LIST_H_INCLUDED

主函数:

<pre name="code" class="cpp">#include"List.h"

int main()
{
    List<int> mylist;
	int select = 1;
	int Item;
	int pos;
	while(select)
	{
		cout<<"**************************************"<<endl;
		cout<<"* [1] push_back       [2] push_front *"<<endl;
		cout<<"* [3] show_list       [0] quit_system*"<<endl;
		cout<<"* [4] pop_back        [5] pop_front  *"<<endl;
		cout<<"* [6] insert_val      [7] delete_val *"<<endl;
		cout<<"* [8] find            [9]length      *"<<endl;
		cout<<"* [10] clear          [11]destroy    *"<<endl;
		cout<<"* [12] reserv         [13]sort       *"<<endl;
		cout<<"**************************************"<<endl;
		cout<<"请选择:>";
		cin>>select;
		switch(select)
        {
        case 1:
			cout<<"请输入要插入的值(-1结束):>";
			while(cin>>Item, Item!=-1)
			{
				mylist.push_back(Item);
			}
			break;
		case 2:
			cout<<"请输入要插入的值(-1结束):>";
			while(cin>>Item, Item!=-1)
			{
				mylist.push_front(Item);
			}
			break;
		case 3:
			mylist.show_list();
			break;
        case 4:
            mylist.pop_back();
            break;
        case 5:
            mylist.pop_front();
            break;
        case 6:
            cout<<"请输入要插入的值:>";
            cin>>Item;
            mylist.insert_val(Item);
            break;
		case 7:
			cout<<"请输入要删除的值:>";
			cin>>Item;
			mylist.delete_val(Item);
			break;
		case 8:
			cout<<"请输入要查找的值:>";
			cin>>Item;
			mylist.find(Item);
			break;
        case 9:
            mylist.length();
            break;
        case 10:
            mylist.clear();
            break;
        case 11:
            mylist.destroy();
            break;
        case 12:
            mylist.reserv();
            break;
        case 13:
            mylist.sort();
            break;
		default:
			break;
        }
    }
}