单链表的经典问题4

单链表中结点类型定义如下：

typedef struct link {
 int data;
 link* next;
}node,*linklist;

1. 设A和B是两个单链表（带头节点），其中元素递增有序，设计一个算法从A和B中公共元素产生单链表C,要求不破坏A B的结点

void fun3(linklist& A, linklist& B) {
 //设A和B是两个单链表（带头节点），其中元素递增有序，设计一个算法从A和B中公共元素产生单链表C,要求不破坏A B的结点
 node* p = A->next;
 node* q = B->next;
 linklist C = (node*)malloc(sizeof(node*));
 C->next = NULL;
 node* rear = C;//指向链表C的尾节点
 while (p && q) {
  if (p->data < q->data) {//小则后移
   p = p->next;
  }
  else if (p->data > q->data) {
   q = q->next;
  }
  else {
   node* s = (node*)malloc(sizeof(node*));
   if (rear != C && rear->data != p->data||rear==C) {
    s->data = p->data;
    s->next = rear->next;
    rear->next = s;
    rear = rear->next;
   }
   else {
    p = p->next;
    q = q->next;
   }
  }
 }
 display(C);
}

2.已知两个链表A和B分别表示两个集合，其中元素递增排列。绘制函数，求A和B的交集，并存放于A链表中。

void fun4(linklist& A, linklist& B){
//已知两个链表A和B分别表示两个集合，其中元素递增排列。绘制函数，求A和B的交集，并存放于A链表中。
 node* p = A->next;
 node* q = B->next;
 A->next = NULL;
 node* rear = A;
 while (p && q) {
  if (p->data < q->data) {//小则后移
   p = p->next;
  }
  else if (p->data > q->data) {
   q = q->next;
  }
  else {
   node* s = (node*)malloc(sizeof(node*));
   s->data = p->data;
   s->next = rear->next;
   rear->next = s;
   rear = rear->next;
   p = p->next;
   q = q->next;
  }
 }
}

3.头指针分别为la,lb的带头节点的单链表中，结点按元素递增有序排列，将la,和lb两个单链表合并成按元素递增有序的单链表，要求不另外开辟空间，la作为合并后的单链表的头节点

linklist uni_te(linklist la, linklist lb) {
//头指针分别为la,lb的带头节点的单链表中，结点按元素递增有序排列，
//将la,和lb两个单链表合并成按元素递增有序的单链表，要求不另外开辟空间，la作为合并后的单链表的头节点
 node* p = la->next;
 node* q = lb->next;
 la->next = NULL;
 node* rear = la;
 node* temp;//防止断链
 while (p && q) {
  if (p->data < q->data) {
   temp = p->next;
   p->next = rear->next;
   rear->next = p;
   rear = rear->next;
   p = temp;
  }
  else {
   temp = q->next;
   q->next = rear->next;
   rear->next = q;
   rear = rear->next;
   q = temp;
  }
 }
 if (p == NULL) {//链表A用完
  if (q != NULL) {
   rear->next = q;
  }
 }
 else {
  if (p != NULL) {
   rear->next = p;
  }
 }
 return la;
}

4.两个整数序列A=a1,a2,a3,…,am和B=b1,b2,b3,…bn已经存入两个单链表中，设计一个算法，判断序列B是否是序列A的连续子序列

int pattern(linklist A, linklist B) {
//两个整数序列A=a1,a2,a3,....,am和B=b1,b2,b3,...bn已经存入两个单链表中，设计一个算法，判断序列B是否是序列A的连续子序列
 node* p = A->next;
 node* q = B->next;
 node* pre = A->next;
 while (p&&q) {
  if (p->data == q->data) {
   p = p->next;
   q = q->next;
  }
  else {
   p = pre->next;
   pre = pre->next;
   q = B->next;
  }
    }
 if (q == NULL) {
  cout << 1 << endl;
  return 1;
 }
 else {
  cout << 0 << endl;
  return 0;
 }
 cout << 0 << endl;
 return 0;
 /*node* p = A->next;
 node* q = B->next;
 while (p) {
  if (p->data != q->data) {
   p = p->next;
  }
  else {
   node* pp = p;
   node * qq = q;
   while (pp&&qq&&pp->data==qq->data) {
    pp = pp->next;
    qq = qq->next;
   }
   if (qq == NULL) {
    cout << 1 << endl;
    return 1;
   }
   p = p->next;
  }
    }
 cout << 0 << endl;
 return 0;*/
}

5.设计一个算法用于判断带头节点的循环双链表是否对称

int flag(linklist L) {
//设计一个算法用于判断带头节点的循环双链表是否对称
 node* p = L->next;
 node* q = L->prior;
 int flag = 1;
 while (p!=q&&p->next!=q) {
  if (p->data == q->data) {
   p = p->next;
   q = q->prior;
  }
  else {
   flag = 0;
   break;
  }
 }
 return flag;

6.有两个循环单链表（不带头节点），链表头指针分别为h1和h2，编写一个函数将链表h2链接到h1之后，要求链接后的链表仍保持循环链表形式

void fun5(linklist& h1, linklist& h2) {
//有两个循环单链表（不带头节点），链表头指针分别为h1和h2，编写一个函数将链表h2链接到h1之后，要求链接后的链表仍保持循环链表形式
 node* p = h1;
 node* q = h2;
 while (p->next != h1) {
  p = p->next;
 }
 while (q->next != h2) {
  q = q->next;
 }
 p->next = h2;
 q->next = h1;
}

7.设有一个带头节点的单链表，其结点值都是正整数。设计一个算法，反复找出单链表中结点值最小的结点，并输出，然后将该结点从中删除，直到单链表为空位置，再删除表头结点

void De_all(linklist& L) {
//设有一个带头节点的单链表，其结点值都是正整数。设计一个算法，反复找出单链表中结点值最小的结点，
//并输出，然后将该结点从中删除，直到单链表为空位置，再删除表头结点
 node* p = L;
 while (p->next!= NULL) {//找到链表尾结点
  p = p->next;
 }
 p->next = L;
 while (L->next != L) {
  node* min_p = L->next;
  node* min_pre = L;
  node* pre = L;
  node* temp=NULL;
  p = L->next;
  while (p!= L) {
   if (p->data < min_p->data) {//更新最小值指针
    min_pre = pre;
    min_p = p;
   }
   pre = p;
   p = p->next;
  }
  temp = min_p;
  cout << temp->data << " ";
  min_pre->next = min_p->next;
  //free(temp);
 }
 //free(L);
}

8.已知带头节点单链表，头指针list,不改变链表的前提下设计高效的算法，查找链表中倒数第k个位置上的结点的值

int fun6(linklist list, int k) {
//已知带头节点单链表，头指针list,不改变链表的前提下设计高效的算法，查找链表中倒数第k个位置上的结点的值
 node* p = list->next;
 node* q = list->next;
 while (p) {
  if (k > 0) {
   p = p->next;
   k--;
  }
  else {
   p = p->next;
   q = q->next;
  }
 }
 if (p == NULL && k > 0) {
  cout << "k大于表的长度" << endl;
  return 0;
 }
 cout << q->data << endl;
 return 1;
 /*node* p = list;
  node* q = list;
  while (k > 0&&q->next!=NULL) {
   q = q->next;
   k--;
  }
  if (q->next == NULL && k != 0) {
   cout << "失败 k大于表长" << endl;
   return 0;
  }
  while (q) {
   p = p->next;
   q = q->next;
  }
  cout << p->data;
  return 0;*/
}