【数据结构与算法】LinkedList与链表

news2024/10/5 16:32:33

请添加图片描述

✨个人主页：bit me
✨当前专栏：数据结构
✨每日一语：假如困境有解，何须心烦意乱；倘若困境无解，又何须郁郁寡欢。每个人都有两次生命，当你意识到你只有一次生命的时候，你的第二次生命就开始了🌹 🌹 🌹
在这里插入图片描述

LinkedList 与 链表

  • 📕一. ArrayList的缺陷
  • 📗二. 链表
    • 📄2.1 链表的概念及结构
    • 📄2.2 链表的实现
  • 📘三. LinkedList的模拟实现
  • 📒四.LinkedList的使用
    • 📜4.1 什么是LinkedList
    • 📜4.2 LinkedList的使用
  • 📔五. ArrayList和LinkedList的区别

 

📕一. ArrayList的缺陷

熟悉了ArrayList的使用后，并且进行了简单模拟实现。通过源码知道，ArrayList底层使用数组来存储元素，由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此：java集合中又引入了LinkedList，即链表结构。

 

📗二. 链表

📄2.1 链表的概念及结构

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。

 
在这里插入图片描述
注意：

  1. 从图中可以看出，链式结构在逻辑上是连续的，但是在物理上不一定连续
  2. 现实中的节点一般都是从堆上申请出来的
  3. 从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

  1. 单向或者双向
    在这里插入图片描述

  2. 带头或者不带头
    在这里插入图片描述

  3. 循环或者非循环
    在这里插入图片描述

虽然有这么多的链表的结构，但是我们重点掌握两种:

  1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
    在这里插入图片描述

  2. 无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

📄2.2 链表的实现

  1. 链表是由一个一个节点组成的 就可以设置成内部类，然后就是定义数值域和存储下一个节点的地址，另外提供一个构造方法来new数值域
public class MySingleList {
	static class ListNode{//静态内部类
	    public int val;//数值域
	    public ListNode next;//存储下一个节点的地址
	    
	    public ListNode(int val){
	        this.val = val;
	    }
	}
	...
}

此处需要注意的是我们的构造方法只需要传val，因为我们next值是未知的，在任意位置都是不同的

  1. 定义单链表的头节点的引用
public ListNode head;

注意在这里我们头节点不要定义在静态内部类中，头节点属于整个链表的头节点

  1. 进行初步简单的链表构造
public void creatList(){
    ListNode listNode1 = new ListNode(12);
    ListNode listNode2 = new ListNode(23);
    ListNode listNode3 = new ListNode(34);
    ListNode listNode4 = new ListNode(45);
    ListNode listNode5 = new ListNode(56);

    listNode1.next = listNode2;
    listNode2.next = listNode3;
    listNode3.next = listNode4;
    listNode4.next = listNode5;
    
    this.head = listNode1;
}
  1. 定义好一串链表数值val，此时next域为null
  2. 让每一个节点next域指向下一个节点，就发生了节点的链接指向
  3. 最后把第一个节点定义为头节点
  1. 链表的打印
public void display(){
    ListNode cur = head;
    while(cur != null){
        System.out.print(cur.val+" ");
        cur = cur.next;
    }
    System.out.println();
}
  1. 在这里需要注意的是用cur替代head的遍历，head就会一直存在，不会被丢失掉
  2. cur替代head的时候，只要不为空，就一直打印然后往后走，直到为空后停止打印
  1. 查找是否包含关键字key，是否在单链表当中
public boolean contains(int key){
    ListNode cur = this.head;
    //cur != null 说明没有遍历完链表
    while(cur != null){
        if(cur.val == key){
            return true;
        }
        cur = cur.next;
    }
    return false;
}

cur从头节点开始遍历，当头节点不为空的情况下，判断遍历的时候是否有元素和关键字key相等

  1. 得到单链表的长度
public int size(){
    int count = 0;
    ListNode cur = this.head;
    while(cur != null){
        count++;
        cur = cur.next;
    }
    return count;
}

定义一个count，每当cur走一步，count就自增一次，直到cur遇到null然后返回count的值就是链表长度

  1. 头插法（时间复杂度O(1)）
public void addFirst(int data){
    ListNode node = new ListNode(data);
    //当head == null的时候 可以直接总结出来
    /*if(this.head == null){
        this.head = node;
    }else{
        node.next = this.head;
        this.head = node;
    }*/
    node.next = this.head;
    this.head = node;
}

定义一个node节点，让node节点next域指向head，然后把head赋值给node（注意顺序不可改变）

  1. 尾插法（时间复杂度O(n)）
public void addLast(int data){
    ListNode node = new ListNode(data);
    if(head == null){
        head = node;
    }else{
        ListNode cur = head;
        while(cur.next != null){
            cur = cur.next;
        }
        //cur.next == null;
        cur.next = node;
    }
}

当cur遍历走到null的位置时，说明走到了最后一个节点的位置，此时让cur的next域指向node就可以把node插入到尾部节点

  1. 指定位置插入元素，为了插入元素，我们得先给每个节点赋予下标

①：先判断下标合法性

private void checkIndexAdd(int index){
    if (index < 0 || index > size()){
        throw new MySingleListIndexOutOfException("任意位置插入的时候，index位置不合法！");
    }
}

下标既不能是0，也不能大于链表长度，否则是不合法的

②：考虑特殊情况，下标为0插入相当于头插法，下标为链表长度为尾插法
③：如何插入元素？

例如在下标为 1 和 2 之间插入元素，插入节点为node，我们让cur走到1的时候，让node的next指向cur的next，就相当于让node的next指向了下标为2的节点，再让cur的next指向node就可以把三者连接起来了

找到node前一个节点的位置cur

private ListNode findIndexSubOne(int index){
    ListNode cur = this.head;
    while (index - 1 != 0){
        cur = cur.next;
        index--;//cur走的趟数
    }
    return cur;
}

总的实现：

public void addIndex(int index,int data){
    checkIndexAdd(index);
    if(index == 0){
        addFirst(data);
        return;
    }
    if(index == size()){
        addLast(data);
        return;
    }
    ListNode node = new ListNode(data);
    ListNode cur = findIndexSubOne(index);
    node.next = cur.next;
    cur.next = node;
}
  1. 删除第一次出现的关键字key

删除一个节点我们可以让关键字key前面的一个节点直接指向关键字key后面一个节点，直接跳过了key就是删除了

public void remove(int key){
    if(this.head == null){
        System.out.println("此时链表为空，不能进行删除！");
        return;
    }
    if(this.head.val == key){
        //判断第一个节点是不是等于我要删除的节点
        this.head = this.head.next;
        return;
    }

    ListNode cur = this.head;
    while(cur.next != null){
        if(cur.next.val == key){
            //进行删除了
            ListNode del = cur.next;
            cur.next = del.next;
            return;
        }
        cur = cur.next;
    }
}
  1. 考虑特殊情况，链表为空和第一个节点就是我们要删除的关键字
  2. 首先在cur的next域不为空的前提下我们才能判断cur的next域的val，不至于发生空指针异常，当我们cur的next的val为关键字的时候，最终目的就是要让cur的next往后指俩位，相当于cur.next.next，直接逃过要删除的节点就可以了
  1. 删除所有值为key的节点

要求：

  1. 时间复杂度为O(n)
  2. 只遍历单链表一遍

首先我们需要知道的是：

删除的核心是 需要找到这个节点的前一个节点是谁

所以我们在这里定两个指针cur和prev，其中cur代表的是要删除的节点，prev代表的是cur的前驱

每次cur走一步的时候，prev都会紧随其后，当cur遇到了要删除的链表，都会直接往后走，直到遇到非val值的节点，然后prev继续跟着cur走

①：先考虑特殊情况：头节点不为空
②：定义cur和prev指针位置
③：在删除节点之前，我们得知道cur走动的前提是不为空的
④：在cur 不为空的前提下，我们该如何删除元素呢？

如第二个节点为我们要删除的元素，直接让prev(head)指向第三个元素的下标，第三个元素的下标就是cur.next，所以最终的式子就是prev.next = cur.next，然后让cur继续往后面走，继续执行此代码

⑤：最终代码就完成了，但是还有一个特殊情况，那就是cur是从第二个元素开始遍历，并没有考虑到头节点，所以我们在这里单独判断一下头节点

public void removeAllKey(int key){
   //删除的核心是需要找到这个节点的前一个节点是谁   设置prev为cur的前一个节点
   if(this.head == null){
       return;
   }
   ListNode cur = this.head.next;
   ListNode prev = this.head;

   while(cur != null){
       if(cur.val == key){
           prev.next = cur.next;
           cur = cur.next;
       }else{
           prev = cur;
           cur = cur.next;
       }
   }
   //单独处理了头节点
   if(this.head.val == key){
       head = head.next;
   }
}
  1. 清空链表里的所有元素

就是每个节点之间 不要有人引用了

①：方法一：暴力直接一步到位就是直接把头节点置为空，这样后面的链式节点全都没人引用了
②：方法二：让curNext为空，cur遍历的时候，把curNext赋给cur，最后单独处理下头节点

public void clear(){
    //this.head = null;//一步到位 暴力直接
    ListNode cur = this.head;
    ListNode curNext = null;
    while(cur != null){
        curNext = cur.next;
        cur.next = null;
        cur = curNext;
    }
    head = null;
}

 

📘三. LinkedList的模拟实现

LinkedList底层就是一个双向链表，我们来实现一个双向链表。

在这里插入图片描述

  1. 它是由一个一个节点组成的 就可以设置成内部类，然后就是定义数值域，储存上一个节点的地址和存储下一个节点的地址，另外提供一个构造方法来new数值域
static class ListNode{
    public int val;
    public ListNode prev;
    public ListNode next;

    public ListNode(int val){//此处不添加prev和next参数是因为实例化节点的时候前后都是未知的
        this.val = val;
    }
}
  1. 标记头尾节点
public ListNode head;//标记头部
public ListNode last;//标记尾部
  1. 打印
public void display(){
    ListNode cur = head;
    while(cur != null){
        System.out.print(cur.val+" ");
        cur = cur.next;
    }
}

和链表一样的打印

  1. 头插法
public void addFirst(int data){
    ListNode node = new ListNode(data);
    if(head == null){
        head = node;
        last = node;
    }else{
        node.next = head;
        head.prev = node;
        head = node;
    }
}
  1. 考虑特殊情况，LinkedList为空的情况下
  2. 如何头插：插入节点的next域引用头节点，头节点的前一节点域指向node，然后node就成为了头节点
  1. 尾插法
public void addLast(int data){
    ListNode node = new ListNode(data);
    if(head == null){
        head = node;
        last = node;
    }else{
        last.next = node;
        node.prev = last;
        last = node;
    }
}
  1. 考虑特殊情况，LinkedList为空的情况下
  2. 让最后节点的next域引用node，然后把node的前缀指向最后的节点，让最后的节点等于node
  1. 得到单链表的长度
public int size(){
    int count = 0;
    ListNode cur = head;
    while(cur != null){
        count++;
        cur = cur.next;
    }
    return count;
}
  1. 在任意位置插入节点

①：首先我们得定义下标，为节点插入做准备

private ListNode searchIndex(int index){
    ListNode cur = head;
    while(index != 0){
        cur = cur.next;
        index--;
    }
    return cur;
}

②：插入方法实现

cur是插入节点后一位的节点，让node的next域指向cur，再让插入节点前一位节点的next域指向node，让node的prev域指向插入节点的前一位节点，最后把cur的prev域指向node就完成了所有的步骤

public void addIndex(int index,int data){
    if(index < 0 || index > 0){
        System.out.println("index不合法！");
    }
    if(index == 0){
        addFirst(data);
        return;
    }
    if(index > size()){
        addLast(data);
        return;
    }
    //cur拿到了index下标的节点的地址
    ListNode cur = searchIndex(index);
    ListNode node = new ListNode(data);
    node.next = cur;
    cur.prev.next = node;
    node.prev = cur.prev;
    cur.prev = node;
}
  1. 查找是否包含关键字key是否在单链表当中
public boolean contains(int key){
    ListNode cur = head;
    while(cur != null){
        if(cur.val == key){
            return true;
        }
        cur = cur.next;
    }
    return false;
}
  1. 删除第一次出现关键字为key的节点
public void remove(int key){
    ListNode cur = head;
    while(cur != null){
        if(cur.val == key){
            //判断当前是不是头节点
            if(cur == head){
                head = head.next;
                if(head != null){//只有一个节点
                        head.prev = null;
                    }
            }else {
                //中间和尾巴的情况
                cur.prev.next = cur.next;
                if(cur.next != null){
                    cur.next.prev = cur.prev;
                }else {
                    last = last.prev;
                }
            }
            return;
        }else {
            cur = cur.next;
        }
    }
}
  1. 在这里我们删除节点不需要额外的前驱信息，节点本身就包含了
  2. 删除的条件cur.prev.next = cur.next; cur.next.prev = cur.prev;
  3. 在这里面我们用了前驱后驱信息，考虑特殊情况是有头节点和尾节点的，所以我们又要分开考虑
  4. 头节点就直接往后走，记得前驱为空，且考虑只有一个节点的情况
  5. 尾节点就直接往前面走
     
    注意：判断后如果没有return，删除前面的节点就可能发生空指针异常
  1. 删除所有值为key的节点

和单个的删除是一样的，只是判断完了之后我们需要让cur继续走就对了，此时不可以return

public void removeAllKey(int key){
    ListNode cur = head;
    while(cur != null){
        if(cur.val == key){
            //判断当前是不是头节点
            if(cur == head){
                head = head.next;
                if(head != null){
                    head.prev = null;
                }
            }else {
                //中间和尾巴的情况
                cur.prev.next = cur.next;
                if(cur.next != null){
                    cur.next.prev = cur.prev;
                }else {
                    last = last.prev;
                }
            }
            cur = cur.next;//继续往后走
        }else {
            cur = cur.next;
        }
    }
}
  1. 清空链表

遍历置为空就可以

public void clear(){
    ListNode cur = head;
    while(cur != null){
        ListNode curNext = cur.next;
        //cur.val = null  是引用类型就置为空，基本类型就不用
        cur.prev = null;
        cur.next = null;
        cur = curNext;
    }
    head = null;
    last = null;
}

需要注意的是这里头节点和尾节点需要置为空，因为遍历完成之后他们还在被引用

 

📒四.LinkedList的使用

📜4.1 什么是LinkedList

LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
 
在这里插入图片描述

在集合框架中，LinkedList也实现了List接口

说明：

  1. LinkedList实现了List接口
  2. LinkedList的底层使用了双向链表
  3. LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问
  4. LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)

📜4.2 LinkedList的使用

  1. LinkedList的构造
方法解释
LinkedList()无参构造
public LinkedList(Collection<? extends E> c)使用其他集合容器中元素构造List
  1. LinkedList的其他常用方法介绍
方法解释
boolean add(E e)尾插 e
void add(int index, E element)将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)尾插 c 中的元素
E remove(int index)删除 index 位置元素
boolean remove(Object o)删除遇到的第一个 o
E get(int index)获取下标 index 位置元素
E set(int index, E element)将下标 index 位置元素设置为 element
void clear()清空
boolean contains(Object o)判断 o 是否在线性表中
int indexOf(Object o)返回第一个 o 所在下标
int lastIndexOf(Object o)返回最后一个 o 的下标
List subList(int fromIndex, int toIndex)截取部分 list

方法简介：

public static void main(String[] args) {
	LinkedList<Integer> list = new LinkedList<>();
	list.add(1); // add(elem): 表示尾插
	list.add(2);
	list.add(3);
	list.add(4);
	list.add(5);
	list.add(6);
	list.add(7);
	System.out.println(list.size());
	System.out.println(list);
	// 在起始位置插入0
	list.add(0, 0); // add(index, elem): 在index位置插入元素elem
	System.out.println(list);
	list.remove(); // remove(): 删除第一个元素，内部调用的是removeFirst()
	list.removeFirst(); // removeFirst(): 删除第一个元素
	list.removeLast(); // removeLast(): 删除最后元素
	list.remove(1); // remove(index): 删除index位置的元素
	System.out.println(list);
	// contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
	if(!list.contains(1)){
		list.add(0, 1);
	}
	list.add(1);
	System.out.println(list);
	System.out.println(list.indexOf(1)); // indexOf(elem): 从前往后找到第一个elem的位置
	System.out.println(list.lastIndexOf(1)); // lastIndexOf(elem): 从后往前找第一个1的位置
	int elem = list.get(0); // get(index): 获取指定位置元素
	list.set(0, 100); // set(index, elem): 将index位置的元素设置为elem
	System.out.println(list);
	// subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
	List<Integer> copy = list.subList(0, 3); 
	System.out.println(list);
	System.out.println(copy);
	list.clear(); // 将list中元素清空
	System.out.println(list.size());
}
  1. LinkedList的遍历
public static void main(String[] args) {
	LinkedList<Integer> list = new LinkedList<>();
	list.add(1); // add(elem): 表示尾插
	list.add(2);
	list.add(3);
	list.add(4);
	list.add(5);
	list.add(6);
	list.add(7);
	System.out.println(list.size());
	// foreach遍历
	for (int e:list) {
		System.out.print(e + " ");
	}
	System.out.println();
	// 使用迭代器遍历---正向遍历
	ListIterator<Integer> it = list.listIterator();
	while(it.hasNext()){
		System.out.print(it.next()+ " ");
	}
	System.out.println();
	// 使用反向迭代器---反向遍历
	ListIterator<Integer> rit = list.listIterator(list.size());
	while (rit.hasPrevious()){
			System.out.print(rit.previous() +" ");
	}
	System.out.println();
}

 

📔五. ArrayList和LinkedList的区别

ArrayListLinkedList
存储空间上 物理上一定连续逻辑上连续，但物理上不一定连续
随机访问 支持O(1)随机访问 不支持：O(N)
头插 需要搬移元素，效率低O(N)头插 只需修改引用的指向，时间复杂度为O(1)
插入 空间不够时需要扩容没有容量的概念
应用场景：元素高效存储+频繁访问任意位置插入和删除频繁

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/46223.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

艾美捷MTT细胞增殖检测试剂盒测定方案

艾美捷MTT细胞增殖检测试剂盒测定方案

细胞增殖的测量和监测是任何实验室中必不可少的技术专注于基于细胞的研究。该技能还允许优化细胞培养条件作为细胞因子&#xff0c;生长因子或激素活性的测定。更重要的是&#xff0c;细胞抑制毒理学测试中抗癌化合物的性质&#xff0c;治疗化学品在药物中的功效筛选和细胞介导…
阅读更多...
设计模式之迭代器模式（十三）

设计模式之迭代器模式（十三）

目录 1. 背景 1.1 学院展示问题 1.2 迭代器模式概述 2. 迭代器模式 2.1 迭代器解决院校展示 2.2 迭代器模式在JDK ArrayList中的应用 1. 背景 1.1 学院展示问题 编写程序展示一个学校院系结构&#xff1a;需求是这样&#xff0c;要在一个页面中展示出学校的院系 组成&…
阅读更多...
驱动——platform驱动总线三种匹配方式

驱动——platform驱动总线三种匹配方式

三种platform驱动匹配方式代码案例以及现象 方式一&#xff1a;通过设置名字进行匹配 相关API简介&#xff1a; 1、platform_device的API ①分配对象 struct platform_device { const char *name;//用于进行匹配的名字 int id;//总线号 PLATFORM_DEVID_AUTO&#xff08;自…
阅读更多...
Java基于springboot+vue的共享电动车管理系统 nodejs

Java基于springboot+vue的共享电动车管理系统 nodejs

随着在我国国民水平的提高&#xff0c;低碳环保的概念也深入人心&#xff0c;越来越多的人选择了绿色环保的出现方式&#xff0c;共享电动车更是为绿色出行提供了一个有利的保障。通过本人的调查研究发现&#xff0c;很多大学的共享电动车的管理还是用手工传统的方式在进行&…
阅读更多...
谷歌翻译用不了的解决方案

谷歌翻译用不了的解决方案

1.上 https://ping.chinaz.com/ ping一下translate.google.cn 2.往下拉&#xff0c;根据自己所在地&#xff0c;例如广东深圳&#xff0c;则看看按照响应时间排序&#xff0c;找广东省内的。 3.把响应ip复制&#xff0c;并且本地ping一下看看响应时间 响应时间40ms还能接受 …
阅读更多...
redis cluster如何添加和删除节点？

redis cluster如何添加和删除节点？

文章目录redis cluster如何增加和删除节点&#xff1f;背景说明添加节点添加 master 节点添加slave节点删除节点删除 master 节点删除slave节点redis cluster如何增加和删除节点&#xff1f; 背景说明 由于虚拟环境有限&#xff0c;目前所采用的集群方案是在 3 台机器去搭建 …
阅读更多...
java项目_第166期ssm多人命题系统_java毕业设计_计算机毕业设计

java项目_第166期ssm多人命题系统_java毕业设计_计算机毕业设计

java项目_第166期ssm多人命题系统_java毕业设计_计算机毕业设计 【源码请到资源专栏下载】 今天分享的项目是《ssm多人命题系统》 1、该项目分为3个角色&#xff0c;管理员和、用户、教师。 用户角色可以浏览前台,包含功能有&#xff1a; 首页、学校公告、试题信息、论坛信息 用…
阅读更多...
Thread的基本用法

Thread的基本用法

目录 1.创建线程 2.1 继承Thread类,重写run方法 2.2 实现Runnable,重写run方法 2.3 使用匿名内部类继承Thread类,重写run方法 2.4 使用匿名内部类实现Runnable接口,重写run方法 2.5 使用lambda表达式 3.Thread类的构造方法 4.Thread类的常见属性的获取方法 5.线程方法的…
阅读更多...
游戏开发28课 cocoscreator 渲染排序说明

游戏开发28课 cocoscreator 渲染排序说明

渲染排序说明 2D 渲染节点排序 2D 渲染节点可分为在 Canvas 下的节点和不在 Canvas 下的节点两种&#xff1a; 在 Canvas 下的节点可参考下文 UI 节点排序 部分的内容。 不在 Canvas 下的节点&#xff0c;用户可选择通过 自定义材质 来开启深度检测实现和 3D 物体的遮挡显示…
阅读更多...
面试中经常被问到的几个回溯问题

面试中经常被问到的几个回溯问题

前言&#xff1a;大家好&#xff0c;我是小威&#xff0c;24届毕业生&#xff0c;本篇文章是对最近复刷的回溯相关的算法题进行记录&#xff0c;方便复习使用。 如果文章有什么需要改进的地方还请大佬不吝赐教&#x1f44f;&#x1f44f;。 小威在此先感谢各位大佬啦~~&#x1…
阅读更多...
马尔可夫预测案例分析

马尔可夫预测案例分析

根据已经有数据进行预测的研究方法有很多&#xff0c;包括arima模型、指数平滑法、灰色预测等&#xff0c;本文针对马尔可夫预测进行阐述。比如研究中国移动&#xff0c;中国联通和中国电信三家运营商&#xff0c;他们的用户可以互相携号转网&#xff0c;已经当前3家运营商的市…
阅读更多...
开发者友好的Linux常见命令整理

开发者友好的Linux常见命令整理

系统本身 uname -a # 查看内核/操作系统/CPU信息 cat /etc/redhat-release 查看服务器版本 cat /proc/cpuinfo # 查看CPU信息 hostname # 查看计算机名 lspci -tv # 列出所有PCI设备 lsusb -tv # 列出所有USB设备 lsmod # 列出加载的内核模块 env # 查看环境变量 查看…
阅读更多...
领域驱动设计-领域建模

领域驱动设计-领域建模

领域建模 领域建模是针对问题空间的战术求解的过程&#xff1a;观察真实世界的业务需求&#xff0c;对业务知识进行提炼和转换&#xff0c;排除技术因素对建模产生的影响&#xff0c;一切围绕着业务需求而来。同时满足未来的需求变更与产品维护 快速建模法&#xff1a;名次动…
阅读更多...
通信原理技术复习重点知识

通信原理技术复习重点知识

1.感知控制层通信的目的和特点&#xff1a; 目的&#xff1a;将各种传感设备&#xff08;数据采集设备以及相关的控制设备&#xff09;所感知的信息在较短的通信距离内传送到信息汇聚系统&#xff0c;并由该系统传送到网络传输层 特点&#xff1a;传输距离近&#xff0c;传输方…
阅读更多...
使用 SAP WebIDE 将 SAP UI5 应用部署到 ABAP 系统时遇到的关于传输请求的错误

使用 SAP WebIDE 将 SAP UI5 应用部署到 ABAP 系统时遇到的关于传输请求的错误

有朋友遇到一个在 webide 里部署 SAP UI5 应用到 ABAP Repository 里时出错的问题&#xff1a; 错误消息&#xff1a; Failed to get transports for the selected package. Request POST /webidedispatcher/destinations/LND500/sap/bc/adt/cts/transportchecks failed: Forbi…
阅读更多...
【数学】仿射变换（续1）

【数学】仿射变换（续1）

在 这篇文章 中我介绍了椭圆中的圆幂定理。其中&#xff0c;椭圆中的“相交弦定理”为 PA⋅PBPC⋅PDrAB2rCD2\frac{PA\cdot PB}{PC \cdot PD}\frac{r_{AB}^2}{r_{CD}^2}PC⋅PDPA⋅PB​rCD2​rAB2​​ 本来以为它是从来见不到的东西 然而 请看此题&#xff1a; 以下给出两种常…
阅读更多...
传奇登录器打不开的四种原因

传奇登录器打不开的四种原因

最近很多传奇玩家或者GM都遇到了传奇登陆器打不开&#xff0c;没反应&#xff0c;提示无法访问指定设备等问题&#xff0c;导致很多游戏没有办法玩&#xff0c;让玩家心情沮丧&#xff0c;作为GM&#xff0c;那么就更伤心了&#xff0c;很多玩家进不来游戏&#xff0c;开服数千…
阅读更多...
Vue3框架中路由的使用和局部刷新的功能(第十一课)

Vue3框架中路由的使用和局部刷新的功能(第十一课)

使用vue-router的步骤:p第一步&#xff1a;创建路由需要映射的组件&#xff08;打算显示的页面&#xff09;&#xff1b;p第二步&#xff1a;通过createRouter创建路由对象&#xff0c;并且传入routes和history模式&#xff1b;配置路由映射: 组件和路径映射关系的routes数组&a…
阅读更多...
linux杀毒软件clamav安装

linux杀毒软件clamav安装

clamav 简介 ClamAV is an open source (GPLv2) anti-virus toolkit, designed especially for e-mail scanning on mail gateways. It provides a number of utilities including a flexible and scalable multi-threaded daemon, a command line scanner and advanced tool …
阅读更多...
Git的基本使用

Git的基本使用

Git 1.Git基础知识 1.1Git简介 更新的历史保存在Gitee中不会丢失的。 1.简介&#xff1a;Git是一个分布式版本管理系统&#xff0c;是为了更好地管理Linux内核开发而创立的。 Git可以在任何时间点&#xff0c;把文档的状态作为更新记录保存起来。因此可以把编辑过的文档复…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023