【面试经典题之链表】

1、编写代码，移除未排序链表中的重复节点（不使用临时缓冲区）

答题：使用两个指针，一个指针指向当前节点，另一个指针检测当前节点之后的所有节点，当检测指针检测到与当前节点重复的节点时，删除该节点。

void Deletesame(Node *head)

{

           if(head==NULL)

                    return;

           Node *p=head;

           while(p!=NULL)

            {

                       Node *q=p;

                       while(q->next!=NULL)

                        {

                                 if(q->next->data==p->data)

                                  {

                                             q->next=q->next->next;

                                   }

                                  else

                                  {

                                             q=q-next;

                                  }

                         }

                         p=p->next;

                  }

}

2、实现一个算法，找到一个单向链表中倒数第k个节点。

答：制定两个指针，一开始两个都指向链表第一个节点，这时第一个指针不动，第二个指针往后找当前节点后的第k-1个节点，如果第二个指针的next为空，那么说明当前第一个指针为链表的倒数底k个节点。

Node* whenkreturn(Node *head,int k)

{

          Node *p,*q;

          p=q=head;

      while(p!=NULL)

      {

          for(int i=0;i<k-1;i++)

          {

                  if(q->next==NULL)

                           return null;

                  q=q->next;

           }

          if(q->next==NULL)

                   return p;

          p=p->next;

       }

}

3、实现一个算法，删除单向链表中的某个节点，假设你只能访问该节点。

答：将节点的下一节点复制给该节点，删除下一节点。

bool deletenode(Node *p)

{

   if(p==NULL||p->next==NULL)

   {

         return false;

   }

         p->data=p->next->data;

         p->next=p->next->next;

         return true;

}

4、链表逆置算法。

void swap(node *head)

{

         int i=1;

         node *tail,*p;

         int temp;//假设节点的数据域是int型的

         tail=head;

         while(tail!=NULL)

         {

                 tail=tail->next;

                 i++;

          }

          while(i>1)

         {

                 p=head;

                 for(int j=0;j<i-1;j++)

                 {

                         t=p->data;

                         p->data=p->next->data;

                         p->next->data=t;

                         p=p->next;

                  }

                  i--;

           }

}

ps:这个算法不是最好的，看得懂就看，看不懂就算了吧。。。其实最易理解的算法就是另外定义一条链表，然后将原来的链表逆置地复制过去。。。