/*************************
   
   WZ  ASUST  2016

C++  实现双向链表


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



#include"sts.h"
class CList{
public:
    struct Link{
                Link *pPrev,*pNext;
                int   nData;
                //节点的初始化，前驱与后继指针置空
                Link( int Data = 0): pPrev(NULL),pNext(NULL)
                {
                   nData = Data;
                }
                 ~Link() {}
             };
public:
CList( Link* p = NULL)
{
   pHead = pTail = p;
};
//类的析构，具体由调用后面Clear实现；
~CList()
{
   Clear();
}
//类成员为头尾指针，体现这一结构设计。
Link* pHead,*pTail;

void AddHead( Link* p)
{
   if( pHead )
   {
    pHead->pPrev = p;
    p->pNext = pHead;
    pHead = p;
   }
  else
  {
    pHead = p;
   }
   if( NULL == pTail )
  {
    pTail = pHead;
   }
};
void AddTail( Link* p)
{
   if( pTail )
   {
    pTail->pNext = p;
    p->pPrev = pTail;
    pTail = p;
   }
  else
  {
    pTail = p;
   }
   if( NULL == pHead )
  {
    pHead = pTail;
  }
}
 
void Addmiddle( Link* enter,int n)
{
//just test;
n=n-2;
Link* p = pHead;
   while( p&&n-- )
   {
    p = p->pNext;
   }
 enter->pNext=p->pNext;
  (p->pNext)->pPrev=enter;
 enter->pPrev=p;
 p->pNext=enter;
 }
 
void Print()
{
   Link* p = pHead;
   while( p )
   {
    cout<< p->nData<<",";
    p = p->pNext;
   }
   cout<<endl;
}
void Clear()
{
   Link* p = pHead;
   while( p )
   {
    Link* pt = p->pNext;
    delete p;
    p = pt;
   }
   pHead = pTail = NULL;
};
void DelHead()
{
   if( pHead )
   {
    Link* p = pHead->pNext;
    if( p == pTail )
    {
     delete pHead;
     pTail->pPrev = pTail;
     pHead = pTail ;
    }
    else
   {
     delete pHead;
     pHead = p;
     p->pPrev = NULL;
    }
   }
};
void DelTail()
{
   if( pTail )
   {
    Link* p = pTail->pPrev;
    if( p == pHead )
    {
     delete p;
     pHead->pNext = pHead;
     pTail = pHead;
    }
    else
   {
     delete pTail;
     pTail = p;
     p->pNext = NULL;
    }
   }
}
int lengthlist()
{  int length=0;
   Link* p = pHead;
  if(pHead)
  {
      while( p )
     {
        p = p->pNext;
        length++;
     }
    cout<<"length is "<<length<<endl;
   return length;
  }
  else  return 0;
}
int reverselist()
{  int  len=lengthlist();
   int state=1;
   int tmp=0;
   Link* p = pHead;Link* q = p->pNext;
     while(len--&&state )
     { cout<<"ckeck"<<endl;
        while(q->pNext)
       { cout<<"ckeck2"<<endl;
        if(p->nData >= q->nData )
          {tmp=p->nData; p->nData= q->nData;q->nData=tmp;}
         p =p->pNext; q = q->pNext;
       }

     }
   
 }
 
void ptintfloop()

{  int n=20;
  Link* p = pHead;
   Link* q = pTail;
   
 while(n--)
 {n=n-1;
   while(p!=pTail&&n--)
   {
    cout<<(p->nData);
    p=p->pNext;
    n=n-1;
   }
   while(q!=pHead&&n--)
   {
    cout<<(q->nData);
     q=q->pNext;
    n=n-1;
   }
 }
}
void  listtoloop()
{  if(pHead)
   {
     pHead->pPrev=pTail;
    pTail->pNext=pHead;
    }  
   else return;
}


};
int main()
{
CList list;
list.AddHead( new CList::Link(2) );
list.AddHead( new CList::Link(0) );
list.AddHead( new CList::Link(1) );
list.AddHead( new CList::Link(6) );
list.AddHead( new CList::Link(3) );
list.AddTail( new CList::Link(1) );
list.AddTail( new CList::Link(4) );
list.AddTail( new CList::Link(5) );
list.AddTail( new CList::Link(2) );
list.AddTail( new CList::Link(0) );
list.DelHead();
list.DelTail();
list.Print();
cout<<endl<<"########################################################"<<endl;
list.DelHead();
list.DelHead();
list.DelTail();
list.DelTail();
list.Print();
cout<<endl<<"########################################################"<<endl;
list.AddHead( new CList::Link(1) );
list.AddHead( new CList::Link(2) );
list.AddHead( new CList::Link(3) );
list.AddHead( new CList::Link(4) );
list.AddHead( new CList::Link(5) );
list.AddTail( new CList::Link(6) );
list.Print();
list.DelHead();
cout<<"Del Head()"<<endl;
list.Print();
list.AddTail( new CList::Link(7) );
list.AddTail( new CList::Link(8) );
list.AddTail( new CList::Link(9) );
list.AddTail( new CList::Link(10) );
list.Print();
list.lengthlist();
// list.reverselist();//bug
// list.listtoloop();
//list.ptintfloop();  // bug  always printf all;
list.Print();
list.Addmiddle( new CList::Link(111),3);
list.Print();
list.Clear();
 
return 0;
}
/*************************
   
   WZ  ASUST  2016

   C++  实现单向链表


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



#include"sts.h"
class CList{
public:
    struct Link{
                Link *next;
                int   data;
               
                Link( int Data = 0): next(NULL)
                {
                   data = Data;
                }
                 ~Link() {}
             };
public:
CList( Link* p = NULL)
{
   pHead = pTail = p;
};
//类的析构，具体由调用后面Clear实现；
~CList()
{
   Clear();
}
//类成员为头尾指针，体现这一结构设计。
Link* pHead,*pTail;

void AddHead( Link* p)
{
   if( pHead )
   {
     p->next= pHead;
     pHead=p;
   }
  else
  {
    pHead = p;
   }
   if( NULL == pTail )
  {
    pTail = pHead;
   }
};
 
void AddTail( Link* p)
{  p->next=NULL;
   if( pTail )
   {
    pTail->next = p;
       pTail=p;
   }
  else
  {
    pTail = p;
   }
   
}
 
void Addmiddle( Link* enter,int n)
{
//just test;
n=n-2;
Link* p = pHead;
   while( p&&n-- )
   {
    p = p->next;
   }
 enter->next=p->next;  
 p->next=enter;
 }
 
 
int lengthlist()
{  
   int length=0;
   Link* p = pHead;
  if(pHead)
  {
      while( p )
     {
        p = p->next;
        length++;
     }
    cout<<"length is "<<length<<endl;
   return length;
  }
  else  return 0;
}
void paixu( )
{    int x= lengthlist()+2;  int t=0; int state=1;
int ii=0,jj=0,kk=0;
 Link *p=pHead,*q=p->next;
 while(x--&&state)
  { ii++;
  while (p->next)
    {
     jj++;
    if(p->data >= q->data){t=q->data;q->data=p->data;p->data=t;kk++;}
    else state=0;
    p=p->next;q=q->next;
    }
  }

 
}

void sort( )
{
 Link *p,*q,*hs= new Link;
 Link *s=pHead;
 hs->next=NULL;
 hs->data=-1;
 while(s->next)
 {
  p=s->next;
  s->next=p->next;
  q=hs;
   
  while(q->next)
  {
   
   if(p->data <= q->next->data){p->next=q->next;q->next=p;break;}
   q=q->next;
  }
   
   if(!q->next){q->next=p;p->next=NULL;}
 }
 s->next=hs->next;
}

void reverselist()
{
Link *p=pHead;
Link *q=pHead;
Link *th = NULL;
  while(p)
  {
     q=p;
     p=p->next;
     q->next=th;
     th=q;
   }
 pHead=th;
}

void Print()
{
   Link* p = pHead;
   while( p )
   {
    cout<< p->data<<" ";
    p = p->next;
   }
   cout<<endl;
}
void Clear()
{
   Link* p = pHead;
   while( p )
   {
    Link* pt = p->next;
    delete p;
    p = pt;
   }
   pHead = pTail = NULL;
};
 
void DelHead()
{
   if( pHead )
   {
    Link* p = pHead->next;
    if( p == pTail )
    {
     delete pHead;
     pHead = pTail ;
    }
    else
   {
     delete pHead;
     pHead = p;
    }
   }
   else return; //could not write this.
};
 
 
void DelTail()
{
   if( pTail )
   {
     Link* p = pTail;
     if( p == pHead )
     {
      delete p;    
      pTail= NULL;pHead=NULL;
     }
     else
    {  Link* q =pHead; int len=lengthlist()-2;
     while(len --)
          {  q=q->next;}
        pTail=q;
       delete p;
       
     
    }
   }
   else return;
}

 
int sort1()
{  int  len=lengthlist();
   int state=1;
   int tmp=0;
   Link* p = pHead;Link* q = p->next;
     while(len--&&state )
     { cout<<"ckeck"<<endl;
        while(q->next)
       { cout<<"ckeck2"<<endl;
        if(p->data >= q->data )
          {tmp=p->data; p->data= q->data;q->data=tmp;}
         p =p->next; q = q->next;
       }

     }  
 }
 
void ptintfloop()

{  int n=20;
  Link* p = pHead;
   Link* q = pTail;
   
 while(n--)
 {n=n-1;
   while(p!=pTail&&n--)
   {
    cout<<(p->data)<<" ";
    p=p->next;
    n=n-1;
   }
   while(q!=pHead&&n--)
   {
    cout<<(q->data)<<" ";
     q=q->next;
    n=n-1;
   }
 }
}
 
void  listtoloop()
{  if(pHead)
   {
    Link* p = pHead;
    while(p->next)
    {
     p=p->next;
    }  
   p->next=pHead;
   }
   else return;
}

 
};
void test1()
{
CList list;
list.AddHead( new CList::Link(2) );
list.AddHead( new CList::Link(2) );
list.AddTail( new CList::Link(8) );
list.AddTail( new CList::Link(1) );
list.AddTail( new CList::Link(8) );
//   list.DelTail();   //(core dumped)
list.Print();
list.DelHead();    //ok
list.Addmiddle( new CList::Link(9),3 );
list.lengthlist();
//list.sort1();//bug

// list.paixu();//bug
// list.sort();  //bug
list.reverselist();  //ok
list.Print();
//list.listtoloop();
//list.ptintfloop();//0k

list.Clear();
 
}

int main()
{
test1();
return 0;
}
 #include"wz.h"



 
typedef struct mylist
{
int data;
struct mylist *next;
}mylist;


int listlength(mylist *list)
{
int length=0;
mylist *p=list;
while(p)
{
p=p->next;
length++;
}
return length;
}

paixu(mylist *list)
{    int x=listlength(list)+2;  int t=0; int state=1;
int ii=0,jj=0,kk=0;
 mylist *p=list,*q=p->next;
 while(x--&&state)
  { ii++;
  while (p->next)
    {
     jj++;
    if(p->data >= q->data){t=q->data;q->data=p->data;p->data=t;kk++;}
    else state=0;
    p=p->next;q=q->next;
    }
  }
printf("paixu :\nii==%d,jj==%d,kk==%d\n",ii,jj,kk);
}


printflist(mylist *list)
{
  mylist  *p=list;
 
  while(p)
  {
    printf("%3d",p->data);
    p=p->next;
  }
printf("\n" );
}
main()
{

int i;
int k=9;
int t=0;
mylist *list=(mylist *)malloc(sizeof(mylist));
list->data = 11;
list->next = NULL;
mylist  *new,*p=list,*q=p->next;
i=11;
while(i--)
{
 new=(mylist *)malloc(sizeof(mylist));
  new->data=i;    //   printf("%2d",new->data);
  new->next = list->next;
 list->next = new;
 
}
printflist(list);
while(k--)
{p=p->next;}
printf("%d\n",p->data);

q=p->next;
t=q->data;q->data=p->data;p->data=t;
printflist(list);
printf("%d\n",p->data);
paixu(list);
printflist(list);

}