Pergunta da entrevista: Como encontrar rapidamente o nó do meio de uma lista vinculada individualmente de tamanho desconhecido?
fundo
Me deparei com uma pergunta de entrevista por acaso: como encontrar rapidamente o nó do meio de uma lista de encadeamento simples de comprimento desconhecido?
método
A primeira coisa que pensei foi um método de passagem muito simples e depois aprendi um método de ponteiros rápidos e lentos.
método comum
princípio
O método comum é muito simples, primeiro percorra a lista vinculada individualmente para determinar o comprimento da lista vinculada individualmente. Em seguida, comece a partir do nó principal e faça um loop N/2 vezes novamente para encontrar o nó do meio da lista encadeada individualmente.
A complexidade do algoritmo é O(N+N/2)=O(3N/2).
o código
void common_found_List(Linklist *L,int len)
{
Linklist *mid;
int i = 0;
Elemtype e;
mid = L;
len = len/2;
while(i<=len)
{
mid = mid->next;
i++;
}
e = mid->data;
printf("The middle data of the list is ：%d\n",e);
}
método avançado
Otimize o método de pesquisa comum→★★★Velocidade e ponteiro lento★★★
princípio
Defina os dois ponteiros p e mid para apontar para o nó principal da lista vinculada individualmente. Entre eles, a velocidade de movimento de p é o dobro da de mid. Quando *p aponta para o nó final, *mid também apontará para o nó intermediário.
A complexidade do algoritmo é O(N/2).
o código
void fast_slow_List(Linklist *L)
{
Linklist *f,*mid;
Elemtype e;
f = L;
mid = L;
while(f->next)
{
if(f->next->next)
{
f = f->next->next;
mid = mid->next;
}
else
{
f = f->next;
}
}
e = mid->next->data;
printf("The middle data of the list is ：%d\n",e);
}
Processo experimental e resultados
código total
//<库函数>
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<math.h>
//<相关参数的宏定义>
#define Len sizeof(Node)
#define N 20
typedef int Elemtype;
typedef struct Node
{
Elemtype data;
struct Node* next;
}Node;
typedef struct Node Linklist;
//功能函数
Linklist* Creat_L();
void Out_Linklist(Linklist *h);
void fast_slow_List(Linklist *L);
void common_found_List(Linklist *L,int len);
int Length_list(Linklist *L);
void main()
{
Linklist *L;
int k ;
int i ;
int len;
Elemtype x;
printf(" 《 Welcome to use the founction 》\n");
printf(" The founction can offer following service\n");
printf(" *******Please first Initlist*******\n\n");
printf(" 1、Initlist ->创建单链表\n");
printf(" 2、Insertlist ->输出链表长度操作\n");
printf(" 3、common_Foundlist ->普通方法查找中间元素操作\n");
printf(" 4、fast_Foundlist ->高级方法查找中间元素操作\n");
printf(" 0、Exitlist ->退出操作\n\n\n");
printf(" Please choose following digital：1、2、3、0\n");
printf(" Finish your idea!!!!!!\n");
do
{
printf("\n\nPlease Input your choice：");
scanf("%d",&k);
switch(k)
{
case 1:
{
L = Creat_L();
Out_Linklist(L);
}break;
case 2:
{
len = Length_list(L);
printf("The length of the list is：%d\n",len);
}break;
case 3:
{
len = Length_list(L);
common_found_List(L,len);
}break;
case 4:
{
fast_slow_List(L);
Out_Linklist(L);
}break;
}
}while(k!=0);
}
// <随机创建单链表>
Linklist* Creat_L()
{
int count = 0;
Linklist *h,*p,*s;
Elemtype x;
h = (Node*)malloc(Len);
h->next = NULL;
p = h;
//printf("Please Enter the FIRST Node data： ");
//scanf("%d",&x);
while(count < N) //假设终止条件
{
x = rand() % 50; //随机生成各节点，创建单链表
s = (Node*)malloc(Len);
s->data = x; //赋值
s->next = NULL;
p->next = s;
p = s;
//printf("Please Enter the NEXT Node data： ");
//scanf("%d",&x);
count++;
}
return h;
}
//<输出函数>
void Out_Linklist(Linklist *h)
{
Linklist *p;
p = h->next;
printf("Output Linklist：\n");
while(p)
{
if(p->next!=NULL)
{
printf("%d -> ",p->data);
p = p->next;
}
else
{
printf("%d",p->data);
p = p->next;
}
}
}
// <快慢指针查找函数：使用快慢指针查找中间值的操作，时间复杂度为O(N/2)>
void fast_slow_List(Linklist *L)
{
Linklist *f,*mid;
Elemtype e;
f = L;
mid = L;
while(f->next)
{
if(f->next->next)
{
f = f->next->next;
mid = mid->next;
}
else
{
f = f->next;
}
}
e = mid->next->data;
printf("The middle data of the list is ：%d\n",e);
}
//<长度函数>
int Length_list(Linklist *L)
{
int count = 0;
Linklist *p;
p = L;
while(p->next)
{
p = p->next;
count++;
}
//printf("The length of the list is：%d\n",count);
return count;
}
// <普通方法函数>
void common_found_List(Linklist *L,int len)
{
Linklist *mid;
int i = 0;
Elemtype e;
mid = L;
len = len/2;
while(i<=len)
{
mid = mid->next;
i++;
}
e = mid->data;
printf("The middle data of the list is ：%d\n",e);
}
resultado da operação
Resumir
Usar o algoritmo de ponteiro rápido e lento para encontrar os nós intermediários da lista encadeada individualmente é cerca de 3 vezes mais rápido que o algoritmo comum. Claro, não há diferença de velocidade neste exemplo, quando houver muitos elementos, haverá uma lacuna mais óbvia.
Além disso, métodos avançados irão agregar pontos durante sua entrevista! ! ! ! ! !