单链表面试题

最新推荐文章于 2022-11-12 12:28:51 发布
最新推荐文章于 2022-11-12 12:28:51 发布
阅读量222 收藏 1
点赞数 1
分类专栏： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/so1125so/article/details/99712324
版权
  •  求单链表中有效节点的个数

     

//方法：获取到单链表的节点的个数(如果是带头节点的链表，需求不统计头节点)
	/**
	 * 
	 * @param head 是链表的头节点
	 * @return  返回的是有效节点的个数
	 */
	public static int getLength(HeroNode head) {
		if(head.next == null) {
			return 0;
		}
		int count = 0;
		//这里没有统计头节点
		HeroNode cur = head.next;
		while(cur != null) {
			count++;
			cur = cur.next;
		}
		return count;
	}
  •   查找单链表的倒数第k个节点

      

//查找单链表中倒数第K个节点
	//思路：编写一个方法，接收head节点，同时接收一个 index(表示的是倒数第index个节点)
	//先把链表从头到尾遍历，得到链表的总长度length,我们重连表的的第一个开始遍历(length-index)个
	public static HeroNode getLastKth(HeroNode head, int K) {
		if(head.next == null) {
			return null;
		}
		int length = getLength(head);
		if(K<=0 || K>length) {
			return null;
		}
		HeroNode tmp = head.next;
		int count = 0;
		while(true) {
			if(count == length-K) {
				break;
			}
			if(tmp != null) {
				count++;
				tmp = tmp.next;
			}
		}
		return tmp;
	}
  •  单链表的反转

       

//将单链表进行反转
	public static void reverseList(HeroNode head) {
		if(head.next == null || head.next.next == null) {
			return ;
		}
		//定义一个辅助节点，帮助遍历原来的链表
		HeroNode current = head.next;
		HeroNode next = null; //指向当前节点[cur]的下一个节点
		HeroNode reverseHead = new HeroNode(0, "", "");
		//遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
		while(current!=null) {
			next = current.next; //先暂时保存当前节点的下一个节点
			current.next = reverseHead.next;
			reverseHead.next = current;
			current = next;
		}
		head.next = reverseHead.next;
	}
  • 逆序打印单链表（方法一：先进行反转再打印，方法二：用一个辅助栈）

  

//逆序打印单链表
	public static void reversePrint(HeroNode head) {
		if(head.next == null) {
			return;
		}
		Stack<HeroNode> stack = new Stack<HeroNode>();
		HeroNode cur = head.next;
		while(cur!=null) {
			stack.push(cur);
			cur = cur.next;
		}
		//将栈的节点进行打印
		while(stack.size()>0) {
			System.out.print(stack.pop()+" ");
		}
	}
  •      合并两个有序单链表，合并后依然有序

    

//合并两个有序的单链表，合并后依然有序
	public static void mergeList(SingleLinkedList list1, SingleLinkedList list2) {
		SingleLinkedList merge = new SingleLinkedList();
		HeroNode node1 = list1.getHead().next;
		HeroNode node2 = list2.getHead().next;
		HeroNode cur = merge.getHead();
		while(node1 != null && node2 != null) {
			if(node1.no <= node2.no) {
				cur.next = node1;
				node1 = node1.next;
				cur = cur.next;
			}else {
				cur.next = node2;
				node2 = node2.next;
				cur = cur.next;
			}
		}
		while(node1 != null) {
			cur.next = node1;
			node1 = node1.next;
			cur = cur.next;
		}
		while(node2 != null) {
			cur.next = node2;
			node2 = node2.next;
			cur = cur.next;
		}
		merge.showList();
	}
  • 全部过程

   

package com.linkedList;

import java.util.Stack;

public class SingleLinkedListDemo{
	public static void main(String[] args) {
		//测试
		//先创建节点
		HeroNode node1 = new HeroNode(1, "宋江", "及时雨");
		HeroNode node2 = new HeroNode(3, "卢俊义", "玉麒麟");
		HeroNode node3 = new HeroNode(6, "吴用", "智多星");
		HeroNode node4 = new HeroNode(8, "林冲", "豹子头");
		
		HeroNode node5 = new HeroNode(2, "宋江", "及时雨");
		HeroNode node6 = new HeroNode(3, "卢俊义", "玉麒麟");
		HeroNode node7 = new HeroNode(5, "吴用", "智多星");
		HeroNode node8 = new HeroNode(9, "林冲", "豹子头");
		//创建一个链表
		SingleLinkedList singleLinkedList = new SingleLinkedList();
		//加入
		singleLinkedList.add(node1);
		singleLinkedList.add(node2);
		singleLinkedList.add(node3);
		singleLinkedList.add(node4);
		
		singleLinkedList.showList();
		System.out.println();
		
		SingleLinkedList singleLinkedList1 = new SingleLinkedList();
		singleLinkedList1.add(node5);
		singleLinkedList1.add(node6);
		singleLinkedList1.add(node7);
		singleLinkedList1.add(node8);
		
		singleLinkedList1.showList();
		System.out.println();
		
		mergeList(singleLinkedList, singleLinkedList1);
		//加入通过编号排序
//		singleLinkedList.addByOrder(node4);
//		singleLinkedList.addByOrder(node1);
//		singleLinkedList.addByOrder(node2);
//		singleLinkedList.addByOrder(node3);
		
//		singleLinkedList.showList();
		
//		HeroNode node = new HeroNode(2, "哈哈", "啊哈哈");
//		singleLinkedList.updateNode(node);
		//显示
//		singleLinkedList.showList();
//		System.out.println();
		
//		HeroNode head = singleLinkedList.getHead();
//		System.out.println(getLength(head));
//		HeroNode res = getLastKth(singleLinkedList.getHead(), 1);
//		System.out.println(res);
//		reverseList(singleLinkedList.getHead());
//		reversePrint(singleLinkedList.getHead());
//		singleLinkedList.showList();
	}
	
	//查找单链表中倒数第K个节点
	//思路：编写一个方法，接收head节点，同时接收一个 index(表示的是倒数第index个节点)
	//先把链表从头到尾遍历，得到链表的总长度length,我们重连表的的第一个开始遍历(length-index)个
	public static HeroNode getLastKth(HeroNode head, int K) {
		if(head.next == null) {
			return null;
		}
		int length = getLength(head);
		if(K<=0 || K>length) {
			return null;
		}
		HeroNode tmp = head.next;
		int count = 0;
		while(true) {
			if(count == length-K) {
				break;
			}
			if(tmp != null) {
				count++;
				tmp = tmp.next;
			}
		}
		return tmp;
	}
	
	//方法：获取到单链表的节点的个数(如果是带头节点的链表，需求不统计头节点)
	/**
	 * 
	 * @param head 是链表的头节点
	 * @return  返回的是有效节点的个数
	 */
	public static int getLength(HeroNode head) {
		if(head.next == null) {
			return 0;
		}
		int count = 0;
		//这里没有统计头节点
		HeroNode cur = head.next;
		while(cur != null) {
			count++;
			cur = cur.next;
		}
		return count;
	}
	
	//将单链表进行反转
	public static void reverseList(HeroNode head) {
		if(head.next == null || head.next.next == null) {
			return ;
		}
		//定义一个辅助节点，帮助遍历原来的链表
		HeroNode current = head.next;
		HeroNode next = null; //指向当前节点[cur]的下一个节点
		HeroNode reverseHead = new HeroNode(0, "", "");
		//遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
		while(current!=null) {
			next = current.next; //先暂时保存当前节点的下一个节点
			current.next = reverseHead.next;
			reverseHead.next = current;
			current = next;
		}
		head.next = reverseHead.next;
	}
	
	//合并两个有序的单链表，合并后依然有序
	public static void mergeList(SingleLinkedList list1, SingleLinkedList list2) {
		SingleLinkedList merge = new SingleLinkedList();
		HeroNode node1 = list1.getHead().next;
		HeroNode node2 = list2.getHead().next;
		HeroNode cur = merge.getHead();
		while(node1 != null && node2 != null) {
			if(node1.no <= node2.no) {
				cur.next = node1;
				node1 = node1.next;
				cur = cur.next;
			}else {
				cur.next = node2;
				node2 = node2.next;
				cur = cur.next;
			}
		}
		while(node1 != null) {
			cur.next = node1;
			node1 = node1.next;
			cur = cur.next;
		}
		while(node2 != null) {
			cur.next = node2;
			node2 = node2.next;
			cur = cur.next;
		}
		merge.showList();
	}
	
	//逆序打印单链表
	public static void reversePrint(HeroNode head) {
		if(head.next == null) {
			return;
		}
		Stack<HeroNode> stack = new Stack<HeroNode>();
		HeroNode cur = head.next;
		while(cur!=null) {
			stack.push(cur);
			cur = cur.next;
		}
		//将栈的节点进行打印
		while(stack.size()>0) {
			System.out.print(stack.pop()+" ");
		}
	}
}

//定义SingleLinkedList 管理英雄人物
class SingleLinkedList{
	//先初始化头节点,不存放具体数据
	private HeroNode head = new HeroNode(0, "", "");
	
	public HeroNode getHead() {
		return head;
	}

	//添加节点到单向链表
	//当不考虑编号顺序时
	//1.找到当前链表的最后节点
	//2.将最后节点的next指向新的节点
	public void add(HeroNode node) {
		//因为head节点不能动，所以需要一个辅助节点
		HeroNode tmp = head;
		//遍历链表，找到最后
		while(true) {
			//找到链表的最后
			if(tmp.next == null) {
				break;
			}
			//如果没有找到最后，就将tmp后移
			tmp = tmp.next;
		}
		//当退出while循环时，tmp指向了链表的最后
		//将最后这个节点的next指向新的节点
		tmp.next = node;
	}
	
	//第二种方式在添加英雄时，根据排名将英雄插入到指定位置 （如果有这个排名了，则提示失败）
	public void addByOrder(HeroNode node) {
		//因为头节点不能动，因此仍然通过一个辅助变量来找到添加的位置
		//因为是单链表，需要找到添加位置的前一个节点
		HeroNode tmp = head;
		boolean flag = false; //标识添加的编号是否存在
		while(true) {
			if(tmp.next == null) {  //说明tmp已经在链表最后 
				break;
			}
			if(tmp.next.no > node.no) {  //位置找到，就在tmp的后面插入
				break;
			}else if(tmp.next.no == node.no) {  //说明编号已经存在
				flag = true;
				break;
			}
			tmp = tmp.next;   
		}
		//判断flag的值
		if(flag) {
			System.out.println("不能添加，编号存在");
		}else {
			node.next = tmp.next;
			tmp.next = node;
		}
	}
	
	//根据编号修改节点信息，根据node的编号即可
	public void updateNode(HeroNode node) {
		//判断是否空
		if(head.next == null) {
			System.out.println("链表为空");
			return;
		}
		//找到需要修改的节点，根据no
		HeroNode tmp = head;
		boolean flag = false;
		while(true) {
			if(tmp == null) {
				break; //已经遍历完链表
			}
			if(tmp.no == node.no) {
				flag = true;
				break;
			}
			tmp = tmp.next;
		}
		if(flag) {
			tmp.name = node.name;
			tmp.nickname = node.nickname;
		}else {
			System.out.println("没有找到");
		}
	}
	
	//删除节点
	//思路：
	//1.head 不能动，因此我们需要一个tmp辅助节点找到待删除节点的前一个节点
	//2.说明比较的时候是比较tmp.next.no和需要删除的no比较
	public void deleteNode(int no) {
		HeroNode tmp = head;
		boolean flag = false;
		while(true) {
			if(tmp.next == null) {
				break;
			}
			if(tmp.next.no == no) {
				flag = true;
				break;
			}
			tmp = tmp.next;
		}
		if(flag) {
			tmp.next = tmp.next.next;
			System.out.println("删除完毕");
		}else {
			System.out.println("没有找到");
		}
	}
	
	
	//显示链表[遍历]
	public void showList() {
		//判断链表是否为空
		if(head.next == null) {
			System.out.println("链表为空");
			return;
		}
		//因为头节点不能动，因此需要辅助变量来遍历
		HeroNode tmp = head.next;
		while(true) {
			//判断是否到链表最后
			if(tmp == null) {
				break;
			}
			//输出节点信息
			System.out.println(tmp.toString());
			//将tmp后移
			tmp = tmp.next;
		}
	}
}

//定义HeroNode , 每个HeroNode对象就是一个节点
class HeroNode{
	public int no;
	public String name;
	public String nickname;
	public HeroNode next;  //指向下一个节点
	
	public HeroNode(int no, String name, String nickname){
		this.no = no;
		this.name = name;
		this.nickname = nickname;
	}
	//显示方便重写toString()
	@Override
	public String toString() {
		return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
	}
	
}

 

  

 

 

 

 

 

 

 

 

 

 

 

 

  

 

 

 

so1125so
关注
专栏目录
数据结构——单链表基本操作（初始化，销毁，统计元素个数，指定位置元素，查找元素位置，求前驱后继，插入，删除，清空，遍历输出）
qq_45913371的博客
04-06 4621
数据结构——单链表基本操作（初始化，销毁，统计元素个数，指定位置元素，查找元素位置，求前驱后继，插入，删除，清空，遍历输出） 1.实验目的 通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C++语言中指针的操作。 2.实验内容：单链表基本操作（初始化，销毁，统计元素个数，指定位置元素，查找元素位置，求前驱后继，插入，删除，清空，遍历输出），用菜单形式对应各个操作，使其编程一个完整的小软件。 #include<bits/stdc++.h> using n
单项链表的介绍与其基本操作
weixin_64622048的博客
04-22 185
链表 单向链表 每个节点只保存了下一个节点的地址，只能从头开始向后遍历，这种链表结构成为单向链表，简称单链表。 节点类如何定义？ 类比火车车厢 当前车厢号和链接下一个车厢的挂钩 class Node{ int val;//当前节点的保存值。 Node next;//下一个节点的地址。 } 给定一个火车头Node head 就可以便利当前链表中所有的节点从head后开始遍历。 一个链表对象又一下部分组成： class SingleLinedList{ Node
单链表的基本操作
最新发布
m0_51697147的博客
11-12 1136
链表的存储结构在逻辑上、概念上的连续结构，但在实际的物理存储上是非连续、非顺序的。 它的存储单元以结点为单位，每一个结点由数据域和指针域两个域组成。数据域存储数据元素信息data，指针域存储直接后继存储位置next。 整个链表的存取必须从头指针开始进行，头指针指链表中第一个结点（即第一个数据元素的存储映像，也称首元结点）的存储位置。同时，由于最后一个数据元素没有直接后继，则单链表中最后一个结点的指针为空（null）。 头指针有两种情况： （1）为了方便处理，在单链表的第一个结点（首元结点）之前附
单链表的常见面试题１
nullcanon的博客
09-26 284
单链表的常见面试题： 从尾到头打印单链表 删除一个无头单链表的非尾节点（不能遍历链表） 在无头单链表的一个非头节点前插入一个节点（不能遍历链表） 单链表实现约瑟夫环(JosephCircle) 逆置/反转单链表 查找单链表的中间节点，要求只能遍历一次链表 单链表的基础操作 void PrintListTail2Head(pNode head)//倒着打印 { if(head) {
搞懂单链表常见面试题
王小六的博客
03-09 3310
搞懂单链表常见面试题 Hello 继上次的 搞懂基本排序算法，这个一星期，我总结了，我所学习和思考的单链表基础知识和常见面试题，这些题有的来自 《剑指 offer》 ,有的来自《程序员代码面试指南》，有的来自 leetCode，不是很全面，但都具有一定代表性，相信大家看完以后一定跟我一样，对面试的时候算法题又多了一份自信。 什么是单链表 链表（Linked list）是一种常...
Java单链表面试题
weixin_47219685的博客
10-09 152
单链表面试题 获取单链表长度 查找单链表倒数第k个元素 单链表反转 反向打印单链表（不破坏原有单链表） 合并两个有序的单链表，合并后依然有序
数据结构单链表面试题
ChenMeng9的博客
09-29 192
1 单链表如何逆置 逆置1 ：一直头插即可 bool Reverse(PNode plist) { assert(plist!=NULL); Node *p=plist->next; Node*q; plist->next=nullptr; //让头结点断开，方便尾部为空。 while(p!=NULL) { q=p->next; p->next=plst->next; plist->next=p; p=q; } ..
C++单链表面试题
honeyJ
11-19 1414
下面是C++中一些常见的单链表面试题，文中皆是无头单链表。 如下：我们必须构建节点，为了方便测试，我只写了尾插函数。 #include #include #include using namespace std; typedef struct Node { Node(const int& data) : _data(data) , _pNext(NULL) {} int _data
java程序-单链表面试题（求有效节点数；查找第K个结点；单链表反转）
不知谓
08-18 220
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np impor..
C语言实现单链表面试题汇总
ljx_5489464的博客
03-20 2909
这篇博客只有针对单链表的不同面试题的不同函数，没有对单链表的具体实现方法的介绍。 单链表的具体实现方法（创建，初始化，前插，后插，删除，插入，销毁等），可以参考我的另一边博客： http://blog.csdn.net/ljx_5489464/article/details/50893430以下是单链表面试题的具体实现：1、从尾到头打印单链表void PrintListTailToHead(PS
数据结构之单链表的其他基本操作
six_teen的博客
01-27 631
前面两篇文章介绍了一下单链表的增删改查，这篇文章来介绍一下单链表的一些其他基本操作。 1）统计单链表长度 2）获取单链表倒数第k个节点 3）单链表反转 4）单链表反向输出 5）两个有序单链表合并为一个单链表且仍然有序 根据前面两篇文章，应该都对单链表有一个简单的的认识，即想要操作单链表就需要一个节点指针，来指向单链表的每一个节点，要完成上面五个操作仍然需要一个节点指针，甚至还需要一个辅助指针。以下方法都不在单链表类内部，所以需要接收参数 统计单链表长度思路： 即计算单链表的节点个数，很明显需要遍历单链
【C语言】单链表相关面试题（一）
pointer_y的博客
06-26 802
先前已经写过一些单链表的基本操作：单链表的基本操作（若有兴趣可先看看链表的基本操作） 这次链表相关的面试题是建立在这个之上写的，测试的时候会调用的其中的一些函数。 今天主要说以下几个常见的链表面试题 1.查询链表中间结点 2.只给出一个位置，删除非尾结点 3.逆序链表       查询链表的中间结点，我们知道，单链表只能顺序访问，那么怎么查找中间结点呢？你可能会
数据结构——单链表的基本操作
Hierarch的博客
05-03 770
什么是链表 链表是一种链式存取得数据结构，它与数组类似，但是单链表堆内存的运用更加方便，可以在中间添加或者删除一个或者多个元素，不需要向数组那样移动大量元素。链表分为很多种，单链表，双向链表，循环链表。 单链表的建立与初始化 单链表就是一种链式存储的结构，链表中的数据是以结点来表示的，相当于是一个个节点相互连接在一起。 结点：分为两个部分，数据域与指针域，用结构体的形式来表示。如下： ...
数据结构与算法（4）
SH931662208的博客
09-16 187
栈的链式存储结构 上一次我们讲解了链式存储结构里面的基础链表，今天我们先来讲讲栈的链式存储结构，我们将它命名为LinkedStack，当然我们也要实现之前写的Stack接口里面的方法。跟我们之前线性存储结构一样，我们之前写了LinkedList，我们是不是就可以用它里面的共同特性来写栈（相当于对LinkedList封装起来）。 强调一点，Java中的LinkedList本身就是双向的。 #进栈 我...
数据结构算法题汇总
热门推荐
qq_41835813的博客
04-13 1万+
1. 在计算机中，算法是指什么？ 答案：解题方案的准确而完整的描述。 2. ，算法的四个基本特征是？ 说明：可行性、确定性、有穷性和输入输出。 3. 算法一般都可以用哪几种控制结构组合而成？ 答案：顺序、选择、循环。 4. 算法的时间复杂度是指？ 答案：算法执行过程中所需要的基本运算次数。 5. 算法的空间复杂度是指？ 答案：执行过程中所需要的存储空间。 6. 算法分析的目的是？ 答案：...
数据结构之链表（1）：单链表基本操作
C/C++攻城狮
02-18 1401
1.前言 1.1声明 文章中的文字可能存在语法错误以及标点错误，请谅解； 如果在文章中发现代码错误或其它问题请告知，感谢！ 2.关于链表 2.1什么是链表 链表可以看成一种在物理存储单元上的非连续、非顺序存储的数据结构，该数据结构中的结点（数据元素）逻辑顺序通过链表中指针链接次序实现。结点可以在程序运行是动态生成。每一个结点包括两部分：一个是存储数据元素的数据域，另一个是存...
03链表：add、size
编程语言基础知识
05-06 3608
取得元素个数：public int size();在一个链表中可以保存多个元素的数据，那么为了操作的方便就需要知道其一共保存的数据个数，所以需要有一个计数的统计操作。1.在Link类之中追加有一个统计个数的属性；private int count =0;//当前的保存个数2.随后在每次进行数据追加的时候都应该进行一个个数的累加public void add(Object data) { if...
单链表面试算法解析与实现
"这篇资源主要涉及单链表的面试中常见的算法问题，包括链表的创建、打印、求长度以及删除指定元素等操作，并提供了相应的C++代码实现。" 在计算机科学领域，单链表是一种基础的数据结构，常用于存储线性数据序列。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值