剑指offer面试题5

最新推荐文章于 2024-04-11 06:12:33 发布
最新推荐文章于 2024-04-11 06:12:33 发布
阅读量711 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 剑指offer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ahuang1900/article/details/26618583

面试题5： 从尾到头打印链表

题目： 输入一个链表的头结点，从尾到头反过来打印出每个结点的值

预备知识：

链表结点定义：

struct ListNode
{
    int       m_nValue;
    ListNode* m_pNext;
};

链表的操作有：创建结点，插入结点，删除结点，遍历结点等 

//创建链表结点
ListNode* CreateListNode(int value)
{
    ListNode* pNode = new ListNode(); //结构体起始指针（头指针）
    pNode->m_nValue = value;
    pNode->m_pNext = NULL;

    return pNode;
}
//连接链表结点
void ConnectListNodes(ListNode* pCurrent, ListNode* pNext)
{
    if(pCurrent == NULL)
    {
        printf("Error to connect two nodes.\n");
        exit(1);
    }

    pCurrent->m_pNext = pNext;
}

//输出链表结点
void PrintListNode(ListNode* pNode)
{ 
    if(pNode == NULL)
    {
        printf("The node is NULL\n");
    }
    else
    {
        printf("The key in node is %d.\n", pNode->m_nValue);
    }
}

//遍历链表并打印
void PrintList(ListNode* pHead)
{
    printf("PrintList starts.\n");
    
    ListNode* pNode = pHead;
    while(pNode != NULL)
    {
        printf("%d\t", pNode->m_nValue);
        pNode = pNode->m_pNext;
    }

    printf("\nPrintList ends.\n");
}

//销毁链表（每一个结点都要销毁）
void DestroyList(ListNode* pHead)
{
    ListNode* pNode = pHead;
    while(pNode != NULL)
    {
        pHead = pHead->m_pNext; //一个一个结点的销毁
        delete pNode;
        pNode = pHead;
    }
}

//向链表尾部添加结点
void AddToTail(ListNode** pHead, int value)
{
    ListNode* pNew = new ListNode();
    pNew->m_nValue = value; //初始化
    pNew->m_pNext = NULL;

    if(*pHead == NULL)
    {
        *pHead = pNew;
    }
    else
    {   //在结点的尾部添加
        ListNode* pNode = *pHead;
        while(pNode->m_pNext != NULL)
            pNode = pNode->m_pNext;

        pNode->m_pNext = pNew;
    }
}

//移去结点
void RemoveNode(ListNode** pHead, int value)
{
    if(pHead == NULL || *pHead == NULL)
        return;

    ListNode* pToBeDeleted = NULL;
    if((*pHead)->m_nValue == value) //刚好等于这个值
    {
        pToBeDeleted = *pHead;
        *pHead = (*pHead)->m_pNext; //指针改变
    }
    else
    {
        ListNode* pNode = *pHead;
        while(pNode->m_pNext != NULL && pNode->m_pNext->m_nValue != value)
            pNode = pNode->m_pNext; //遍历

        if(pNode->m_pNext != NULL && pNode->m_pNext->m_nValue == value) //遍历找到了这个值
        {
            pToBeDeleted = pNode->m_pNext;
            pNode->m_pNext = pNode->m_pNext->m_pNext; //指针改变
        }
    }

    if(pToBeDeleted != NULL)
    {
        delete pToBeDeleted; //销毁
        pToBeDeleted = NULL;
    }
}


思路：1. 把链表中结点的指针反过来，改变链表的反向，然后就可以从头到尾输出，但是该方法会改变原来链表的结果

            2.根据题目的要求遍历顺序是从头到尾，而输出是从尾到头，因此可以使用栈来实现这种顺序，即通过构建一个栈（后入向出）来实现，STL中有一个stack。（显栈）

            3.由于递归本质上是一个栈结构，因此可以使用递归来实现，但是当链表非常长的时候，可能导致调用栈溢出。（隐栈）

代码：

List.h

struct ListNode
{
    int       m_nValue;
    ListNode* m_pNext;
};
//使用标识符：_declspec(dllimport)表明函数是从动态库中引入的 （孙鑫VC++ 712）
__declspec( dllexport ) ListNode* CreateListNode(int value);
__declspec( dllexport ) void ConnectListNodes(ListNode* pCurrent, ListNode* pNext);
__declspec( dllexport ) void PrintListNode(ListNode* pNode);
__declspec( dllexport ) void PrintList(ListNode* pHead);
__declspec( dllexport ) void DestroyList(ListNode* pHead);
__declspec( dllexport ) void AddToTail(ListNode** pHead, int value);
__declspec( dllexport ) void RemoveNode(ListNode** pHead, int value);

List.cpp 

#include "stdafx.h"
#include "list.h"
#include <stdio.h>
#include <stdlib.h>

//创建链表结点
ListNode* CreateListNode(int value)
{
    ListNode* pNode = new ListNode(); //结构体起始指针（头指针）
    pNode->m_nValue = value;
    pNode->m_pNext = NULL;

    return pNode;
}
//连接链表结点
void ConnectListNodes(ListNode* pCurrent, ListNode* pNext)
{
    if(pCurrent == NULL)
    {
        printf("Error to connect two nodes.\n");
        exit(1);
    }

    pCurrent->m_pNext = pNext;
}

//输出链表结点
void PrintListNode(ListNode* pNode)
{ 
    if(pNode == NULL)
    {
        printf("The node is NULL\n");
    }
    else
    {
        printf("The key in node is %d.\n", pNode->m_nValue);
    }
}

//遍历链表并打印
void PrintList(ListNode* pHead)
{
    printf("PrintList starts.\n");
    
    ListNode* pNode = pHead;
    while(pNode != NULL)
    {
        printf("%d\t", pNode->m_nValue);
        pNode = pNode->m_pNext;
    }

    printf("\nPrintList ends.\n");
}

//销毁链表（每一个结点都要销毁）
void DestroyList(ListNode* pHead)
{
    ListNode* pNode = pHead;
    while(pNode != NULL)
    {
        pHead = pHead->m_pNext; //一个一个结点的销毁
        delete pNode;
        pNode = pHead;
    }
}

//向链表尾部添加结点
void AddToTail(ListNode** pHead, int value)
{
    ListNode* pNew = new ListNode();
    pNew->m_nValue = value; //初始化
    pNew->m_pNext = NULL;

    if(*pHead == NULL)
    {
        *pHead = pNew;
    }
    else
    {   //在结点的尾部添加
        ListNode* pNode = *pHead;
        while(pNode->m_pNext != NULL)
            pNode = pNode->m_pNext;

        pNode->m_pNext = pNew;
    }
}

//移去结点
void RemoveNode(ListNode** pHead, int value)
{
    if(pHead == NULL || *pHead == NULL)
        return;

    ListNode* pToBeDeleted = NULL;
    if((*pHead)->m_nValue == value) //刚好等于这个值
    {
        pToBeDeleted = *pHead;
        *pHead = (*pHead)->m_pNext; //指针改变
    }
    else
    {
        ListNode* pNode = *pHead;
        while(pNode->m_pNext != NULL && pNode->m_pNext->m_nValue != value)
            pNode = pNode->m_pNext; //遍历

        if(pNode->m_pNext != NULL && pNode->m_pNext->m_nValue == value) //遍历找到了这个值
        {
            pToBeDeleted = pNode->m_pNext;
            pNode->m_pNext = pNode->m_pNext->m_pNext; //指针改变
        }
    }

    if(pToBeDeleted != NULL)
    {
        delete pToBeDeleted; //销毁
        pToBeDeleted = NULL;
    }
}

main.cpp 

#include "stdafx.h"
#include "..\Utilities\List.h"
#include <stack>  //STL: push,pop

//方法1：构建一个栈（后进先出）来实现
void PrintListReversingly_Iteratively(ListNode* pHead)
{
    std::stack<ListNode*> nodes;

    ListNode* pNode = pHead;      //栈顶
    while(pNode != NULL)
    {
        nodes.push(pNode);       //先入栈
        pNode = pNode->m_pNext;  //指针向上移到
    }

    while(!nodes.empty())
    {
        pNode = nodes.top();            //栈顶
        printf("%d\t", pNode->m_nValue);//先输出值 
        nodes.pop(); //结点出栈，同时栈顶改变
    }
}

//方法2：递归本质上是一个栈结构，因此可以使用递归来实现
void PrintListReversingly_Recursively(ListNode* pHead) //层级过深，可能导致调用栈溢出
{
    if(pHead != NULL)
    {
        if (pHead->m_pNext != NULL)
        {
            PrintListReversingly_Recursively(pHead->m_pNext);
        }
 
        printf("%d\t", pHead->m_nValue);
    }
}

void Test(ListNode* pHead)
{
    PrintList(pHead);
    PrintListReversingly_Iteratively(pHead); //显示栈实现
    printf("\n");
    PrintListReversingly_Recursively(pHead);  //隐式栈实现
}

// 1->2->3->4->5
void Test1()
{
    printf("\nTest1 begins.\n");
	//创建单个结点
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode5 = CreateListNode(5);

	//连接链表结点
    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);

    //测试
	Test(pNode1);
	//销毁栈
    DestroyList(pNode1);
}

// 只有一个结点的链表: 1
void Test2()
{
    printf("\nTest2 begins.\n");

    ListNode* pNode1 = CreateListNode(1);

    Test(pNode1);

    DestroyList(pNode1);
}

// 空链表
void Test3()
{
    printf("\nTest3 begins.\n");

    Test(NULL);
}

int _tmain(int argc, _TCHAR* argv[])
{
    Test1();
    Test2();
    Test3();

    return 0;
}


/********************7月15日********************************/

// 面试题5.cpp : 定义控制台应用程序的入口点。
//
//面试题5：从尾到头打印链表
#include "stdafx.h"
#include <stack>

struct ListNode
{
	int			m_nKey;
	ListNode*	m_pNext;
};
/********链表的基本操作*************/
//创建结点
ListNode* CreateListNode(int value)
{
	ListNode* pNode = new ListNode();
	pNode->m_nKey = value;
	pNode->m_pNext= NULL;

	return pNode;
}

//链接结点
void ConnectListNode(ListNode* pNode1, ListNode* pNode2)
{
	if(pNode1 == NULL)
		return;
	pNode1->m_pNext = pNode2;
}

//遍历链表 
void PrintListNode(ListNode* pHead)
{
	if(pHead == NULL)
		return;
	ListNode* pNode = pHead;
	while(pNode != NULL)
	{
		printf("%d ", pNode->m_nKey);
		pNode = pNode->m_pNext;
	}
	printf("\n");
}

//销毁链表
void DestroyListNode(ListNode* pHead)
{
	ListNode* pNode = pHead;

	while(pNode != NULL)
	{	
		pNode = pNode->m_pNext;	
		delete pHead;		
		pHead = pNode;
	}

}


/************面试题5的功能****/
void PrintListReversingly_Iteratively(ListNode* pHead)
{
	std::stack<ListNode*> nodes;

	ListNode* pNode = pHead;
	while(pNode != NULL)
	{
		nodes.push(pNode); //结点入栈
		pNode = pNode->m_pNext;
	}

	while(!nodes.empty())
	{
		pNode = nodes.top();  //栈顶元素
		printf("%d ", pNode->m_nKey);
		nodes.pop();          //出栈
	}
	printf("\n");
}

void PrintListReversingly_Recursively(ListNode* pHead)
{
	if(pHead != NULL)
	{
		if(pHead->m_pNext != NULL)
			PrintListReversingly_Recursively(pHead->m_pNext);
		printf("%d ", pHead->m_nKey);
	}
}


/***********测试链表基本功能*****************/
void Test1()
{
	//创建链表结点
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode2 = CreateListNode(2);
	ListNode* pNode3 = CreateListNode(3);
	ListNode* pNode4 = CreateListNode(4);
	ListNode* pNode5 = CreateListNode(5);
	ListNode* pNode6 = CreateListNode(6);

	//连接链表结点
	ConnectListNode(pNode1,pNode2);
	ConnectListNode(pNode2,pNode3);
	ConnectListNode(pNode3,pNode4);
	ConnectListNode(pNode4,pNode5);
	ConnectListNode(pNode5,pNode6);

	//打印链表
	PrintListNode(pNode1);

	//销毁链表
	DestroyListNode(pNode1);
}

void Test2()
{
	//创建链表结点
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode2 = CreateListNode(2);
	ListNode* pNode3 = CreateListNode(3);
	ListNode* pNode4 = CreateListNode(4);
	ListNode* pNode5 = CreateListNode(5);
	ListNode* pNode6 = CreateListNode(6);

	//连接链表结点
	ConnectListNode(pNode1,pNode2);
	ConnectListNode(pNode2,pNode3);
	ConnectListNode(pNode3,pNode4);
	ConnectListNode(pNode4,pNode5);
	ConnectListNode(pNode5,pNode6);

	//打印链表
	PrintListReversingly_Iteratively(pNode1);

	//销毁链表
	DestroyListNode(pNode1);
}

void Test3()
{
	//创建链表结点
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode2 = CreateListNode(2);
	ListNode* pNode3 = CreateListNode(3);
	ListNode* pNode4 = CreateListNode(4);
	ListNode* pNode5 = CreateListNode(5);
	ListNode* pNode6 = CreateListNode(6);

	//连接链表结点
	ConnectListNode(pNode1,pNode2);
	ConnectListNode(pNode2,pNode3);
	ConnectListNode(pNode3,pNode4);
	ConnectListNode(pNode4,pNode5);
	ConnectListNode(pNode5,pNode6);

	//打印链表
	PrintListReversingly_Recursively(pNode1);
	printf("\n");
	//销毁链表
	DestroyListNode(pNode1);
}

void Test4()
{
	//创建链表结点
	ListNode* pNode1 = CreateListNode(1);

	//打印链表
	//PrintListReversingly_Iteratively(pNode1);
	PrintListNode(pNode1);
	//销毁链表
	DestroyListNode(pNode1);
}


int _tmain(int argc, _TCHAR* argv[])
{
	Test1();
	Test2();
	Test3();
	Test4();
	return 0;
}



剑指Offer —— 面试题（五）
想要进大厂的螺丝钉的博客
07-10 209
TCP协议是7层网络协议的传输层协议，负责数据的可靠传输。在建立TCP连接时，需要通过三次握手来建立，过程是：在断开TCP连接时，需要通过四次挥手来断开，过程是：零拷贝指的是，应用程序在需要把内核中的一块区域数据转移到另外一块内核区域时，不需要经过复制到用户空间，再转移到目标内核区域去，直接实现转移。应用程序直接调用TransferTo（）命令，实现转移，不需要两次复制，提高了效率。...
剑指offer之面试题5：替换空格
叶强的博客
08-21 913
1、题目 2、解题思路
剑指offer之面试题5
小鑫的博客
03-12 137
面试题5：替换空格 请实现一个函数，把字符串中每个空格替换成"%20"。例如，输入"We are happy"，则输出"We%20are%20happy." 题目说明：在网络编程中，如果 URL 参数中含有特殊字符，如空格、’#'等，则可能导致服务端无法获得正确的参数值。我们需要将这些特殊符号转换成服务器可以识别的字符。转换的规则是 % 后面加上 ASCII 码的两位十六进制的表示。比如空格的 ASCII 码是32，即十六进制的 ox20，因此空格转换成 %20。 这里我们假设字符数组中有足够的长度来扩
剑指Offer面试题5：替换空格程序调试与错误解决方法
linyuhan3232的博客
03-01 601
1.问题描述面试题5：替换空格题目：请实现一个函数，把字符串中的每个空格替换成"%20"。例如输入“We are happy.”，则输出“We%20are%20happy.”。2.程序代码：/*******************************************************************Copyright(c) 2016, Harry HeAll rights...
剑指offer-面试题5-替换空格
mxrrr_sunshine的博客
05-04 285
替换空格 题目：请实现一个函数，把字符串中的每个空格替换成%20。例如：输入“we are happy”输出“we%20are%20happy”。 拿到这个题时，第一个要考虑的就是内存够不够的问题。因为原来空格是一个字符，现在要将一个空格替换为三个字符，内存会变大。现在假设是在内存足够的情况下修改。 过程如下： 完成一个空格的替换： 完成替换： 测试用例的考虑： 正确输入：空格位于最
剑指offer面试题5-替换空格C语言.cpp
06-17
请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。输入：每个输入件仅包含一组测试样例。对于每组测试案例，输入一行代表要处理的字符...
剑指Offer精选题（含答案）.pdf
10-27
剑指Offer是针对Java面试的一本经典题目集，包含大量经典算法题目及其解答，这些题目对于应聘者在面试时应对此类问题有很大的帮助。书中题目覆盖了从基础到高级的各种难度，包括但不限于算法、数据结构、JVM知识等...
Leetcode刷题：剑指offer【面试题07】
01-20
【面试题07】重建二叉树 难度： 中等 限制： 0 <= 节点个数 <= 5000 输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 Leetcode题目对应...
基于剑指Offer编程题库的C++面试题设计源码
最新发布
02-13
基于剑指Offer编程题库的C++面试题设计源码是一个针对程序员技术面试的专项准备工具，它将常见的编程面试题目以C++语言的形式进行实现。这个项目包含了338个文件，从文件类型上看，有C++源代码文件、Markdown文件、...
剑指offer面试题25
05-23
【标题】：“剑指Offer面试题25”是关于寻找二叉树中和为特定数值的路径的问题。这个问题经常出现在编程面试中，特别是在《剑指Offer》这本书中被提及，是一道典型的二叉树遍历题目。 【描述】：描述中提到这道题目...
剑指offer第二版——面试题5（java）
冲鸭！！！
03-07 308
面试题5：替换空格 请实现一个函数，把字符串中的每个空格替换成“%20”。例如输入“We are happy”，则输出”We%20are%20happy”. 原因：在网络编程中，如果URL参数中含有特殊字符，如：空格、“#”等，可能导致服务器端无法获得正确的参数值。我们需要将这些特殊符号转换成服务器识别的字符。转换规则是在“%”后面跟上ASCII码的两位十六进制的表示。比如：空格的ASCII码...
python——《剑指 offer》面试题5:替换空格
shichunxue的博客
05-05 237
题目描述 请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。 解题思路： 为了减少时间复杂度，先遍历一遍字符串，统计空格的个数，从而计算出新字符串的长度，然后设置两个指针，分别从新旧字符串的尾部开始依次移动，如果遇到字符，那么就直接复制过来指针向前移动一个单位，如果遇到空格，则将‘%’...
剑指 Offer 05，2024年最新阿里P7级别面试经验总结
2401_84254057的博客
04-11 613
不知道你们用的什么环境，我一般都是用的Python3.6环境和pycharm解释器，没有软件，或者没有资料，没人解答问题，都可以免费领取（包括今天的代码），过几天我还会做个视频教程出来，有需要也可以领取~给大家准备的学习资料包括但不限于：Python 环境、pycharm编辑器/永久激活/翻译插件python 零基础视频教程Python 界面开发实战教程Python 爬虫实战教程Python 数据分析实战教程python 游戏开发实战教程Python 电子书100本。
剑指offer--从尾到头打印链表
m0_37666249的博客
03-22 305
从尾到头打印链表
linux内核list.h头文件分析（七）——list.h应用
sunjiangangok的博客
04-10 1779
自己把list.h源文件的代码一下部分做了手脚，下次如果在你的程序当中有用到list或者是hlist的时候，你就可以把我修改之后的内容复制一下，命名为list.h，然后在你的用户程序中写着这么一句#include "list.h"这样的话，你就可以很好的对内核链表进行使用了。改动的地方（代码中的红色部分）：1）#define LIST_POISON1  (void *) 0x0#define LI
Python实现剑指Offer面试题精选解析
资源摘要信息:"剑指Offer面试题Python实现" 《剑指Offer》是一本针对计算机程序设计面试的参考书籍，由何海涛编写，该书收集了大量的面试题，并给出了详细的解答和解题思路，涵盖了数据结构和算法的各个方面，是很...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值