单链表面试题

原创 已于 2022-03-14 17:06:12 修改 · 828 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#拓扑学 #c++ #数据结构

于 2014-11-19 22:07:14 首次发布
本文详细介绍了单链表的基本操作，包括结点个数的计算、逆序、求倒数第k个结点、中间结点、逆序输出、合并有序单链表、判断与求相交点、是否有环及入口点、二元查找树转双向链表、LeetCode题解等。

1.求单链表的结点个数

struct LNode
{
    int data;
    LNode *next;
};

int f(LNode *head)
{
    int k=0;
    while(head)
    {
        ++k;
        head=head->next;
    }
    return k;
}

2.单链表逆序

LNode *f(LNode *head)
{
    if(head==NULL||head->next==NULL)return head;
    LNode *pCur=head->next,*pNext;
    head->next=NULL;
    while(pCur)
    {
        pNext=pCur->next;
        pCur->next=head;
        head=pCur;
        pCur=pNext;
    }
    return head;
}

LNode *f(LNode *head)
{
    if(!head||!head->next)return head;
    LNode *prev=head,*cur=prev->next,*next=cur->next;
    while(cur)
    {
        cur->next=prev;
        prev=cur;
        cur=next;
        next=next?next->next:NULL;
    }
    head->next=NULL;
    return prev;
}

3.求单链表倒数第k个结点

LNode *f(LNode *head,int k)
{
    LNode *p=head,*q=head;
    for(;k>1&&q->next;k--)q=q->next;
    if(k>1)return NULL;
    while(q->next)
    {
        p=p->next;
        q=q->next;
    }
    return p;
}

4.求单链表的中间结点

LNode *f(LNode *head,int k)
{
    LNode *p=head,*q=head;
    while(q->next&&q->next->next)
    {
        p=p->next;
        q=q->next->next;
    }
    return p;
}

5.单链表逆序输出

void f(LNode *head)
{
    stack<int> s;
    while(head)
    {
        s.push(head->data);
        head=head->next;
    }
    while(!s.empty())
    {
        cout<<s.top()<<endl;
        s.pop();
    }
}
void f(LNode *head)
{
    if(head==NULL)return;
    f(head->next);
    cout<<head->data<<endl;
}

6.合并两个有序单链表

LNode *f(LNode *head1,LNode *head2)  
{
    LNode *head,*pCur;
    if(head1->data<=head2->data)
    {
        head=head1;
        head1=head1->next;
    }
    else 
    {
        head=head2;
        head2=head2->next;
    } 
    pCur=head;
    while(head1&&head2)  
    {  
        if(head1->data<=head2->data)  
        {  
            pCur->next=head1;  
            pCur=head1;  
            head1=head1->next;  
        }  
        else  
        {  
            pCur->next=head2;  
            pCur=head2;  
            head2=head2->next;  
        }  
    }  
    pCur->next=head1?head1:head2;  
    return head;
}

7.判断两个单链表是否相交，若相交，则求相交的第一个点。

LNode *f(LNode *head1,LNode *head2)
{
    LNode *p=head1,*q=head2;
    int length1=1,length2=1,k;
    while(p->next)
    {
        p=p->next;
        length1++;
    }
    while(q->next)
    {
        q=q->next;
        length2++;
    }
    if(p==q)
    {
        p=head1;
        q=head2;
        k=length1-length2;
        if(length1<length2)
        {
            p=head2;
            q=head1;
            k=-k;
        }
        while(k--)p=p->next;
        while(p)
        {
            if(p==q)return p;
            else
            {
                p=p->next;
                q=q->next;
            }
        }
    }
    else return NULL;
}

8.判断单链表是否有环，若有，则求环的入口点。

若slow走了s步，则fast走了2s步，设环长为r：

2s = s + nr ->

s = nr

设头结点到入口点的距离为x，入口点到相遇点的距离为y，相遇点到入口点的距离为z：

s = x + y ->

x + y = nr ->

x = nr - y -> 

x = (n-1)r + z

将fast重置成表头，slow不变，两者以相同的速度走，当slow走到入口点时，fast离入口点还有(n-1)r，经过(n-1)r后两者会在入口点相遇

LNode *f(LNode *head)
{
    LNode *slow=head,*fast=head;
    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
        if(slow==fast)break;
    }
    if(fast==NULL||fast->next==NULL)return NULL;
    slow=head;
    while(slow!=fast)
    {
        slow=slow->next;
        fast=fast->next;
    }
    return slow;
}

9.把二元查找树转变成排序的双向链表

#include<iostream>
using namespace std;    

struct node
{
	int value;
	node *left,*right;
	node(int x):value(x),left(NULL),right(NULL){}
};  

void createBinaryTree(node *&root)    
{    
    int i;    
    cin>>i;    
    if(i==0)root=NULL;    
    else    
    {  
        root=new node(i);     
        createBinaryTree(root->left);    
        createBinaryTree(root->right);    
    }    
}

void inorderTraversal(node *root,node *&tail)    
{    
    if(root)    
    {    
        inorderTraversal(root->left,tail);   
		tail->right=root;
        root->left=tail;    
		tail=root;        
        inorderTraversal(root->right,tail);    
    }    
}

node *convert(node *root)
{
	node dummy(-1);
	node *tail=&dummy;
	inorderTraversal(root,tail);
	return dummy.right;
}

int main()
{
	node *root;
	createBinaryTree(root);
	node *head=convert(root);
	for(;head;head=head->right)cout<<head->value<<' ';
	cout<<endl;
	return 0;
}

10.Leetcode

struct node
{
	int data;
	node *next;
	node(int x):data(x),next(NULL){}
};

//Add Two Numbers
node *addTwoNumbers(node *l1,node *l2)
{
	node dummy(-1);
	node *prev=&dummy;
	int carry=0;
	for(node *pa=l1,*pb=l2;pa||pb;pa=pa?NULL:pa->next,pb=!pb?NULL:pb->next,prev=prev->next)
	{
		int ai=!pa?0:pa->data;
		int bi=!pb?0:pb->data;
		int key=ai+bi+carry;
		carry=key/10;
		prev->next=new node(key%10);
	}
	if(carry>0)prev->next=new node(carry);
	return dummy.next;
}

//Reverse Linked List II
node *reverseBetween(node *head,int m,int n)
{
	 node *head2=head;
	 for(int i=0;i<m-2;++i)head2=head2->next;
	 node *prev=head2->next;
	 node *cur=prev->next;
	 for(int i=m;i<n;++i)
	 {
		 prev->next=cur->next;
		 cur->next=prev;
		 head2->next=cur;
	 }
	 return head;
}

//Partition List
node *partition(node *head,int x)
{
	node dummy1(-1);
	node dummy2(-1);
	node *cur1=&dummy1;
	node *cur2=&dummy2;
	for(node *cur=head;cur;cur->next)
	{
		if(cur->data<x)
		{
			cur1->next=cur;
			cur1=cur;
		}
		else
		{
			cur2->next=cur;
			cur2=cur;
		}
	}
	cur1->next=dummy2.next;
	cur2->next=NULL;
	return dummy1.next;
}

//Remove Duplicates from Sorted List
node *deleteDuplicates(node *head)
{
	if(!head)return head;
	node *prev=head,*cur=head->next;
	while(cur)
	{
		if(prev->data==cur->data)
		{
			prev->next=cur->next;
			delete cur;
			cur=prev->next;
		}
		else 
		{
			prev=cur;
			cur=cur->next;
		}
	}
	return head;
}

//Remove Duplicates from Sorted List II
node *deleteDuplicates(node *head)
{
	if(!head)return head;
	node dummy(-1);
	dummy.next=head;
	node *prev=&dummy,*cur=head;
	while(cur)
	{
		bool duplicated=false;
		while(cur->next&&cur->data==cur->next->data)
		{
			duplicated=true;
			node *tmp=cur;
			cur=cur->next;
			delete tmp;
		}
		if(duplicated)
		{
			node *tmp=cur;
			cur=cur->next;
			delete tmp;
		}
		else
		{
			prev=prev->next;
			cur=cur->next;
		}
	}
	prev->next=NULL;
	return dummy.next;
}

//Rotate List
node *rotateRight(node *head,int k)
{
	if(!head||k==0)return head;
	int len=1;
	node *p=head;
	while(p->next)
	{
		p=p->next;
		++len;
	}
	p->next=head;
	for(k=len-k%len;k>0;--k)p=p->next;
	head=p->next;
	p->next=NULL;
	return head;
}

//Remove Nth Node From End of List
node *removeNthFromEnd(node *head,int n) 
{
	node *p=head,*q=head;
	for(;n>0;n--)q=q->next;
	while(q->next)
	{
		p=p->next;
		q=q->next;
	}
	node *tmp=p->next;
	p->next=tmp->next;
	delete tmp;
	return head;
}

//Swap Nodes in Pairs
node *swapPairs(node *head)
{
	if(!head||!head->next)return head;
	node dummy(-1);
	dummy.next=head;
	for(node *prev=&dummy,*cur=prev->next,*next=cur->next;
		next;
		prev=cur,cur=next,next=next?next->next:NULL)
	{
		cur->next=next->next;
		next->next=cur;
		prev->next=next;
	}
}

//Reverse Nodes in k-Group
node* reverse(node *prev,node *end)
{
	node *begin=prev->next;
	for(node *p=prev->next,*q=p->next,*r=q->next;
		q!=end->next;
		p=q,q=r,r=r?r->next:NULL)q->next=p;
	begin->next=end->next;
	prev->next=end;
	return begin;
}

node *reverseKGroup(node *head,int k)
{
	if(!head||!head->next||k<2)return head;
    node dummy(-1);
	dummy.next=head;
	for(node *prev=&dummy,*end=head;end=prev->next;)
	{
		for(int i=1;i<k&&end;++i)end=end->next;
		if(!end)break;
		prev=reverse(prev,end);
	}
}

//Reorder List
node *reverse(node *head)
{
	if(!head||!head->next)return head;
	node *p=head;
	for(node *q=p->next,*r=q->next;
		q;
		p=q,q=r,r=r?r->next:NULL)q->next=p;
	head->next=NULL;
	return p;
}

void reorderList(node *head)
{
	if(!head||!head->next||!head->next->next)return;
	node *slow=head,*fast=head;
	while(fast->next&&fast->next->next)
	{
		slow=slow->next;
		fast=fast->next->next;
	}
	node *prev=slow->next;
	slow->next=NULL;
	prev=reverse(prev);
	node *p=head;
	while(p->next)
	{
		node *tmp=p->next;
		p->next=prev;
		prev=prev->next;
		p->next->next=tmp;
		p=tmp;
	}
        if(prev)p->next=prev;
}

hz5034
关注
本题要求实现一个函数，求单链表L结点的阶乘和
TaoSayHi的博客
01-10 7138
本题要求实现一个函数，求单链表L结点的阶乘和
【数据结构】单链表面试题（Java + 力扣 + 详解）
最新发布
明志の博客
07-24 1534
单链表力扣面试题
【数据结构与算法 4】单链表面试题
学Java，找哪吒
05-13 3880
一、获取到单链表的节点的个数 /* * head 链表的头节点 * 返回有效节点的个数,没有统计头节点 * */ public static int getLength(HeroNode head) { if(head.next == null) { return 0; } int length = 0; //定义一个辅助变量 HeroNode cur = head.next; while(cur != null) { length++; cur = cur.next;
单链表面试题汇总
Amber的博客
08-03 2867
之前我们实现过单链表的一些简单接口，而单链表还有一些面试题非常重要，今天来看一下一些常见面试题的实现 （注：本文调用的简单接口实现：http://blog.youkuaiyun.com/qq_34021920/article/details/76594389） 1.从尾到头打印单链表 void RPrintList(pList plist);//从尾到头打印链表(不改变链表) 从尾到头打印单链表，...
Java单链表面试题
weixin_47219685的博客
10-09 221
单链表面试题 获取单链表长度 查找单链表倒数第k个元素 单链表反转 反向打印单链表（不破坏原有单链表） 合并两个有序的单链表，合并后依然有序
java程序-单链表面试题（求有效节点数；查找第K个结点；单链表反转）
不知谓
08-18 268
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np impor..
C语言实现单链表面试题汇总
ljx_5489464的博客
03-20 2986
这篇博客只有针对单链表的不同面试题的不同函数，没有对单链表的具体实现方法的介绍。 单链表的具体实现方法（创建，初始化，前插，后插，删除，插入，销毁等），可以参考我的另一边博客： http://blog.youkuaiyun.com/ljx_5489464/article/details/50893430以下是单链表面试题的具体实现：1、从尾到头打印单链表void PrintListTailToHead(PS
单链表面试题~带环链表的入口点
jhcconan614的博客
03-19 792
昨天做了一个小总结，发现单链表这块关于带环链表漏掉了，今天就来总结一下。要寻找一个单链表的环的入口点，首先得判断一个链表是否带环，那么又怎样判断一个单链表是否带环呢？首先我们得普及一下环有什么特性，我们知道无环的单链表有首节点和尾节点，那么带环的单链表呢？显然还是有首节点的，但是没有尾节点吧。如图所示： 带环的单链表既然没有尾结点，那么要是遍历的话，就会无限循环，我们就没法通过这样来判断这是带环的
Java数据结构与算法-链表(单链表、双向链表、环形链表、约瑟夫问题)[day02]
SwaeLeeUknow的博客
09-04 658
day02-链表 单链表介绍和内存布局 链表是有序的列表，但是内存中是实际存储结构如下： 小结: 1.链表是以节点的方式来存储,是链式存储(即各个节点之间并不一定是连续存储的，而是相互指向的); 2.每个节点包含 data 域:存放数据的域， next 域：指向下一个节点; 3.如图：发现链表的各个节点不一定是连续存储; 4.链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定. 单链表(带头结点) 逻辑结构示意图如下: 单链表创建和遍历的分析实现 例子 使用带head头的单向
【单链表面试题】
qq_25355771的博客
04-24 283
面试题常见的面试题基础代码求单链表中有效节点的个数查找单链表中倒数第k个节点 [新浪]链表的反转 [腾讯]从尾到头打印单链表 [百度，要求：1.反向遍历；2.stack栈]合并两个有序的单链表，合并之后的链表依然有序。 常见的面试题 基础代码 代码： package Package01; public class SingleLinkedListDemo { public static void main(String[] args) { // 进行测试 // 先创建节
单链表面试题（一）
Hlun的博客
08-02 707
链表是最基本的数据结构，链表的相关操作也比较简单，同时它也包含了指针的运用，能把许多知识结合起来，因此链表的面试题在面试中占据很重要的地位，所以我整理了一些关于链表的面试题与大家分享。下图是其中一道求带环链表入口点题的分析图
数据结构 --- 单链表面试题
yuan_dai_ma的博客
06-25 264
数据结构 --- 单链表试题 求单链表中有效节点的个数 查找单链表中倒数第k个节点 单链表的反转 单链表的逆序打印 package linkedlist; import java.util.Stack; public class SingleLinkedListDemo1 { public static void main(String[] args) { Node a = new Node(1); Node b = new Node(2);
单链表相关的面试题
weixin_44834926的博客
10-27 152
面试题1：删除值为key的所有节点 要求只遍历一遍 public Node removeAllKey(int key) { if (this.head == null) { return null; } Node prev = this.head; Node cur = this.head.next; while (cur != null) { if (cur.data
单链表面试算法解析与实现
"这篇资源主要涉及单链表的面试中常见的算法问题，包括链表的创建、打印、求长度以及删除指定元素等操作，并提供了相应的C++代码实现。" 在计算机科学领域，单链表是一种基础的数据结构，常用于存储线性数据序列。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值