链表实现比较高效的删除倒数第k项

最近写链表不太顺，无限的段错误。今天中午写的链表删除倒数第k项，用的带尾节点的双向链表，感觉已经把效率提到最高了，还是超时，改了很多方法都不行，最

终决定看博客，发现原来是审题错了，样例给的是以-1结束，我就天真的以为到-1结束，原来题目写的到负数结束，服了。。

先把我觉得最高效的代码贴上：思路是用带尾节点的双向链表存数据，在找倒数第k项时，如果超过表长，直接NULL，如果小于表长除以2，从尾指针往前找，如果大

于，从头指针往后找：

 //解法一：带尾节点的双向链表
 #include<stdio.h>
 #include<stdlib.h>
 #include<malloc.h>
 //using namespace std;
 //输入数据，从尾节点，用prior指针向左移K-1位
 //注意：遇到头结点，即为不存在，输出NULL

 #define OK 1
 #define ERROR 0
 //#define
 typedef int ElemType;
 typedef int Status;

 typedef struct DuLNode
 {
     ElemType data;
     DuLNode *prior;//前驱
     DuLNode *next;//后继
 }DuLNode,*DuLink;

 typedef struct
 {
     DuLink head;//头指针
     DuLink tail;//尾指针
     int length;
 }DuLinkList;//它是结构体类型

 Status Create_DuL_ht(DuLinkList &L)//摸索
 {
     L.head=(DuLNode*)malloc(sizeof(DuLNode));
     L.head->next=NULL;
     L.head->prior=NULL;
     L.tail=L.head;//应该是这么初始化吧
     L.length=;

     DuLNode *cur=(DuLNode*)malloc(sizeof(DuLNode));//开新节点
     cur->next=L.head;//指向头结点
     scanf("%d",&cur->data);
     while(cur->data>=)
     {
         cur->next=L.head;
         L.tail->next=cur;
         cur->prior=L.tail;
         L.tail=cur;
         L.head->prior=L.tail;
         ++L.length;

         cur=(DuLNode*)malloc(sizeof(DuLNode));
         cur->next=L.head;
         scanf("%d",&cur->data);

     }

     return OK;

 }

 Status CountBack_k(DuLinkList &L,int k)
 {//用计数器从tail往前找，只要没遇到倒数第k项且没遇到头结点，就前移；
     if(k>L.length)
     {
         printf("NULL");
         return OK;
     }
     DuLNode *p;
     if(k<L.length/)
     {
      int i=;
      p=L.tail;
      while(p!=L.head&&i<k)
      {
          p=p->prior;
          ++i;
      }

     }
     else
     {
         int i=;
         p=L.head->next;
         k=L.length-k+;
         while(p!=L.head&&i<k)
         {
             p=p->next;
             ++i;
         }
     }

      printf("%d",p->data);

      return OK;

 } 

 int main()
 {
     DuLinkList L;
     int k;
     scanf("%d",&k);
     Create_DuL_ht(L);
     //printf("%d",L.tail->prior->data);//创建函数没有错误
     CountBack_k(L,k);

     return ;
 }//

方法二是用伴随指针，让它与遍历指针相距k个结点，当遍历指针NULL，它就到了倒数第k项（这个方法是老师教的）

：

 /*
 //解法二，普通单链表
 #include<stdio.h>
 #include<stdlib.h>
 #include<malloc.h>
 #define OK 1
 #define ERROR 0
 //#define
 typedef int ElemType;
 typedef int Status;

 typedef struct LNode
 {
     ElemType data;
     LNode *next;
 }LNode,*LinkList;

 Status Creat_L(LinkList &L)
 {
     L=(LNode*)malloc(sizeof(LNode));
     L->next=NULL;

     LNode *rear,*cur;
     rear=L;
     cur=(LNode*)malloc(sizeof(LNode));
     scanf("%d",&cur->data);//cin>>cur->data;
     cur->next=NULL;

     while(cur->data!=-1)
     {
         rear->next=cur;
         rear=cur;

         cur=(LNode*)malloc(sizeof(LNode));
         scanf("%d",&cur->data);
         cur->next=NULL;

     }

     return OK;
 }

 Status CountBack_k(LinkList &L,int k)
 {
     LNode *p,*q;
     p=L->next;
     q=NULL;
     int i=0;
     while(p)
     {
         p=p->next;
         i++;
         if(i==k)
         q=L->next;
         if(i>k)
         q=q->next;

     }

     if(q)
     printf("%d",q->data);//cout<<q->data;
     else
     printf("NULL");//cout<<"NULL";

 }

 int main()
 {
     LinkList L;
     int k;
     scanf("%d",&k);//cin>>k;
     Creat_L(L);
     //cout<<L->next->next->data;输入函数没问题
     CountBack_k(L,k);
 }//
 */

审题还是很重要的，不要看了样例就写啊。。。。。