剑指 Offer 30. 包含 min 函数的栈
题目:定义栈的数据结构,请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中,调用 min、push 及 pop 的时间复杂度都是 O(1)。
示例:
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.min(); --> 返回 -2.
代码实现:
/*
解题思路:
普通栈的push()和pop()函数的复杂度为O(1);而获取栈最小值min()函数需要遍历整个栈,复杂度为O(N) 。
本题难点:将 min() 函数复杂度降为O(1),可通过建立辅助栈实现;
数据栈A:栈A用于存储所有元素,保证入栈push()函数、出栈pop()函数、获取栈顶top()函数的正常逻辑。
辅助栈B:栈B中存储栈A中所有非严格降序的元素,则栈A中的最小元素始终对应栈B的栈顶元素,即min()函数只需返回栈B的栈顶元素 即可。
因此,只需设法维护好栈B的元素,使其保持非严格降序,即可实现min()函数的O(1)复杂度。
函数设计:
push(x) 函数:重点为保持栈B的元素是非严格降序的。
1、将x压入栈A(即 A.add(x) );
2、若①栈B为空或②x小于等于栈B的栈顶元素,则将x压入栈B(即 B.add(x) )。
pop() 函数:重点为保持栈A,B的 元素一致性 。
1、执行栈A出栈(即 A.pop() ),将出栈元素记为y;
2、若y等于栈B的栈顶元素,则执行栈B出栈(即 B.pop() )。
top() 函数:直接返回栈A的栈顶元素即可,即返回 A.peek() 。
min() 函数:直接返回栈B的栈顶元素即可,即返回 B.peek() 。
复杂度分析:
时间复杂度O(1):push(),pop(),top(),min()四个函数的时间复杂度均为常数级别。
空间复杂度O(N):当共有N个待入栈元素时,辅助栈B最差情况下存储N个元素,使用O(N)额外空间。
*/
//Java 代码中,由于 Stack 中存储的是 int 的包装类 Integer ,因此需要使用 equals() 代替 == 来比较值是否相等。
class MinStack {
Stack<Integer> A, B;
public MinStack() {
A = new Stack<>();
B = new Stack<>();
}
public void push(int x) {
A.add(x);
if(B.empty() || B.peek() >= x)
B.add(x);
}
public void pop() {
if(A.pop().equals(B.peek()))
B.pop();
}
public int top() {
return A.peek();
}
public int min() {
return B.peek();
}
}
剑指 Offer 35. 复杂链表的复制
题目:请实现 copyRandomList 函数,复制一个复杂链表。在复杂链表中,每个节点除了有一个 next 指针指向下一个节点,还有一个 random 指针指向链表中的任意节点或者 null。
示例1:
输入:head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出:[[7,null],[13,0],[11,4],[10,2],[1,0]]
示例2:
输入:head = [[1,1],[2,1]]
输出:[[1,1],[2,1]]
示例3:
输入:head = [[3,null],[3,0],[3,null]]
输出:[[3,null],[3,0],[3,null]]
示例4:
输入:head = []
输出:[]
解释:给定的链表为空(空指针),因此返回 null。
提示:
1、-10000 <= Node.val <= 10000
2、Node.random 为空(null)或指向链表中的节点。
3、节点数目不超过 1000 。
代码实现:
/*
解题思路:
普通链表的节点定义如下:
// Definition for a Node.
class Node {
int val;
Node next;
public Node(int val) {
this.val = val;
this.next = null;
}
}
本题链表的节点定义如下:
// Definition for a Node.
class Node {
int val;
Node next, random;
public Node(int val) {
this.val = val;
this.next = null;
this.random = null;
}
}
给定链表的头节点 head ,复制普通链表很简单,只需遍历链表,每轮建立新节点 + 构建前驱节点 pre 和当前节点 node 的引用指向即可。
本题链表的节点新增了 random 指针,指向链表中的 任意节点 或者null 。这个 random 指针意味着在复制过程中,除了构建前驱节点和当前节点的引用指向 pre.next ,还要构建前驱节点和其随机节点的引用指向 pre.random 。
本题难点: 在复制链表的过程中构建新链表各节点的 random 引用指向。
class Method{
public Node copyRandomList(Node head) {
Node cur = head;
Node dum = new Node(0), pre = dum;
while(cur != null) {
Node node = new Node(cur.val); // 复制节点 cur
pre.next = node; // 新链表的 前驱节点 -> 当前节点
// pre.random = "???"; // 新链表的 「 前驱节点 -> 当前节点 」 无法确定
cur = cur.next; // 遍历下一节点
pre = node; // 保存当前新节点
}
return dum.next;
}
}
*/
/*方法一:哈希表
利用哈希表的查询特点,考虑构建原链表节点和新链表对应节点 的键值对映射关系,再遍历构建新链表各节点的next和random引用指向即可。
算法流程:
1、若头节点head为空节点,直接返回null;
2、初始化:哈希表dic,节点cur指向头节点;
3、复制链表:
(1)建立新节点,并向dic添加键值对(原cur节点,新cur节点);
(2)cur遍历至原链表下一节点;
4、构建新链表的引用指向:
(1)构建新节点的next和random引用指向;
(2)cur遍历至原链表下一节点;
5、返回值:新链表的头节点 dic[cur] ;
复杂度分析:
时间复杂度O(N):两轮遍历链表,使用O(N)时间。
空间复杂度O(N):哈希表dic使用线性大小的额外空间。
*/
class Method1{
public Node copyRandomList(Node head) {
if(head == null) return null;
Node cur = head;
Map<Node, Node> map = new HashMap<>();
// 3. 复制各节点,并建立 “原节点 -> 新节点” 的 Map 映射
while(cur != null) {
map.put(cur, new Node(cur.val));
cur = cur.next;
}
cur = head;
// 4. 构建新链表的 next 和 random 指向
while(cur != null) {
map.get(cur).next = map.get(cur.next);
map.get(cur).random = map.get(cur.random);
cur = cur.next;
}
// 5. 返回新链表的头节点
return map.get(head);
}
}
/*方法二:拼接 + 拆分
考虑构建原节点1->新节点1->原节点2->新节点2->……的拼接链表,如此便可在访问原节点的random指向节点的同时找到新对应新节点的random指向节点。
算法流程:
1、复制各节点,构建拼接链表:
设原链表为node1→node2→⋯,构建的拼接链表如下所示:
node1→node1new→node2→node2new→⋯
2、构建新链表各节点的random指向:
当访问原节点cur的随机指向节点cur.random时,对应新节点cur.next的随机指向节点为cur.random.next 。
3、拆分原/新链表:
设置pre/cur分别指向原/新链表头节点,遍历执行pre.next=pre.next.next和cur.next=cur.next.next将两链表拆分开。
4、返回新链表的头节点res即可。
复杂度分析:
时间复杂度O(N):三轮遍历链表,使用O(N)时间。
空间复杂度O(1):节点引用变量使用常数大小的额外空间。
*/
class Method2{
public Node copyRandomList(Node head) {
if(head == null) return null;
Node cur = head;
// 1. 复制各节点,并构建拼接链表
while(cur != null) {
Node tmp = new Node(cur.val);
tmp.next = cur.next;
cur.next = tmp;
cur = tmp.next;
}
// 2. 构建各新节点的 random 指向
cur = head;
while(cur != null) {
if(cur.random != null)
cur.next.random = cur.random.next;
cur = cur.next.next;
}
// 3. 拆分两链表
cur = head.next;
Node pre = head, res = head.next;
while(cur.next != null) {
pre.next = pre.next.next;
cur.next = cur.next.next;
pre = pre.next;
cur = cur.next;
}
pre.next = null; // 单独处理原链表尾节点
return res; // 返回新链表头节点
}
}
总结:
在整理数据结构和算法的过程中遇到了很多的问题!也发现了很多的问题!最近身边的很多同学都开始找工作!有些是实习的工作,有些是正式的工作!他们在面试的过程中还是比较看重JAVA基础的,当然有些也会问到底层源码和项目!甚至是项目中框架以及数据库的使用和一些细节问题!
因此,在学习的过程中一定不要掉以轻心,争取能够理解自己所学的知识点,并在实际的项目开发中运用出来,并将它们内敛为自己的知识点!
最后,希望身边的同学和正在找工作的小伙伴们都能找到一份好的工作!
愿我们能在互联网的行业中愈走愈远!一起加油!