只允许遍历链表一遍，定位链表倒数第m个元素

    最近一某大公司面试，碰到一算法类笔试题。大致要求为：输出单链表倒数第m个元素，只允许遍历链表一遍。

    笔试时，我的想法是：遍历一遍链表，反转单链表，在反转链表的过程中，用一个指针数组保存当前链表指针（指针数组应足够大），倒转后，输出指针数组倒数第m个即可。以下是我的一个大致想法，并在vc上简单的调试通过：

     （本人解法）：

#define MAX_LIST_NODE_CNT 1024

static List *SavedList[MAX_LIST_NODE_CNT ] = {0};
static int ListLength=0;

//我的思路，在反序单链表的过程中，用一个指针数组保存链表的信息，并计算出链表的长度n，求链表倒数第m个元素只需求第n-m个链表指针数组元素的数据即可

List *list_reverse(List *head)
{
   List *Prev, *Cur, *Next; 
   Prev=head; //保存头结点指针
   Cur=Prev->next; //cur 用于保存当前访问到的结点指针，此处用户保存默认访问到第一个结点指针
   int i =0;//数组位置初始化为0
   while( Cur!=NULL )
   {
       SavedList[i] = Cur;//保存当前遍历到的结点到辅助链表数组中

       Next=Cur->next; //保存当前结点的后续结点指针

      //以下代码交换当前指针和后续指针
       Cur->next=Prev; 
       Prev=Cur; 
       Cur=Next;
       i++;   //数组位置后移   
       ++ListLength;//统计遍历到的链表结点个数
  }

    head->next=NULL;
    head=Prev;
    return head;
}

 //以下代码配合前面的代码作测试用：

List *list_create(void) //创建一个简单的单链表0-1-2-3-4-5-6-7
{
 struct List *head,*tail,*p;
 int e = 0;
 head=(List *)malloc(sizeof(List));
 tail=head;
 printf("\nList Create,input numbers(end of 0):");
 //scanf("%d\n",&e);
 while(e<8)
 {
  p=(List *)malloc(sizeof(List));
  p->data=e;
  tail->next=p;
  tail=p;
  //scanf("%d\n",&e);
  e++;
 }

 tail->next=NULL;
 return head;
}

oid main(void)
{
 struct List *head,*p;
 int d;
 head=list_create();
 printf("\n");
 for(p=head->next;p;p=p->next)
 printf("--%d--,",p->data);

 head=list_reverse(head);
 printf("\n");
 for(p=head;p->next;p=p->next)
 printf("--%d--",p->data);
    printf("链表指针数组长度为：n=%d", n);
    int i =0;
 for (i=0; i<9;i++)
 {
  if (SavedList[i] != 0)
  {
   printf("%d-->>", SavedList[i]->data );
  }
  else
  {
   printf("Error***********");
  }
 }

 printf("倒数第3个元素为%d", SavedList[n-3]->data );
}

 

     今天在网上看了一些别人的办法，觉得上述算法可能不是最佳，因为链表个数可能无限大，而指针数组大小（辅助空间最大值）必须预估和固定。因此这是一个很大的缺点。也正因为这个，我可能直接无缘这个工作机会。

     以下解法是参考某位网友的解法：

代码一：

  01 iNode * GetLastNnode(iNode * head, int n)    
02 {    
03     iNode * pfirst=head;    
04     iNode *psecond=head;    
06     int counter;    
07     //第1步：建立标尺，移动pfirst m步    
08     for(counter=0; counter 09     {    
10         if(NULL == pfirst)    
11              break; // 此时pfirst->next无意义    
12         pfirst=pfirst->next;    
13     }    
15     if( m != counter ) //长度不够n，未找到倒数第n个节点    
16         return NULL;    
18     //第2步：保持距离让标尺向右移动，直到右端指向末尾，左端即结果    
19     while(pfirst!=NULL)     
20     {    
21          pfirst=pfirst->next;    
22          psecond=psecond->next;    
23     }    
24     return psecond;    
25 }  

代码二：（同代码一类似，只是遍历用的循环方法不一样）  
28 iNode * GetLastNnode ( iNode *head, int n)    
29 {    
30     iNode * pfirst = head;    
31     iNode * psecond = NULL;//可能没有n个    
32     while( n-- > 0 && (pfirst!= NULL)    
33     {    
34         pfirst = pfirst ->next;    
35     }    
37     if(pfirst!= NULL)// 有n个节点    
38         psecond = head;    
40     while(pfirst!=NULL)    
41     {    
42          pfirst = pfirst ->next;    
43          psecond = psecond ->next;    
44     }    
45     return psecond; //只有一个出口，无论是否有n个节点，都能返回正确值    
46 } 

 

 

类似问题，一次遍历单向链表找到中间节点
某网友的解答为：和上面的思路类似，设置2个指针，一个走2步时，另一个走1步。那么一个走到头时，另一个走到中间。

01 iNode * GetMiddleNode ( iNode *head )    
02 {    
03     iNode *p1 = head;    
04     iNode *p2 = p1;    
05     while( p2 )    
06     {    
07         p2 = p2->next;    
08         if(p2)    
09         {    
10             p2 = p2->next;    
11             p1=p1->next;    
12         }    
13     }    
14     return p1;    
15 } 

  

2：找到单向链表中间的那个元素，如果有两个则取前面一个。

 

#include
using namespace std;

typedef struct node
{
    int value;
    node* next;
}Lnode,*Pnode;

int find_mid(Lnode* head)
{
    Lnode* pre,*curr;
    curr = head;
    pre = head;
    int i = 1;

    for (;curr != NULL; curr = curr->next)
    {
        if (i%2 == 0)
        {
            pre = pre->next;
        }
        i ++;
    }
    return pre->value;

}
//有头结点
int main()
{
    Lnode* head = new Lnode;
    head->next = NULL;
   
    Lnode* nod = head;
    int val;

    cout << "输入数据(int类型,以0结束): ";
    cin >> val;

    while (val != 0)
    {
        Lnode* curr = new node;
       
        curr->value = val;
        curr->next = NULL;
       
        nod->next = curr;
        nod = nod->next;

        cin >> val;
    }

    cout << "链表数据为：";
    for (Lnode* pre = head->next;pre!=NULL;pre=pre->next)
    {
        cout << pre->value  <<" ";
    }
    cout << endl;

    cout << "中间的数是：" << find_mid(head) << endl;

    return 0;
}