模板实现单向链表

 /************************************

          WZ ASUST   2016

        模板实现单向链表

************************************/

#include"sts.h"
template <class T>
struct node
{
public:node(const T &d):next(NULL),data(d){}
T data;
node<T> *next;
};
template <class T>
class dlist
{
private: node<T>* head;node<T>* tail;
public:
       dlist():head(NULL),tail(NULL){};
       ~dlist(){node<T>*cur=head;while(cur){node<T>*del=cur;cur=cur->next;delete del;}}
     void print(){node<T>*cur=head;while(cur){cout<<cur->data<< " ";cur=cur->next;}cout<<"ok"<<endl;}
 
dlist & operator=(const dlist <T> & dl)
{
if(this!=&dl)
  {
   head=dl.head;
   tail=dl.tail;
   node<T>*dlcur=dl.head;
   node<T>*cur=dlcur;
int xx=length()-1;
 while(xx--)
   {
    dlcur=dlcur->next;
     dlcur=cur;
    cur=cur->next;
   }

  }

}
int length()
{
int ret=0;
if(head)
{
 node<T>*cur=head;
while(cur)
{
ret++;
 cur=cur->next;
}
return ret;
}
else return 0;
}

void pushback(const T &d)
{
if(head==NULL)
 {
  head=new node<T>(d);
  tail=head;
 }
else
 {
   tail->next=new node<T>(d);
   tail=tail->next;
 }
}
T popback()
{
if(head==NULL)
 {
   return 0;
 }
else
 {
   return tail->data;
 
 }

}
void pushfront(const T &d)
{
if(head==NULL)
 {
  head=new node<T>(d);
  tail=head;
 }
else
 {
   node<T> *add=new node<T>(d);
    add->next=head;
   head=add;
 }
}
T popfront()
{
if(head==NULL)
 {
   return 0;
 }
else
 {
   return head->data;
 
 }

}
void insert(int x, const T d)
{
if(x<0||x<length())
 {x=x-1;
  node<T> *add=new node<T>(d);
   node<T> *cur=head;
  if(head)
     {
      while(x--)
       {cur=cur->next;}
         add->next=cur->next;
        cur->next=add;
     }
  }
}
void reverse()
{
 int len=length();
 node<T> *tmp=NULL;
if(head)
  {
    node<T>* p = head;
    node<T>* q = head;  
    node<T>* th=NULL;
   while(len--)
   {
       q=p;
       p=p->next;
      q->next=th;
      th=q;
   }
   head=th;
}
  else
      return;
 
 
}
void paixu()
{
 int len=length();
 int state=1;
  T  tmp;
//len>1;
 while(len--&&state)
  {
    node<T>* p = head; node<T>* q=p->next;
   while(q)
    {
     if(p->data >= q->data){ tmp=q->data;q->data=p->data;p->data=tmp; }
     else state=1;
     p=p->next;     q=q->next;
     }
  }
}
};
 void test()
{
dlist<int> int_dlist;
cout<<"** 1 : ***************"<<endl;
 int_dlist.pushback(11);
 int_dlist.pushback(22);
 int_dlist.pushback(33);
 int_dlist.pushback(44);
 int_dlist.print();
cout<<"*** 2 :**************"<<endl;
 
 int_dlist.pushfront(55);
 int_dlist.pushfront(66);
 int_dlist.pushfront(77);
 int_dlist.print();
cout<<"*** 3 :**************"<<endl;
  cout<<int_dlist.popfront()<<endl;
  cout<<int_dlist.popback()<<endl;
cout<<"*** 4 :**************"<<endl;

dlist<int> int_dlist2;
int_dlist2=int_dlist;
 int_dlist.print();
cout<<"** 5 : ***************"<<endl;
cout<<int_dlist.length()<<endl;

}
int main()
{
// test();
dlist<int> int_dlist;

 int_dlist.pushback(11);
 int_dlist.pushback(22);

 int_dlist.pushback(44);
 int_dlist.pushback(33);
 int_dlist.print();

cout<<"** 6 : ***************"<<endl;
int_dlist.reverse();
int_dlist.print();
cout<<"** 7 : ***************"<<endl;
int_dlist.insert(3,99);
int_dlist.paixu();
int_dlist.print();
 return 0;
}
时间: 2024-09-30 15:01:55

模板实现单向链表的相关文章

C++模板实现单向链表

模板实现头文件: #ifndef SUN_LINKLIST_H #define SUN_LINKLIST_H #include <iostream> using namespace std ; //#include "List.h" // T : operator= , operator!= , operator== , copy constructor , assign constructor #define SUN_LINKLIST_DEBUG #ifdef SUN_L

单向链表模板

写个单向链表模板练练手: #include <bits/stdc++.h> using namespace std; //create // delete // modify // search class Node{ public: int data; Node* ptr; Node(int elem= 0, Node* node= NULL){ this->data= elem; this->ptr= NULL; } }; class MyList{ private: Node

数据结构-单向链表 C和C++的实现

数据结构,一堆数据的存放方式. 今天我们学习数据结构中的 链表: 数组,大家相当熟悉的存放数据方式,而链表是数组的一种特殊方式,它每个节点包括两个部分: 数据域:存放数据,此部分与数组相同 指针域:存放了下一个节点的地址 链表比数组多了指针域,因为链表需要通过上一个节点的指针域去找下一个数据,比如有一个链表ABCD四个节点,我们要访问D里边的数据.操作如下: 先通过A节点的指针域找到B节点 再通过B节点的指针域找到C节点 再通过C节点的指针域找到D节点 获取D节点数据域的数据 对比数组直接通过下

C语言实现简单的单向链表(创建、插入、删除)及等效STL实现代码

实现个算法,懒得手写链表,于是用C++的forward_list,没有next()方法感觉很不好使,比如一个对单向链表的最简单功能要求: input: 1 2 5 3 4 output: 1->2->5->3->4 相当于仅仅实现了插入.遍历2个功能(当然遍历功能稍微修改就是销毁链表了) 用纯C写了份测试代码 /* 基本数据结构的定义以及函数的声明 */ typedef int ElemType; typedef struct Node { ElemType elem; struc

【转】Linus:利用二级指针删除单向链表

原文作者:陈皓 原文链接:http://coolshell.cn/articles/8990.html 感谢网友full_of_bull投递此文(注:此文最初发表在这个这里,我对原文后半段修改了许多,并加入了插图) Linus大婶在slashdot上回答一些编程爱好者的提问,其中一个人问他什么样的代码是他所喜好的,大婶表述了自己一些观点之后,举了一个指针的例子,解释了什么才是core low-level coding. 下面是Linus的教学原文及翻译—— “At the opposite en

数据结构与算法学习-单向链表的实现

链表(Chain本文所说链表均为单向链表,以下均简称单向链表)实际上是由节点(Node)组成的,一个链表拥有不定数量的节点.而向外暴露的只有一个头节点(Head),我们对链表的所有操作,都是直接或者间接地通过其头节点来进行的. 节点(Node)是由一个需要储存的对象及对下一个节点的引用组成的.也就是说,节点拥有两个成员:储存的对象.对下一个节点的引用. 这样说可能大家不是很明白,我贴一张图大家可能更容易理解. package LinkedList; /** * <p><strong>

算法总结之 反转部分单向链表

给定单链表的表头节点head, 以及两个整数from 和 to, 在单向链表上把fro个节点到第to个节点这一部分进行反转 思路: 本题 有可能存在换头的问题,所以函数应该返回调整后的新的头节点 1 判断是否满足 1<=from<=to<=N 如果不满足,直接返回原来的头节点 2 找到第from-1个节点pre和第to+1个节点tPos,fPre即要反转部分的前一个节点,tPos是反转部分的后一个节点,把反转部分先反转,然后正确的链接fPre和tPos package TT; impor

C语言之字符单向链表

/* * @Author: suifengtec * @Date:   2017-09-02 16:06:33 * @Last Modified by:   suifengtec * @Last Modified time: 2017-09-02 20:47:13 **/ /* 字符单向链表 gcc -o a.exe main.c && a  */ #include <stdio.h> #include <stdlib.h> #include <stdbool

C++__单向链表(练习)

单向链表 link.h #ifndef LINK_H_ #define LINK_H_ #define HEADER 0 #define TAIL -1 typedef int data_type; enum LINK_OP { LINK_ERR = -1, LINK_OK }; class LINK { private: data_type data; LINK *next; public: LINK(); LINK(data_type data); virtual ~LINK(); data