算法通关村】，第一关-原来链表这么有用！---白银挑战
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录
- 链表高频面试算法题
- 一、两个链表的第一个公共子节点问题！
-
- 1-1.哈希和集合
- 1-2.栈
- 2.判断链表是否为回文序列
- 3.合并有序列表
- 待完善todo
链表高频面试算法题
链表在算法题比数组少很多，而在回溯贪心动规等高级算法中很少见到链表的影子。我们这里就集中研究一些出现频率特别高的算法题！
1、两个链表的第一个公共子节点问题！
一、两个链表的第一个公共子节点问题！
输出两个链表，找出它们的第一个公告子节点。
首先在这边，我需要注意的是，链表要求是环环相扣的，核心是一个节点只能有一个后继，但是不代表一个节点只能被一个指向。
在没有思路的情况下，我们该如何解题呢？
以下为两种方式解析：
1-1.哈希和集合
hashmap的方法：
put(K key,V value) 增添数据
remove(Object Key) 根据键删除键值对元素
void clear() 移除所有的键值对元素
boolean containsKey(Object key) 判断集合是否包含指定的键
boolean containsValue(Object value) 判断集合是否包含指定的值
boolean isEmpty() 判断集合是否为空
V get(Object key)() 根据键获取值
Set keySet() 获取所有键集合
代码如下（示例）：
public static void main(String[] args) {
//创建并获取初始化链表
ListNode[] heads = initLinkedList();
//la 为 1 2 3 4 5
//lb 为 11 22 4 5
ListNode la = heads[0];
ListNode lb = heads[1];
ListNode node = new ListNode(0);
node = hhztFindFirstCommonNodeByMap(la, lb);
System.out.println("map解析公共节点为："+node.val);
node = hhztFindFirstCommonNodeBySet(la, lb);
System.out.println("set解析公共节点为："+node.val);
node = hhztFindFirstCommonNodeByStack(la, lb);
System.out.println("栈解析公共节点为："+node.val);
}
/**
* hashMap方法解析 两个链表，找出它们的第一个公告子节点
* @param listNode1
* @param listNode2
* @return
*/
public static ListNode hhztFindFirstCommonNodeByMap(ListNode listNode1,ListNode listNode2){
//判空
if (listNode1==null||listNode2==null){
return null;
}
Map<ListNode,String> nodeHashMap= new HashMap<ListNode,String>();
// Map nodeHashMap2= new HashMap<>();
//错误写法，containsKey()用法的理解错误
/*while(listNode1 != null){
nodeHashMap1.put(listNode1,null);
listNode1 = listNode1.next;
}
while(listNode2 != null){
nodeHashMap2.put(listNode2,null);
listNode2 = listNode2.next;
}
boolean b = nodeHashMap1.containsKey(nodeHashMap2);*/
ListNode node1 = listNode1;
ListNode node2 = listNode2;
//怎么循环呢？将链表的数据存入map中，难点在与 每次存入节点后，都要指向下个节点，
//每次存入节点，比如节点1-->2-->3，第一个map存入1-->2--3，第二个map存入2--3，第三个map存入3
while(node1 != null){
nodeHashMap.put(node1,null);
node1 = node1.next;
}
while(node2 != null){
if (nodeHashMap.containsKey(node2)){
return node2;
}
node2 = node2.next;
}
return null;
}
/**
* hashSet方法解析 两个链表，找出它们的第一个公告子节点
* @param listNode1
* @param listNode2
* @return
*/
public static ListNode hhztFindFirstCommonNodeBySet(ListNode listNode1,ListNode listNode2){
Set<ListNode> listNodeSet = new HashSet<ListNode>();
ListNode node1 = listNode1;
ListNode node2 = listNode2;
while(node1 != null){
listNodeSet.add(node1);
node1 = node1.next;
}
while(node2 != null){
if ( listNodeSet.contains(node2)){
return node2;
}
node2 = node2.next;
}
return null;
}
/**
* 简单构造两个链表，直接引用数据
*
* @return
*/
private static ListNode[] initLinkedList() {
ListNode[] heads = new ListNode[2];
// 构造第一个链表交点之前的元素 1 ->2-> 3
heads[0] = new ListNode(1);
ListNode current1 = heads[0];
current1.next = new ListNode(2);
current1 = current1.next;
current1.next = new ListNode(3);
current1 = current1.next;
// 构造第二个链表交点之前的元素11->22
heads[1] = new ListNode(11);
ListNode current2 = heads[1];
current2.next = new ListNode(22);
current2 = current2.next;
// 构造公共交点以及之后的元素
ListNode node4 = new ListNode(4);
current1.next = node4;
current2.next = node4;
ListNode node5 = new ListNode(5);
node4.next = node5;
ListNode node6 = new ListNode(6);
node5.next = node6;
return heads;
}
1-2.栈
栈的基本用法：
push方法：添加元素
当栈为空的时候，top 为 -1 ，当只有 1 个元素时，top 为 0
stack.push()
pop方法：弹出栈顶元素
stack.pop()
peek方法：获取栈顶元素
stack.peek()
代码如下（示例）：
/**
* 栈 方法解析 两个链表，找出它们的第一个公告子节点
* @param listNode1
* @param listNode2
* @return
*/
public static ListNode hhztFindFirstCommonNodeByStack(ListNode listNode1,ListNode listNode2){
Stack<ListNode> listNodeStack = new Stack<ListNode>();
Stack<ListNode> listNodeStack2 = new Stack<ListNode>();
ListNode node1 = listNode1;
ListNode node2 = listNode2;
while(node1 != null){
listNodeStack.push(node1);
node1 = node1.next;
}
while(node2 != null){
listNodeStack2.push(node2);
node2 = node2.next;
}
ListNode nodeNew = null;
//错误，忘记进行循环比较
// if (listNodeStack.peek()==listNodeStack2.peek()){
// nodeNew = listNodeStack.pop();
// listNodeStack2.pop();
// }
while(listNodeStack.size()>0&&listNodeStack2.size()>0){
//需要在加深理解下，栈顶数据
if (listNodeStack.peek()==listNodeStack2.peek()){
nodeNew = listNodeStack.pop();
listNodeStack2.pop();
}else {
break;
}
}
return nodeNew;
}
2.判断链表是否为回文序列
首先理解什么是回文序列：
如果一个数字序列逆置之后跟原序列是一样的，就称这样的数字序列为回文序列。
例如：
{1, 2, 1}, {15, 78, 78, 15} , {112} 是回文序列,
{1, 2, 2}, {15, 78, 87, 51} ,{112, 2, 11} 不是回文序列。
判断链表是否为回文序列
示例：
输入：1->2->2->1
输出：true
进阶：你能否用O(n)时间复杂度和O(1)空间复杂度解决此题？
package com.yugutou.charpter1;
import com.yugutou.charpter1_linklist.level2.topic2_2回文序列.IsPalindromic;
import java.util.Stack;
/**
* 判断链表是否为回文序列
* 示例：
* 输入：1->2->2->1
* 输出：true
* 进阶：你能否用O(n)时间复杂度和O(1)空间复杂度解决此题？
*/
public class HhztIsPalindromic {
public static void main(String[] args) {
int[] a = {1, 2, 3, 4, 4, 3, 2, 1};
ListNode node = initLinkedList(a);
//全部压栈
boolean b = hhztIsPalindromeByAllStack(node);
System.out.println(b);
}
static class ListNode{
public int val;
public ListNode next;
public ListNode(int a){
val = a;
next = null;
}
}
public static ListNode initLinkedList(int[] array){
//错误的初始化
// ListNode head =null;
// for (int i = 1; i < array.length; i++) {
// head = new ListNode(i);
// if (i==1){
// head.val = i;
// }else {
// head = head.next;
// }
// }
ListNode head =null,cur =null;
for (int i = 0; i < array.length; i++) {
ListNode newNode = new ListNode(array[i]);
if (i==0){
head = newNode;
cur = head;
}else{
cur.next = newNode;
cur = newNode;
}
}
return head;
}
/**
* 全部压栈 判断链表是否为回文序列
*/
public static boolean hhztIsPalindromeByAllStack(ListNode node){
//为什么不能使用listNode的泛型进行比较呢？
//Stack listNodeStack = new Stack();
Stack<Integer> listNodeStack = new Stack<Integer>();
ListNode head = node;
while (head !=null){
listNodeStack.push(head.val);
head = head.next;
}
//如何将栈中的元素进行对比呢？ 思路陷入盲区，其实思考下栈的原理就能明白，先入后出，
// 栈目前的顺序是和原始的链表顺序是相反的，我们可以进行直接出栈对比
while (node!=null){
//将链表的每个数据与另外一组出栈的数据进行比较
if (node.val != listNodeStack.pop()){
return false;
}
node = node.next;
}
return true;
}
/**
* 压栈一半 判断链表是否为回文序列
* 与全部压栈的主要区别是 Java中＞＞,＞＞=,＜＜,＜＜=运算符的使用方式
* @param node
* @return
*/
public static boolean hhztIsPalindromeByHalfStack(ListNode node){
Stack<Integer> listNodeStack = new Stack<Integer>();
ListNode head = node;
//创建一个计数的参数
int count =0;
while (head !=null){
listNodeStack.push(head.val);
head = head.next;
count++;
}
//首先我们要了解 Java中＞＞,＞＞=,＜＜,＜＜=运算符的作用
/**
1.Java语言中的 >> 意思为：逻辑右移，相当于除以2
如：8>>1、8>>2
8>>1，则是将数字8右移1位，结果为8/=4
8>>2，则是将数字8右移2位，结果为8/=2
2.Java语言中的 >>= 意思为：右移后赋值，相当于除以2
如：当x = 8时，
x >>= 2，则是x = 8/,结果x =2
x >>= 3，则是x = 8/,结果x =1
3.Java语言中的 << 意思为：逻辑左移，相当于乘2
如：2<<1、3 << 2、3<<3
2 << 1，则是将数字2左移1位，结果为2*=4
3 << 2，则是将数字3左移2位，结果为3*=12
3 << 3，则是将数字3左移3位，结果为3*=24
4.Java语言中的 <<= 意思为：左移后赋值,相当于乘2后赋值
如：当x = 5时，
x <<= 3，则是x = 5*,结果x = 40
————————————————
版权声明：本文为CSDN博主「Java大数据运动猿」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_51697147/article/details/128601518
*/
//计数的长度除以2
count >>=1;
//如何将栈中的元素进行对比呢？ 思路陷入盲区，其实思考下栈的原理就能明白，先入后出，
// 栈目前的顺序是和原始的链表顺序是相反的，我们可以进行直接出栈对比
while (count-- >=0){
//将链表的每个数据与另外一组出栈的数据进行比较
if (node.val != listNodeStack.pop()){
return false;
}
node = node.next;
}
return true;
}
}
3.合并有序列表
待完善todo
判断链表是否为回文序列的实现方式，双指针，递归