链表例题



#include <iostream>
#include <math.h>
#include <stack>
using namespace std;
//删除动态链表中指定的节点
#if 0
class Node
{
public:
 int number;
 Node *pnext;
 Node* creat_list();
 void show_list(Node *h);
 bool delete_list(Node *phead, int pos, int *pval);
 bool insert_list(Node *phead, int pos, int val);
};
Node * Node::creat_list()
{
 Node *head = NULL, *p1, *p2 = NULL;
 p1 = new Node;
 p1->number = 1;
 head = p1;
 p2 = head;
 for (int i = 2; i <= 13; i++)
 {
  p1 = new Node;
  p1->number = i;
  p2->pnext = p1;
  p2 = p1;
 }
 
 p2->pnext = NULL;
 return head;
}
bool Node::delete_list(Node *phead, int pos, int *pval)
{
 int i = 0;
 Node *p = phead;
 while (p->pnext != NULL && i < pos - 1)
 {
  p = p->pnext;
  i++;
 }
 if (i >(pos - 1) || p->pnext == NULL)
 {
  return false;
 }
 Node *q = p->pnext;
 *pval = q->number;
 //删除p节点后面的节点
 p->pnext = p->pnext->pnext;
 free(q);
 q = NULL;
 cout << "the delete value is" << *pval << endl;
 return true;
}
bool Node::insert_list(Node *phead, int pos, int val)
{
 int i = 0;
 Node *p = phead;
 while ((NULL != p) && (i<pos - 1))
 {
  p = p->pnext;
  i++;
 }
 if ((i > pos - 1) || NULL == p)
 {
  return false;
 }
 Node *pnew = new Node;
 pnew->number = val;
 Node *q = p->pnext;
 p->pnext = pnew;
 pnew->pnext = q;
 return true;
}

void Node::show_list(Node *h)
{
 Node*p;
 p = h;
 while (p != NULL)
 {
  cout << p->number << " ";
  p = p->pnext;
 }
 cout << endl;
}
void main()
{
 int val;
 Node *p = NULL;
 p = p->creat_list();
 p->show_list(p);
 p->delete_list(p, 4, &val);
 p->show_list(p);
 p->insert_list(p,6,60);
 p->show_list(p);
}
#endif
//a b 合并 按学好的升序排列
#if 0
class student
{
public:
 long num;
 float score;
 student *next;
 void print( student * head);
 friend  student* sx(student * head);
};
class student a[5] =
{
 { 1005, 10.23, &a[1] },
 { 1004, 10.54, &a[2] },
 { 1003, 11.55, &a[3] },
 { 1002, 12.32, &a[4] },
 { 1001, 15.65, NULL }
};
class student b[5] =
{
 { 2005, 11.23, &b[1] },
 { 2004, 12.54, &b[2] },
 { 2003, 16.55, &b[3] },
 { 2002, 14.32, &b[4] },
 { 2001, 17.65, NULL }
};
void student::print( student * head)//打印链表的函数
{
 student * p;
 p = head;
 if (head == NULL)
 {
  cout << "该链表为空" << endl;
 }
 else{
  do{
   cout << p->num <<" "<<p->score<<endl;
   p = p->next;
  } while (p != NULL);
 }
}
student* sx( student * head)
{    // 用递归，每次找出原链表中学号最小的元素，插入到新链表的后面。
 student *cursor, *first, *prev, *min;
 first = NULL;
 if (head == NULL)
  return NULL;
 for (cursor = min = head; cursor->next != NULL; cursor = cursor->next)
 {
  if ((cursor->next->num) <  (min->num))
  {
   prev = cursor;
   min = cursor->next;
  }
 }
 first = min;
 if (min == head)
 {
  head = head->next;
 }
 else
 {
  prev->next = min->next;
 }
 first->next = sx(head);
 return first;
}
void main()
{
 a[4].next = &b[0];//将两个链表先连接起来
 student * head;
 head = &a[0];
 head->print(head);
 cout << "num 按升序排列之后的输出结果是" << endl;
 head = sx(head);//将经过升序排列之后的节点链表的首地址，赋值给head
 head->print(head);//打印升序之后的链表
}
#endif
// a b 从a 中删除与b 中相同学号的元素
#if 0
class student
{
public:
 long num;
 float score;
 student *pnext;
 void print(student * head);
 friend student *del(student *head1, student *head2); 
};
void student::print(student * head)//打印链表的函数
{
 student * p;
 p = head;
 while (p != NULL)
 {
  cout << p->num << " " << p->score << endl;
  p = p->pnext;
 }
}

student *del(student *head1, student *head2)
{
 student *pa = head1;
 student *pb = head2;
 student *prev = NULL;
 if (pa == NULL)
 {
  cout << "链表A为空" << endl;
  return head1;
 }
 while (pa != NULL)
 {
  if (pa->num == pb->num)
  {
   if (pa == head1)
   {
    head1 = pa->pnext;
   }
   else
   {
    prev->pnext = prev->pnext->pnext;
    pb = pb->pnext;
   }
   return head1;
  }
  else
  {
   prev = pa;
  }
  pa = pa->pnext;
  pb = pb->pnext;
 }
 return head1;
}
class student a[5] =
{
 { 1005, 10.23, &a[1] },
 { 1004, 10.54, &a[2] },
 { 1003, 11.55, &a[3] },
 { 1002, 12.32, &a[4] },
 { 1001, 15.65, NULL }
};
class student b[5] =
{
 { 2005, 11.23, &b[1] },
 { 1004, 12.54, &b[2] },
 { 2003, 16.55, &b[3] },
 { 2002, 14.32, &b[4] },
 { 2001, 17.65, NULL }
};
void main()
{
 student * head;
 head = &a[0];
 head->print(head);
 cout << "b链表的数据为 " << endl;
 head = &b[0];
 head->print(head);
 cout << "删除相同元素之后" << endl;
 head = del(&a[0],&b[0]);
 head->print(head);
}
#endif
//如果链表中输入一个年龄   该链表包含此年龄则删除该节点
#if 0
#include<stdio.h>
class student
{
public:
 int num;
 char name[10];
 int age;
 student *next;
    friend student * del(student *head);
 void print(student * head);
};
void student::print(student * head)//打印链表的函数
{
 student * p;
 p = head;
 while (p != NULL)
 {
  cout << p->num << " " << p->name <<" "<<p->age<< endl;
  p = p->next;
 }
}
student * del(student *head)
{
 int n;
 student *p = head;
 student *prev = NULL;
 printf("请输入年龄：");
 scanf("%d", &n);
 while (p != NULL)
 {
  if (p->age == n)
  {
   head = p->next;
   p = p->next;
   
  }
  else if (p->next->age == n)
  {
   cout << "被删除的数为" << n << endl;
   p->next = p->next->next;
   break;
  }
  else
   p = p->next;
 }
 return head;
}
class student a[5] =
{
 { 1, "li",10, &a[1] },
 { 2, "zhang",11, &a[2] },
 { 3, "liu", 13, &a[3] },
 { 4, "hui", 10, NULL }
};

void main()
{
 student * head;
 head = &a[0];
 head->print(head);

 head = del(head);
 cout << "删除后为" << endl;
 head->print(head);
}
#endif
//13个人围坐一起 3退出
#if 0
class _Node
{
public:
 int order; // The order number
 bool state; // true is in the circle, false is out of the
 _Node *next;
};
void main()
{
 _Node *p1;
 _Node *head = NULL;
 _Node *p2 = NULL;
 p1 = new _Node;
 p1->order = 1;
 p1->state = true;
 head = p1;
 p2 = head; // Initialize
 for (int i = 2; i <= 13; i++)
 {
  p1 = new _Node;
  p1->order = i;
  p1->state = true;
  p2->next = p1;
  p2 = p1;
 }
 p2->next = head;
 p2 = head;
 int leave = 13;
 int num;
 while (leave > 1)
 {
  num = 1;
  while (1)
  {
   if (p2->state == true)
   {
    if (num < 3)
    {
     p2 = p2->next;
     num++;
    }
    else
    {

     p2->state = false;
     cout << "Out of the circle:" << p2->order << endl;
     p2 = p2->next;
     leave--;
     break;
    }
   }
   else
    p2 = p2->next;
  }
 }
 p2 = head;
 while (p2->state == false)
 {
  p2 = p2->next;
 } 
 cout << "The person who is in the circle:" << p2->order << endl;
}
#endif

#if 0
//单链表
typedef struct LNode
{
 char date;
 struct  LNode *next;
}Node, *LinkList;
//初始化
void  IntLink(Node **head)
{
 *head = new Node;
 (*head)->next = NULL; 
}

void CreatlInk(Node *head)
{
 char c;
 while ()
}
//头插
/*该方法从一个空表开始，重复读入数据，生成新结点，将读入数据存放到新结点的数据域中，
然后将新结点插入到当前链表的表头上，直到读入结束标志(比如$）为止。*/
void InsertFront_1(LinkList *l)
{
 char c;
 Node *s;
 int flag = 1;
 while (flag)
 {
  c = getchar();
  if ( c != '$')
  {
   s = new Node;
   s->date = c;
   s->next =(*l)->next;
   (*l)->next = s;
  }
  else
  {
   flag = 0;
  }
 }
}
LinkList InsertFront_2()
{
 LinkList L;
 Node *s;
 int flag = 1;
 char c;
 L = new Node;
 L->next = NULL;
 while (flag)
 {
  c = getchar();
  if (c != '$')
  {
   s = new Node;
   s->date = c;
   s->next = L->next;
   L->next = s;
  }
  else
  {
   flag = 0;
  }
 }
 return L;
}
//尾插
/*可采用尾插法建表。该方法是将新结点插入到当前链表的表尾上。
为此必须增加一个尾指针r，使其始终指向当前链表的尾结点。*/
void InsertTail_1(LinkList l)
{
 Node *r, *s;
 int flag = 1;
 char c;
 r = l;
 while (flag)
 {
  c = getchar();
  if (c != '$')
  {
   s = new Node;
   s->date = c;
   r->next = s;
   r = s;
  }
  else
  {
   flag = 0;
   r->next = NULL;
  }
 }
}
LinkList InsertTail_2()
{
 LinkList L;
 Node *s, *r;
 int flag = 1;
 char c;
 L = new Node;
 L->next = NULL;
 r = L;
 while (flag)
 {
  c = getchar();
  if (c != '$')
  {
   s = new Node;
   s->date = c;
   r->next = s;
   r = s;
  }
  else
  {
   flag = 0;
   r->next = NULL;
  }
 }
 return L;
}
// 按序号查找
/*设单链表的长度为n，要查找表中第i个结点，仅当1<=i<=n时，i的值是合法的。
但有时需要找头结点的位置，故我们将头结点看做是第0个结点，*/
Node*  FormAddGet_1(LinkList l, int i)
{
 int j=0;
 Node *p;
 p = l;
 while ((p->next != NULL) && (j < i))
 {
  p = p->next;
  j++;
 }
 if (j == i)
 {
  return p;
 }
 else
 {
  return NULL;
 }
}
Node*  FormAddGet_2(LinkList L, int i)
{
 Node *p;
 int j = 0;
 p = L->next;
 while ((p != NULL) && (j < i))
 {
  p = p->next;
  j++;
 }
 if (j == i)
 {
  return p;
 }
 else
 {
  return NULL;
 }
}
//按值查找
/*按值查找是在链表中，查找是否有结点值等于给定值key的结点，若有，则返回首次找到的其值为key的结
点的存储位置；否则返回NULL。查找过程从开始结点出发，顺着链表逐个将结点的值和给定值key作比较。*/
Node* FormValueGet_1(LinkList l, char key)
{
 Node *p;
 p = l->next;
 while (p != NULL)
 {

  if (p->date != key)
  {
   p = p->next;
  }
  else
  {
   break;
  }
 }
 return p;
}
Node* FormValueGet_2(LinkList l, char key)
{
 Node *p;
 p = l->next;
 while (p != NULL)
 {
  if (p->date != key)
  {
   p = p->next;
  }
  else
  {
   break;
  }
 }
 return p;
}
//插入运算
/*插入运算是将值为x的新结点插入到表的第i个结点的位置上，即插入到ai - 1与ai之间。因此，必须首先找到ai - 1的存储位置p，
然后生成一个数据域为x的新结点，并令q指针指向该新结点，新结点的指针域指向结点ai。从而实现三个结点ai - 1，x和ai之间的
逻辑关系的变化*/
int InsertList(LinkList l, int i, char e)
{
 Node *prev, *s;
 prev = l;                               //prev = l->next;
 int k = 0;
 while ((prev != NULL) && (k < i - 1))        //while ((prev != NULL) && (k < i - 1)) 
 {
  prev = prev->next;
  k++;
 }
 if (k != i - 1)
 {
  cout << "插入位置不符合要求，插入失败" << endl;
  return 0;
 }
 s = new Node;
 s->date = e;
 s->next = prev->next;
 prev->next = s;
 return 0;
}
//删除运算
/*删除运算是将表的第i个结点删去。因为在单链表中结点ai的存储地址是在其直接前趋结点ai - 1的
指针域next中，所以必须首先找到ai - 1的存储位置p。然后令p–>next指向ai的直接后继结点，即把
ai从链上摘下。*/
int DelList(LinkList l, int i)
{
 Node *p, *s;
 p = l;
 int k = 0;
 while(p->next != NULL && k < i - 1)
 {
  p = p->next;
  k++;
 }
 if (k != i - 1)
 {
  cout << "删除位置错误，删除失败" << endl;
  return 0;
 }
 s = p->next;
 p->next = p->next->next;
 free(s);
 cout << "删除成功" << endl;
 return 0;
}

//求单链表的长度
int LengthLink(LinkList l)
{
 int count = 0;
 Node *p;
 p = l->next;                //p = l;         ??????????????????????
 while (p != NULL)
 {
  p = p->next;
  count++;
 }
 return count;
}
//俩个链表集合之差  LA-LB
LinkList Differrnce(LinkList LA, LinkList LB)
{
 Node *prev,*pa,*pb,*r;
 prev = LA;
 pa = prev->next;
 while (pa != NULL)
 {
  pb = LB->next;
  while ((pb != NULL) && (pb->date != pa->date))
  {
   pb = pb->next;

   if (pa != NULL)                    //???????????????????????????????????//
   {
    r = pa;
    prev->next = pa->next;
    pa = pa->next;
    free(r);
   }
   else
   {
    prev = pa;
    pa = pa->next;
   }
  }
 }
}
//循环链表的合并方法
/*LA LB 先分别找到各自的表尾，pa为LA的尾 pb为LB的尾，
pa->next= LB->next   pb->next = LA  并释放LB*/
LinkList TogetherLink(LinkList LA, LinkList LB)
{
 Node *pa;
 Node *pb;
 pa = LA;
 pb = LB;
 while (pa->next != NULL)
 {
  pa = pa->next;
 }
 while (pb->next != NULL)
 {
  pb = pb->next;
 }
 pa->next = LB->next;
 pb->next = LA;
 free(LB);
 return LA;
}
int main(void )
{
 
 Node *head = NULL;
 IntLink(&head);

 return 0;
}
#endif
//双向链表
#if 0
typedef struct DouLNode
{
 char date;
 DouLNode *prior;
 DouLNode *next;
}DouNode,*DouLinkList;
//前插
/*找到要插得位置p   需要插入的元素q
p->prior->next = q;
q->prior = p->prior;
q->next = p;
p->next = q;
*/
int DouInsertFront(DouLinkList l, int i, char e)
{
 DouNode *p, *q;
 int k = 0;
 p = l;
 while (p != NULL && k < i )
 {
  p = p->next;
  k++;
 }
 if (k != i )
 {
  cout << "插入位置有错误，插入失败" << endl;
  return 0;
 }
 q = new DouNode;
 q->date = e;
 p->prior->next = q;
 q->prior = p->prior;
 q->next = p;
 p->next = q;
 return 1;
}
//删除
/*
p->prior->next = p->next;
p->next->prior = p->prior;
*/
int DouDelLink(DouLinkList l, int i, char *e)
{
 int k = 0;
 DouNode *p;
 p = l;
 while (p->next != NULL && k < i)
 {
  p = p->next;
 }
 if (k != i)
 {
  cout << "删除位置错误，删除失败" << endl;
  return 0;
 }
 *e = p->date;
 p->prior->next = p->next;
 p->next->prior = p->prior;
 delete p;
}

#endif

//单链表 有头结点
#if 0
#define ElemType int
typedef struct Node
{
 ElemType date;
 struct Node *next;
 int flag = 0;
}LNode,*LinkList;
//初始化
void IntiLink(LNode **head)
{
 *head = new LNode;
 (*head)->next = NULL;
}
//创建  头插
void CreatFromFront(LNode *head)
{
 int flag = 1;
 ElemType ch;
 LNode *s;
 while (flag)
 {
  cin >> ch;
  if (ch != 0)
  {
   s = new LNode;
   s->date = ch;
   s->next = head->next;
   head->next = s;
  }
  else
  {
   flag = 0;
  }
 }

}
//输出
void PrintLink(LNode *head)
{
 LNode *p = head->next;
 while (p)
 {
  printf("%d  ", p->date);
  p = p->next;
 }
}
//尾插
void CreatFromTail(LNode *head,ElemType ch)
{
 /*LNode *p = head->next;
 while (p != NULL)
 {
  p = p->next;                       跳出while p为空 所以p->next不存在
 } */ 
 LNode *p = head;
 while (p->next != NULL)
 {
  p = p->next;
 }
 LNode *s = new LNode;
 s->date = ch;
 p->next = s;
 s->next = NULL;
}
//查找 按值查
LNode* SerchFromValue(LNode *head, ElemType ch)
{
 LNode *p = head;
 while (p->next != NULL)
 {
  p = p->next;
  if (p->date == ch)
  {
   break;
  }
 }
 return p;
}
//查找 按位置
LNode* SerchFromAdd(LNode *head, int i)
{
 if (i < 0 || head == NULL)
 {
  cout << "出入的位置有误" << endl;
 }
 else
 {
  int k = 1;
  LNode *p = head->next;
  while (p)
  {
   if (k == i)
   {
    return p;
   }
   else
   {
    p = p->next;
    k++;
   }
  }
 }
 return NULL;
}
//插入
void InsertLink(LNode **head, int i, ElemType ch)
{
 LNode *prev, *s;
 int k = 1;                                      //int k = 1
 prev = *head;
 while ((prev->next != NULL) && k <i)           //k<i-1             条件同时改成这个 也成立
 {
   prev = prev->next;
   k++;            
 }
 s = new LNode;
 s->date = ch;
 s->next = prev->next;
 prev->next = s;
}
//删除
void DeletLink(LNode *head, LNode *x)
{
 LNode *pre = head;
 LNode *cur = head->next;
 while (cur != NULL)
 {
  if (cur == x)
  {
   pre->next = cur->next;
   free(cur);
   cur = NULL;
  }
  else
  {
   pre = cur;
   cur = cur->next;
  }
 }
}
//逆序
void TransLink(LNode **head)
{
 //只有头结点或者只有一个结点 空链表
 if ((*head)->next == NULL ||                       
  (*head)->next->next == NULL ||
  (*head)== NULL)
 {
  return;
 }

 LNode *q, *p, *r;
 p = (*head)->next;
 q = p;
 p = q->next;
 q->next = NULL;

 while (p != NULL)
 { 
  r = p->next;
  p->next = q;
  q = p;
  p = r;
 }
 (*head)->next = q;
}
//合并
void SumLink(LNode **head1, LNode **head2)
{
 LNode *p1 = *head1;
 LNode *p2 = *head2;

 while (p1->next != NULL)
 {
  p1 = p1->next;
 }
 p1->next = p2->next;
}
//LA-LB 
void SubLink(LNode **head1, LNode **head2)
{
 LNode *p1 = *head1;
 LNode *p2 = *head2;
 while (p1->next != NULL)
 {
  while (p2->next != NULL)
  {
   p2 = p2->next;
   while (p2->date != p1->date)
   {
    p1 = p1->next;
   }
   DeletLink(*head1,p1);
   p1 = (*head1)->next;
  }
 }
}
//单链表的逆序
void TranslatLink(LNode **head)
{
 LNode *p, *q, *r;
 p = (*head)->next;
 q = p;
 p = q->next;
 p->next = NULL;
 while (p != NULL)
 {
  r = p->next;
  p->next = q;
  q = p;
  p = r;
 }
 (*head)->next = q;
}
//判断一个单链表是否存在环。
void CriclLink(LNode *head)
{
 LNode *p = head; //0没有走过  1走过       
 while (p->next != NULL)
 {
  if (p->flag == 0)
  {
   p = p->next;
   p->flag = 1;
  } 
  else
  {
   cout << "存在环" << endl;
   break;
  }
 }
}
//判断两个单链表是否相交。
void TogherLink(LNode *head1, LNode *head2)
{
 LNode *p1 = head1;
 LNode *p2 = head2;
 int len1 = 0, len2 = 0;
 while (p1->next != NULL)
 {
  p1 = p1->next;
  len1++;
 }
 while (p2->next != NULL)
 {
  p2 = p2->next;
  len2++;
 }
 if (p1->date != p2->date)
  //if (p1 != p2)               地址不相同
 {
  cout << "两个单链表不相交" << endl;
  return;
 }
 int indexlen = abs(len1 - len2);

 if (len1 > len2)
 {
  p1 = head1;
  p2 = head2;
 }
 else
 {
  p1 = head2;
  p2 = head1;
 }
 for (int i = 0; i < indexlen; i++)
 {
  p1 = p1->next;
 }

 while (p1 != p2)      //虽然是俩个链表 但是最后合成一个 地址相同
 {
  p1 = p1->next;
  p2 = p2->next;
 }
 cout << "两个单链表相交" << endl;
}
void main()
{
 LNode *head1 = NULL;
 IntiLink(&head1);

 CreatFromFront(head1);
 PrintLink(head1);
 cout << endl;

 /*ElemType ch = 9;
 CreatFromTail(head1,ch);
 PrintLink(head1);*/

 /*
 LNode *s = NULL;
 ElemType ch = 'a';
 s = SerchFromValue(head, ch);
 cout << s->date << endl;
 */

 /*LNode *l = NULL;
 l = SerchFromAdd(head1, 2);
 cout << "找的的值为";
 cout << l->date << endl;
 cout << endl;*/

 InsertLink(&head1,2,100);
 PrintLink(head1);

 ///DeletLink(head, l);
 //PrintLink(head); 

 //TransLink(&head);
 //PrintLink(head);

 /*LNode *head2 = NULL;
 IntiLink(&head2);
 CreatFromFront(head2);
 PrintLink(head2);
 cout << endl;
 SumLink(&head1, &head2);
 PrintLink(head1);*/

 /*LNode *head2 = NULL;
 IntiLink(&head2);
 CreatFromFront(head2);
 PrintLink(head2);
 cout << endl;
 SubLink(&head1, &head2);
 PrintLink(head1);*/

 //CriclLink(head1);

 /*LNode *head2 = NULL;
 IntiLink(&head2);
 CreatFromFront(head2);
 PrintLink(head2);
 cout << endl;
 TogherLink(head1, head2);*/

}
#endif

//循环链表    不带头结点
//约瑟夫 13个人 3退出
#if 1
#define ElemType int
typedef struct Node
{
 ElemType date;
 struct Node *next;
}LNode, *LinkList;
//创建
LNode* CreatRromFront()
{
 LNode *p, *q, *head;
 p = new LNode;
 head = p;
 p->date = 1;

 for (int i = 2; i <= 9; i++)
 {
  q = new LNode;
  q->date = i;
  p->next = q;
  p = p->next;
 }
 p->next = head;
 return head;
}
//输出
void PrintLink(LNode *head)
{
 LNode *p = head;
 while (p->next != head)                 //输出结束条件
 {
  printf("%d  ", p->date);
  p = p->next;
 }
 printf("%d  ", p->date);
 cout << endl;
}
void Joseph(LNode *head,int k,int m)
{
 LNode *p = head;
 LNode *temp;
 while (p->date != k)
 {
  p = p->next;
 }

 while (p->next != p)
 {
  for (int i = 1; i < m; i++)
  {
   temp = p;
   p = p->next;
  }
  cout << "删除的数据为" <<p->date<< endl;
  temp->next = p->next;
  free(p); 
  p = temp->next;
 }
 cout << "删除的数据为" << p->date << endl;
 free(p);
 /*int count = 0;
 int k = 1;
 LNode *p = *head;
 while (p->next != *head)
 {
  p = p->next;
  count++;
 }
 
 do
 {
  for (int i = 0; i < m; i++)
  {
   p = p->next;
  }
  cout << "删除的数为" << p->date << endl;
  
  count--;
 } while (count = 1);
 */
}
void main()
{
 LNode *head = NULL;
 head = CreatRromFront();
 PrintLink(head);
 Joseph(head, 2, 3);
}
#endif
#if 0
typedef struct Node
{
 int date;
 struct Node* next;
}LNode;
//创建
LNode* CreatLink()
{
 LNode *p ,*head;
 p = new LNode;
 p->date = 0;
 head = p;
 for (int i = 1; i <=4; i++)
 {
  LNode *q = new LNode;
  q->date = i;
  p->next = q;           //q = p->next;错误    p->next还没有值所以赋值语句不成立！
  p = p->next;
 }
 p->next = head;
 return head;

}
//输出
void PintfLink(LNode *first)
{
 LNode *p = first;
 while (p->next != first)
 {
  cout << p->date << " ";
  p = p->next;
 }
 cout << p->date <<endl;
}
//约瑟夫
void Joseph(LNode *first,int m)
{
 LNode *p = first;
 LNode *pre;
 int count = 5;
 while (count > 1)
 {
  for (int i = 1; i < m; i++)
  {
   pre = p;
   p = p->next;
  }
  pre->next = p->next;
  count--;
  cout << "删除的数据为" << p->date << endl;
  delete p;
  p = NULL;
  p = pre->next;
 }
}
void main()
{
 LNode *p = NULL;
 p = CreatLink();
 PintfLink(p);
 Joseph(p,3);
}

#endif

#if 0
#define ElemType int
typedef struct Node
{
 ElemType date;
 struct Node *next;
}LNode, *LinkList;
//初始化
void IntiLink(LNode **head)
{
 *head = new LNode;
 (*head)->next = NULL;
}
//创建  头插
void CreatFromFront(LNode *head)
{
 int flag = 1;
 ElemType ch;
 LNode *s;
 while (flag)
 {
  cin >> ch;
  if (ch != 0)
  {
   s = new LNode;
   s->date = ch;
   s->next = head->next;
   head->next = s;
  }
  else
  {
   flag = 0;
  }
 }

}
//输出
void PrintLink(LNode *head)
{
 LNode *p = head->next;
 while (p)
 {
  printf("%d ", p->date);
  p = p->next;
 }
}
//从链表的结尾添加一个节点
void InsertFromTail(LNode **head,ElemType ch)
{
 LNode *p = *head;
 LNode *s = new LNode;
 s->date = ch;
 s->next = NULL;

 if (*head == NULL)
 {
  *head = s;
 }
 while (p->next != NULL)
 {
  p = p->next;
 }

 p->next = s;

}
//逆序输出链表
void TransLink_1(LNode **head)
{
 //只有头结点或者只有一个结点
 if ((*head)->next == NULL || (*head)->next->next == NULL)
 {
  return;
 }
 LNode *q, *p, *r;
 p = (*head)->next;
 q = p;
 p = q->next;
 q->next = NULL;
 while (p != NULL)
 {
  r = p->next;
  p->next = q;
  q = p;
  p = r;
 }
 (*head)->next = q;
}
void TransLink_2(LNode **head)
{
 std::stack<LNode*> nodes;
 if ((*head)->next == NULL && (*head)->next->next == NULL)
 {
  return;
 }
 LNode *p = *head;
 p = p->next;
 while (p != NULL)  
 {
  nodes.push(p);
  p = p->next;
 }
 while (!nodes.empty())
 {
  p = nodes.top();
  cout << p->date << "  ";
  nodes.pop();
 }
}
void TransLink_3(LNode **head)
{
 if (*head != NULL)
 {
  if ((*head)->next != NULL)
  {
   TransLink_3(&(*head)->next);
  }
 }
 cout << (*head)->date << endl;
}
//查找 按值查
LNode* SerchFromValue(LNode *head, ElemType ch)
{
 LNode *p = head;
 while (p->next != NULL)
 {
  p = p->next;
  if (p->date == ch)
  {
   break;
  }
 }
 return p;
}
//在O(1)时间内删除链表的节点
void DeleteNode(LNode **head, LNode *pdel)
{
 if (*head == NULL || pdel == NULL)
 {
  return;
 }
 if (pdel->next != NULL)       //多个节点 不为尾
 {
  LNode *s1 = new LNode;
  s1 = pdel->next;
  pdel->date = s1->date;
  pdel->next = s1->next;
  delete s1;
  s1 = NULL;
 }
 else if (*head == pdel)   //一个节点
 {
  delete pdel;
  pdel = NULL;
  *head = NULL;
 }
 else                      //多个节点  为结尾
 {
  LNode *s2 = new LNode;
  s2 = *head;
  while (s2 != pdel)
  {
   s2 = s2->next;
  }
  s2->next = NULL;
  delete pdel;
  pdel = NULL;
 }
}
//链表中倒数第K个节点
LNode* FindKToTail(LNode *head, int k)
{
 if (k == 0 || (head == NULL))
 {
  return NULL;
 }
 LNode *p1, *p2;
 p1 = head;
 for (int i = 1; i < k; i++)
 {
  if (p1->next != NULL)
  {
   p1 = p1->next;
  }
  else
  {
   return NULL;
  }
  
 }
 p2 = head;
 while (p1->next != NULL)
 {
  p1 = p1->next;
  p2 = p2->next;
 }
 return p2;
}
//翻转链表
void ReservrLink(LNode **head)
{
 //整个链表为空或只还有一个头结点
 if ((*head) == NULL || (*head)->next == NULL)
 {
  return;
 }
 LNode *q, *p, *r;
 p = (*head)->next;
 q = p;
 p = q->next;
 q->next = NULL;

 while (p != NULL)
 {
  r = p->next;
  p->next = q;
  q = p;
  p = r;
 }
 (*head)->next = q;
}
//尾插          无头结点
void CreatFromTail(LNode *first, LNode *s)
{
 LNode *p = first;
 while (p != NULL)
 {
  p = p->next;
 }
 LNode *index = new LNode;
 index->date = s->date;
 p->next = index;
 index->next = NULL;
}
//合并两个排序的链表
LNode * Mergr(LNode **head1, LNode **head2)
{
 LNode *pnew = NULL;
 pnew = new LNode;

 if (*head1 == NULL)
 {
  return *head2;
 }
 else if (*head2 == NULL)
 {
  return *head1;
 }
 else if (*head1 == NULL && *head2 == NULL)
 {
  return NULL;
 }
 else
 {
  if (((*head1)->date) < ((*head2)->date))
  {
   pnew = *head1;
   pnew->next =  Mergr(&((*head1)->next), &(*head2));
  }
  else
  {
   pnew = *head2;
   pnew->next = Mergr(&(*head1), &((*head2)->next));
  }
 }
 return pnew;
 /*LNode *p1 = (*head1);
 LNode *p2 = (*head2);
 LNode *pnew = NULL;
 pnew = new LNode;
 if (*head1 == NULL)
 {
  while (p2->next)
  {
   CreatFromTail(pnew, p2);
   
  }
  return NULL;
 }
 else if (*head2 == NULL)
 {
  while (p1->next)
  {
   CreatFromTail(pnew, p1);
   
  }
  return NULL;
 }
 else if (*head1 == NULL && *head2 == NULL)
 {
  return NULL;
 }
 else
 {
  if ((p1->date) < (p2->date))
  {
   CreatFromTail(pnew, p1);
   Mergr(&(pnew->next), &p2);
  }
  else
  {
   CreatFromTail(pnew, p2);
   Mergr(&p1, &(p2->next));
  }
 }
 return pnew;*/
}
//两个链表的第一个公共结点

//圈中最后剩下的数字 从0开始

void TheFirstNode(LNode *head1, LNode *head2)
{
 if (head1 == NULL || head2 == NULL)
 {
  return;
 }
 int len1 = 0;
 int len2 = 0;
 LNode *p1 = head1;
 LNode *p2 = head2;
 while (p1->next != NULL)
 {
  p1 = p1->next;
  len1++;
 }
 while (p2->next != NULL)
 {
  p2 = p2->next;
  len2++;
 }
 int indexlen = abs(len1 - len2);
 if (len1 > len2)
 {
  p1 = head1;
  p2 = head2;
 }
 else
 {
  p1 = head2;
  p2 = head1;
 }
 for (int i = 1; i < indexlen; i++)
 {
  p1 = p1->next;
 }
 if (p1 != p2)
 {
  p1 = p1->next;
  p2 = p2->next;
 }
 cout << "两个链表的第一个公共结点为" << p1->date << endl;
}
void main()
{
 LNode *head1 = NULL;
 
 IntiLink(&head1);

 CreatFromFront(head1);
 PrintLink(head1);
 cout << endl;
 /*InsertFromTail(&head,10);
 PrintLink(head);*/

 //TransLink_1(&head);
 //TransLink_2(&head);
 //TransLink_3(&head);

 /*LNode *ss = SerchFromValue(head,3);
 DeleteNode(&head,ss);
 PrintLink(head);*/

 /*LNode *ss = FindKToTail(head, 1);
 cout << ss->date << endl;*/

 //ReservrLink(&head);
 //PrintLink(head);

 /*LNode *head2 = NULL;
 IntiLink(&head2);
 CreatFromFront(head2);
 PrintLink(head2);
 cout << endl;

 //LNode * h1 = head1->next;
 //LNode * h2 = head2->next;
 LNode * pp = Mergr(&head1,&head2);
 PrintLink(pp);*/

 LNode *head2 = NULL;
 IntiLink(&head2);
 CreatFromFront(head2);
 PrintLink(head2);
 cout << endl;
 TheFirstNode(head1,head2);
}

#endif