怒刷LeetCode的第10天（Java版）

2023-09-21 14:39:51

目录

第一题

题目来源

题目内容

解决方法

方法一：两次拓扑排序

第二题

题目来源

题目内容

解决方法

方法一：分治法

方法二：优先队列（Priority Queue）

方法三：迭代

第三题

题目来源

题目内容

解决方法

方法一：迭代

方法二：递归

方法三：双指针

方法四：栈

第一题

题目来源

2603. 收集树中金币 - 力扣（LeetCode）

题目内容

解决方法

方法一：两次拓扑排序

这个解法的思路如下：

  1. 首先，初始化一个邻接表 g，用于存储树的结构，以及一个数组 degree，用于记录每个节点的度数。
  2. 遍历边的数组 edges，将每条边的两个节点之间建立连接关系，并更新节点的度数。
  3. 初始化一个队列 queue，用于存储无金币的叶子节点。
  4. 遍历所有节点，如果一个节点的度数为1并且该节点没有金币，则将其加入队列。
  5. 开始循环，直到队列为空。在每次迭代中，取出队列的首个节点 u。
  6. 将节点 u 的度数减1，剩余节点数 rest 减1。
  7. 遍历与节点 u 相邻的所有节点 v，将其度数减1。
  8. 如果节点 v 的度数为1并且该节点没有金币，则将其加入队列。
  9. 重复步骤 5-8，直到队列为空。
  10. 重复两次以下步骤（总共遍历两次）： a. 初始化一个新的队列 queue。 b. 遍历所有节点，将度数为1的节点加入队列。 c. 开始循环，直到队列为空。 d. 取出队列的首个节点 u，将其度数减1，剩余节点数 rest 减1。 e. 遍历与节点 u 相邻的所有节点 v，将其度数减1。 f. 重复步骤 d-e，直到队列为空。
  11. 返回结果，如果剩余节点数 rest 为0，则路径长度为0；否则，路径长度为 (rest - 1) * 2。

这样，通过删除树中无金币的叶子节点和维护节点的度数，可以得到最小路径长度。

class Solution {
    public int collectTheCoins(int[] coins, int[][] edges) {
        int n = coins.length;
        List<Integer>[] g = new List[n];
        for (int i = 0; i < n; ++i) {
            g[i] = new ArrayList<Integer>();
        }
        int[] degree = new int[n];
        for (int[] edge : edges) {
            int x = edge[0], y = edge[1];
            g[x].add(y);
            g[y].add(x);
            ++degree[x];
            ++degree[y];
        }

        int rest = n;
        /* 删除树中所有无金币的叶子节点，直到树中所有的叶子节点都是含有金币的 */
        Queue<Integer> queue = new ArrayDeque<Integer>();
        for (int i = 0; i < n; ++i) {
            if (degree[i] == 1 && coins[i] == 0) {
                queue.offer(i);
            }
        }
        while (!queue.isEmpty()) {
            int u = queue.poll();
            --degree[u];
            --rest;
            for (int v : g[u]) {
                --degree[v];
                if (degree[v] == 1 && coins[v] == 0) {
                    queue.offer(v);
                }
            }
        }
        /* 删除树中所有的叶子节点, 连续删除2次 */
        for (int x = 0; x < 2; ++x) {
            queue = new ArrayDeque<Integer>();
            for (int i = 0; i < n; ++i) {
                if (degree[i] == 1) {
                    queue.offer(i);
                }
            }
            while (!queue.isEmpty()) {
                int u = queue.poll();
                --degree[u];
                --rest;
                for (int v : g[u]) {
                    --degree[v];
                }
            }
        }

        return rest == 0 ? 0 : (rest - 1) * 2;
    }
}

复杂度分析：

1、构建邻接表和计算节点度数的复杂度：

  • 遍历边的数组 edges，时间复杂度为 O(m)，其中 m 是边的数量。
  • 初始化邻接表 g 的空间复杂度为 O(n)，其中 n 是节点的数量。
  • 更新节点度数的过程需要遍历所有边，时间复杂度为 O(m)。

2、删除无金币叶子节点的过程的复杂度：

  • 初始化队列的时间复杂度为 O(n)，其中 n 是节点的数量。
  • 每个节点最多被处理一次，因此删除过程的时间复杂度为 O(n)。

3、连续删除两次叶子节点的过程的复杂度：

  • 需要进行两次完整的节点遍历，因此时间复杂度为 O(2n) = O(n)，其中 n 是节点的数量。

综上所述，整个解法的时间复杂度为 O(m + n)，其中 m 是边的数量，n 是节点的数量。空间复杂度为 O(n)，用于存储邻接表和节点度数。

LeetCode运行结果：

第二题

题目来源

23. 合并 K 个升序链表 - 力扣（LeetCode）

题目内容

解决方法

方法一：分治法

这是一个合并K个升序链表的问题，可以使用分治法来解决。使用了分治法来将k个链表分成两部分进行合并，然后再将合并后的结果继续与剩下的链表合并，直到最终合并成一个升序链表。在每个合并的过程中，可以使用双指针来逐个比较两个链表的节点值，将较小的节点连接到结果链表上。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
public class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }

        return merge(lists, 0, lists.length - 1);
    }

    private ListNode merge(ListNode[] lists, int start, int end) {
        if (start == end) {
            return lists[start];
        }

        int mid = start + (end - start) / 2;
        ListNode left = merge(lists, start, mid);
        ListNode right = merge(lists, mid + 1, end);

        return mergeTwoLists(left, right);
    }

    private ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        }
        if (l2 == null) {
            return l1;
        }

        if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

复杂度分析：

  • 这个解法的时间复杂度是 O(Nlogk)，其中 N 是所有链表的节点总数，k 是链表的数量。因为在每层合并的过程中，需要遍历 N 个节点来比较值，并且每次合并的链表数量减半，因此总共需要合并 logk 层。所以时间复杂度是 O(Nlogk)。
  • 空间复杂度是 O(logk)，主要是递归调用栈的空间。在每一层递归中，都会创建两个新的递归函数调用，所以递归的层数最多是 logk。因此，空间复杂度是 O(logk)。

需要注意的是，这里的空间复杂度是指除了返回的合并后的链表之外的额外空间使用量。

LeetCode运行结果：

方法二：优先队列（Priority Queue）

使用了优先队列来维护当前k个链表中的最小节点。首先，将所有链表的头节点加入到优先队列中。然后，不断从优先队列中取出最小的节点，将其加入到合并后的链表中，并将该节点的下一个节点加入到队列中。重复这个过程直到队列为空。 

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
public class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }

        // 创建一个优先队列，按照节点值的大小进行排序
        PriorityQueue<ListNode> queue = new PriorityQueue<>((a, b) -> a.val - b.val);

        // 将所有链表的头节点加入到优先队列中
        for (ListNode node : lists) {
            if (node != null) {
                queue.offer(node);
            }
        }

        // 创建一个dummy节点作为合并后的链表头部
        ListNode dummy = new ListNode(0);
        ListNode curr = dummy;

        // 不断从优先队列中取出最小的节点，将其加入到合并后的链表中，然后将该节点的下一个节点加入到队列中
        while (!queue.isEmpty()) {
            ListNode node = queue.poll();
            curr.next = node;
            curr = curr.next;

            if (node.next != null) {
                queue.offer(node.next);
            }
        }

        return dummy.next;
    }
}

复杂度分析：

  • 这个基于优先队列的解法的时间复杂度是O(Nlogk)，其中N是所有链表的节点总数，k是链表的数量。主要的时间消耗在于构建优先队列和从队列中取出最小节点，而构建优先队列的时间复杂度是O(klogk)，每次取出最小节点的操作时间复杂度是O(logk)。由于总共需要取出N个节点，因此总体的时间复杂度是O(Nlogk)。
  • 空间复杂度是O(k)，主要是优先队列所占用的空间。在最坏情况下，优先队列中最多会有k个节点，因此空间复杂度是O(k)。

需要注意的是，这里的空间复杂度是指除了返回的合并后的链表之外的额外空间使用量。

LeetCode运行结果：

方法三：迭代

使用了迭代的方式逐一合并链表。

  1. 首先设定一个变量 interval，初始值为1，表示每次合并的链表数量。
  2. 然后进行循环，直到 interval 大于等于链表数组的长度。在每次循环中，按照 interval 的步长对链表数组进行逐一合并。每次合并两个链表，将合并结果放回原始数组的相应位置。
  3. 通过每次将 interval 值翻倍，循环进行迭代合并，直到 interval 大于等于链表数组的长度，最终得到合并后的链表。
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }
        
        int interval = 1;
        while (interval < lists.length) {
            for (int i = 0; i + interval < lists.length; i += 2 * interval) {
                lists[i] = mergeTwoLists(lists[i], lists[i + interval]);
            }
            interval *= 2;
        }
        
        return lists[0];
    }
    
    private ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(0);
        ListNode curr = dummy;
        
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                curr.next = l1;
                l1 = l1.next;
            } else {
                curr.next = l2;
                l2 = l2.next;
            }
            curr = curr.next;
        }
        
        if (l1 != null) {
            curr.next = l1;
        }
        
        if (l2 != null) {
            curr.next = l2;
        }
        
        return dummy.next;
    }
}

复杂度分析：

  • 时间复杂度：这个解法的时间复杂度是O(Nklogk)，其中N是每个链表的平均长度，k是链表的数量。通过每次将 interval 值翻倍，循环进行迭代合并，直到 interval 大于等于链表数组的长度，最终得到合并后的链表。在每一层循环中的操作总时间复杂度仍然是O(Nk)，因为每一层的合并操作需要遍历所有链表节点。
  • 空间复杂度：这个解法的空间复杂度是O(1)，没有使用额外的数据结构。只需要常数级别的额外空间来保存临时变量。

综上所述，优先队列解法和分治法解法的时间复杂度相同，但优先队列解法的空间复杂度略高于分治法解法。而迭代解法的时间复杂度稍高于前两种解法，并且空间复杂度较低。

LeetCode运行结果：

第三题

题目来源

24. 两两交换链表中的节点 - 力扣（LeetCode）

题目内容

解决方法

方法一：迭代

迭代的思路是遍历链表，每次处理两个相邻节点进行交换。具体步骤如下：

1、定义一个哑节点(dummy)作为新链表的头节点，并将其指向原始链表的头节点head。

2、定义一个指针prev指向哑节点，用于连接新链表中的节点。

3、当原始链表中至少有两个节点时，重复以下操作：

  • 使用指针curr1指向当前要交换的第一个节点，即prev.next。
  • 使用指针curr2指向当前要交换的第二个节点，即curr1.next。
  • 将prev的下一个节点指向curr2，完成节点交换。
  • 将curr1的下一个节点指向curr2的下一个节点，完成节点交换。
  • 将curr2的下一个节点指向curr1，完成节点交换。
  • 更新prev指针和curr1指针，使它们分别指向交换后的第二个节点和下一组要交换的第一个节点。

4、返回哑节点(dummy)的下一个节点作为新链表的头节点。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
public ListNode swapPairs(ListNode head) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode prev = dummy;
    
    while (head != null && head.next != null) {
        ListNode curr1 = head;
        ListNode curr2 = head.next;
        
        prev.next = curr2;
        curr1.next = curr2.next;
        curr2.next = curr1;
        
        prev = curr1;
        head = curr1.next;
    }
    
    return dummy.next;
}

}

复杂度分析：

  • 时间复杂度：O(n)，其中n是链表中的节点数。需要遍历链表中的每个节点一次。
  • 空间复杂度：O(1)。只需要常数级别的额外空间。

LeetCode运行结果：

方法二：递归

递归的思路是将链表分成两部分：第一个节点和剩余节点。然后，交换这两部分，并递归地对剩余节点进行两两交换。具体步骤如下：

  1. 当链表为空或只有一个节点时，无需交换，直接返回该节点。
  2. 令first指向链表的头节点，second指向first的下一个节点。
  3. 交换first和second节点，即将second的next指向first，并将first的next指向递归处理剩余节点的结果。
  4. 返回second节点作为新链表的头节点。
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
public ListNode swapPairs(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    
    ListNode first = head;
    ListNode second = head.next;
    
    first.next = swapPairs(second.next);
    second.next = first;
    
    return second;
}
}

复杂度分析：

  • 时间复杂度：O(n)，其中n是链表中的节点数。每次递归都会处理一个节点，并且递归调用的层数最多为n/2。
  • 空间复杂度：O(n)，其中n是链表中的节点数。递归调用的栈空间最多为n/2。

LeetCode运行结果：

方法三：双指针

除了递归和迭代之外，还可以使用双指针的方法来交换链表中的节点。该方法使用两个指针prev和curr分别指向当前要交换的两个节点的前一个节点和第一个节点。通过不断地交换节点，并更新指针，实现链表中节点的两两交换。

注意：它与迭代方法的思路类似，但在细节上有所改动。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
public ListNode swapPairs(ListNode head) {
    // 创建哑节点(dummy)作为新链表的头节点，并将其指向原始链表的头节点head
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    
    // 定义两个指针prev和curr，分别指向当前要交换的两个节点的前一个节点和第一个节点
    ListNode prev = dummy;
    ListNode curr = head;
    
    while (curr != null && curr.next != null) {
        // 获取要交换的两个节点
        ListNode node1 = curr;
        ListNode node2 = curr.next;
        
        // 进行节点交换
        prev.next = node2;
        node1.next = node2.next;
        node2.next = node1;
        
        // 更新prev和curr指针，进行下一组节点交换
        prev = node1;
        curr = node1.next;
    }
    
    return dummy.next;
}

}

复杂度分析：

  • 时间复杂度：O(n)  遍历链表中的每个节点一次，所以时间复杂度是线性的。
  • 空间复杂度：O(1)  只使用了常数级别的额外空间，不随输入规模增加而变化。

LeetCode运行结果：

方法四：栈

除了递归、双指针和迭代之外，还可以使用栈来实现链表节点的两两交换。

这种栈的方法将链表中的节点依次入栈，每次栈中至少有两个节点时，就进行交换操作。通过维护栈来实现链表节点的两两交换。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
public ListNode swapPairs(ListNode head) {
    // 创建一个栈
    Deque<ListNode> stack = new ArrayDeque<>();
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    
    ListNode curr = dummy;
    
    while (curr != null && curr.next != null) {
        // 将当前节点的后继节点和后继的后继节点入栈
        stack.push(curr.next);
        stack.push(curr.next.next);
        
        // 当栈中至少有两个节点时，进行节点交换
        if (stack.size() >= 2) {
            curr.next = stack.pop();
            curr.next.next = stack.pop();
            curr = curr.next.next;
        } else {
            break;
        }
    }
    
    return dummy.next;
}

}

复杂度分析：

  • 时间复杂度：O(n)，其中 n 是链表的长度。需要遍历链表中的每个节点一次。
  • 空间复杂度：O(n)，需要使用一个栈来存储节点。

需要注意的是，递归的深度与链表的长度相关，当链表较长时可能会导致栈溢出，因此在实际使用时需要注意链表的长度限制。如果链表长度较大，建议使用其他方法实现节点的交换。

LeetCode运行结果：

更多推荐

Vue学习笔记

本博客记录Vuev2.7.8的学习，参考文档目录Vue概述入门案例Vue指令v-bind和v-modelv-onv-if和v-showv-for综合案例生命周期Vue概述一个完整的html页面包括了视图和数据，数据是通过请求从后台获取的，那么意味着我们需要将后台获取到的数据呈现到页面上，很明显，这就需要我们使用DOM操

机器学习的基本代码

步骤1：导入必要的库```pythonimportpandasaspdfromsklearn.feature_extraction.textimportCountVectorizerfromsklearn.naive_bayesimportMultinomialNBfromsklearn.metricsimportac

易基因直播预告｜细菌微生物基因表达调控表观研究易基因科技

大家好，这里是专注表观组学十余年，领跑多组学科研服务的易基因。DNA甲基化是在半个多世纪前在细菌中发现的。DNA碱基可以作为一个表观遗传调节因子——也就是说，它可以赋予相同的基因序列不同的和可逆的调控状态。在真核生物中，表观遗传调控可以发生在多个水平上：DNA甲基化、核小体定位、组蛋白变异和组蛋白修饰。相比之下，细菌缺

【云原生】kuberneter中Helm入门到实践

引言helm是k8s的包管理工具，使用helm，可以使用更为简化和系统化的方式对k8s应用进行部署、升级。helm是CNCF已毕业的项目，社区也是相当活跃的，在https://artifacthub.io/上，能找到很多现成的helmchart，稍作修改就能用到生产环境中，非常方便。本文会介绍helm的核心概念，并用一

Vim的基础操作

前言本文将向您介绍关于vim的基础操作基础操作在讲配置之前，我们可以新建一个文件.vimrc，并用vim打开在里面输入setnu先给界面加上行数，然后shift+；输入wq退出默认打开：命令模式本文将下来会主要讲这几种模式，当然vim还有其他一些特殊模式，但是比较少用在命令模式中：h：向左移动j：向下移动k：向上移动L

自学 Java 需要具备哪些基本条件或技能？

新手初学者在自己学习Java时，需要注意两个方面，一个是学习方面，一个是知识点方面！学习方面：1、做学习计划并保持自律在我们学习Java的过程中，尽量减少干扰，把自己的全部注意力集中在Java上。无论你注意力的持续时间是多久，都应该将全部精力放在Java上。2、通过编码来学习很多新手在学习Java时都会经历一个阶段，那

vue中通过JavaScript实现web端鼠标横向滑动&触控板滑动效果-demo

JavaScript实现web端鼠标横向滑动&触控板滑动效果支持鼠标拖动滑动&触控板滑动效果web端实现滑动，就是对鼠标按下、鼠标松开、鼠标移动事件进行监听效果图代码结构代码<template><divclass="swiper"><divclass="container"ref="container"><!--在这里

计算机视觉与深度学习-全连接神经网络-训练过程-批归一化- [北邮鲁鹏]

文章目录思想批归一化操作批归一化与梯度消失经过BN处理算法实现思想直接对神经元的输出进行批归一化批归一化：对输出值进行归一化，将归一化结果平移缩放作为输出。批归一化操作小批量梯度下降算法回顾：每次迭代时会读入一批数据，比如32个样本；经过当前神经元后会有32个输出值y1,…y32。批归一化操作：对这32个输出进行减均值

Java实现Modbus Tcp协议读写模拟工具数据

标题前言一、读写模拟工具中数据(1)定义Controller层(2)定义Service层实现二、调试(1)读数据(2)向寄存器写单个数据(3)向寄存器写多个数据前言参考文章：https://www.cnblogs.com/ioufev/p/10831289.html该文中谈及常见的几种读取设备数据实现，说到modbus

【CNN-FPGA开源项目解析】01--floatMult16模块

文章目录(基础)半精度浮点数的表示和乘运算16位半精度浮点数浮点数的乘运算floatMult16完整代码floatMult16代码逐步解析符号位sign判断指数exponent计算尾数fraction计算尾数fraction的标准化和舍位整合为最后的16位浮点数结果[sign,exponent,fraction]其他变

MySQL数据库

1、数据库的基本概念1.1数据·描述事物的符号记录·包括数字、文字、图形、图像、声音、档案记录等·以“记录”形式按统一的格式进行存储1.2表·将不同的记录组织在一起的·用来存储具体数据1.3数据库​​·表的集合，是存储数据的仓库·以一定的组织方式存储的相互有关的数据集合1.4数据库管理系统·是实现对数据库资源有效组织、

热文推荐
  1. HashMap：Java中的高性能键值对存储

    一、前言HashMap是Java中最常用的数据结构之一，用于存储键值对，提供了快速的数据检索和插入操作。本文将深入探讨HashMap的内部原理、用法、常见面试问题以及源码分析。二、HashMap的内部工作原理2.1哈希表HashMap的核心是哈希表，它是一个数组，用于存储键值对。哈希表的每个位置称为"桶"，每个桶可以存

  2. Http和Https

    Http和Https1.URI和URLURI（UniformResourceIdentifier）：统一资源标识符，标识资源，可以是相对路径也可以绝对路径表示。绝对路径：http://www.example.com/images/logo.png相对路径：/image/logo.pngURL（UniformResour

  3. Java8实战-总结28

    Java8实战-总结28用流收集数据收集器接口理解Collector接口声明的方法全部融合到一起用流收集数据收集器接口Collector接口包含了一系列方法，为实现具体的归约操作（即收集器）提供了范本。Collector接口中实现了许多收集器，例如toList或groupingBy。这也意味着，可以为Collector

  4. MongoDB

    1.安装dockerrun--restart=always-d--namemongo-v/home/206/mongodb/data:/data/db-p27017:27017mongo:4.0.62.建立数据库3.MongoDB使用基于SpringBoot使用3.1引用依赖包<!--SpringDataMongoDB

  5. 数据湖是什么？数据湖架构及应用（完）

    数据湖架构数据湖架构主要描述了各组件以及组件之间的关系，说明了数据的存储、处理和访问过程。数据湖架构研究最初主要涉及到数据的划分、管理和使用方式，随着研究的进展数据湖的架构包含了更深层次的关键技术和方案。分区架构在初始的数据湖设计中，数据预处理扮演着极为关键的角色，其中最核心的架构为池架构与分区架构。池架构将数据根据不

  6. 【计算机网络】 TCP流量控制——滑动窗口和累积应答

    文章目录累积应答TCP流量控制——滑动窗口累积应答我们前面所说的是我们每发送一个包对端就要回一个ack，那么这样效率太慢了，我们这里就有一个累积应答的机制，就是说我们客户端累积发送多个包，然后服务端再统一进行回复。TCP流量控制——滑动窗口那么我们累积应答时具体发送多少数据之后统一回复一个ack是由什么决定的呢，就是由

  7. kubernetes

    k8s是什么1以容器为中心的应用编排平台2.面向平台的平台：强大的扩展能力：构建其它的平台3、容器编排容器生命周期管理容器创建、运行、监控、终止为容器运行提供支撑：存储卷：卷编排网络：网络编排容器关系管理超亲密关系：运行一个整体，Kubernetes抽象出来的新概念Pod非超亲密关系：各自独立运行通过Service互相

  8. 肖sir_环境搭建之面试题（答案供参考）_003

    课堂巩固练习（可以百度，查询）1、请简述dym的搭建、用到了哪些工具和流程介绍服务器系统：centos6；工具：jdk，MySQL，tomcat；流程：创建数据库，导入数据表–>安装jdk，解压tomcat–>将war代码包放到tomcat中解压—>进入解压的包里配置数据库连接—>进入浏览器打开前端及管理端参考：简化流

  9. Linux系统100条命令：关于Ubuntu和 CentOS 7 相同功能的不同的终端操作命令

    安装软件包：Ubuntu：apt-getinstallpackage_nameCentOS7：yuminstallpackage_name更新软件包列表：Ubuntu：apt-getupdateCentOS7：yumupdate卸载软件包：Ubuntu：apt-getremovepackage_nameCentOS7：