【数据结构与算法】5.详解双向链表的基本操作（Java语言实现）

news2024/9/30 3:25:43

在这里插入图片描述
📚博客主页：爱敲代码的小杨.

✨专栏：《Java SE语法》

❤️感谢大家点赞👍🏻收藏⭐评论✍🏻，您的三连就是我持续更新的动力❤️

🙏小杨水平有限，欢迎各位大佬指点，相互学习进步！

文章目录

  • 0. 前言
  • 1. 双链表的定义
  • 2. LinkedList 模拟实现
    • 2.1 接口
    • 2.2 定义双向链表类
    • 2.3 定义两个指针，分别指向头节点和尾节点
    • 2.4 头插法
    • 2.5 尾插法
    • 2.6 指定位置插入元素
    • 2.7 查找指定元素
    • 2.8 删除指定元素
    • 2.9 删除链表中所有指定元素
    • 2.10 统计链表元素个数
    • 2.11 清空链表
    • 2.12 打印链表
    • 2.13 测试
  • 3.代码
  • 4. ArrayList和LinkedList的区别

0. 前言

上一篇【数据结构与算法】4.自主实现单链表的增删查改 我们自主实现了单链表的操作，在Java的集合类中LinkedList底层实现是无头双向循环链表。所以今天我们模拟LinkedList的实现。

1. 双链表的定义

学习双链表之前，做个回顾。

单链表的特点：

  1. 我们可以轻松的到达下一个节点，但是回到前一节点是很难的。
  2. 只能从头遍历到尾或者从尾遍历到头（一般是从头到尾）

双链表的特点：

  1. 每次在插入或删除某个节点时, 需要处理四个节点的引用, 而不是两个. 实现起来要困难一些
  2. 相对于单向链表, 必然占用内存空间更大一些.
  3. 既可以从头遍历到尾, 又可以从尾遍历到头

双链表的定义：

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。

image-20240125171130806

指针域（prev）：用于指向当前节点的直接前驱节点；

数据域（data）：用于存储数据元素；

指针域（next）：用于指向当前节点的直接后继节点。

2. LinkedList 模拟实现

2.1 接口

public interface IList {
    //头插法
    public void addFirst(int data);

    //尾插法
    public void addLast(int data);

    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data);

    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key);

    //删除第一次出现关键字为key的节点
    public void remove(int key);

    //删除所有值为key的节点
    public void removeAllKey(int key);

    //得到单链表的长度
    public int size();

    // 清空链表
    public void clear();

    // 打印链表
    public void display();
}

2.2 定义双向链表类

static class ListNode {
	public int val; // 数值域 - 存放当前节点的值
	public ListNode next; // next域 指向下一个节点
	public ListNode prev; // prev域 指向上一个节点

	public ListNode(int val) {
		this.val = val;
	}
}

2.3 定义两个指针，分别指向头节点和尾节点

// 链表的属性 链表的头节点
public ListNode head; 
// 链表的属性 链表的尾节点
public ListNode last;

2.4 头插法

  1. 判断链表是否为空，如果为空，将新节点的node设置为头节点，将新节点的node设置为尾节点

    head = node;
last = node;

  2. 如果链表不为空，将新节点的node的next域设置为头节点，将当前头节点的prev设置为新节点的node，更新头节点为新节点的node

    node.next = head;
head.prev = node;
head = node;

动画演示：

1706271497900

代码：

/**
* 头插法
* @param data
*/
@Override
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;
	}
}

2.5 尾插法

  1. 判断链表是否为空，如果为空，将新节点的node设置为头节点，将新节点的node设置为尾节点

    head = node;
last = node;

  2. 如果链表不为空，将最后一个节点last的next域指向新节点，新节点的prev域指向最后一个节点，更新尾节点为新节点

    last.next = node;
node.prev = last;
last = node;

动画演示：

1706271820869

代码：

    /***
     * 尾插法
     * @param data
     */
    @Override
    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;
        }
    }

2.6 指定位置插入元素

  1. 判断索引idnex是否合法，如果不合法则抛出异常。

    if (index < 0 || index > size()) {
	throw new IndexException("index不合法：" + index);
}

  2. 判断链表是否为空，如果为空则将新节点设置为头节点和尾节点

    if (head == null) {
	head = node;
    last = node;
    return;
}

  3. 如果索引index == 0，则使用头插法，如果索引index = 链表长度，则使用尾插法

    if (index == 0) {
    addFirst(data);
	return;
}
if (index == size()) {
    addLast(data);
	return;
}

  4. 找到索引节点（当前节点）

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

  5. 将新节点的next域指向当前节点，新节点的prev域指向当前节点的前一个节点，当前节点的prev域指向新节点，更新新节点的上一个节点的next域指向当前节点。

    ListNode cur = findIndex(index);
node.next = cur;
node.prev = cur.prev;
cur.prev = node;
node.prev.next = node;

动画演示：

1706272997346

2.7 查找指定元素

  1. 从头节点开始遍历链表，如果当前节点的值与要查找的key相等，则返回ture，如果不相等则移动下一个节点继续查找。如果遍历完链表都没有找到key则返回false.

代码：

    @Override
    public boolean contains(int key) {
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

2.8 删除指定元素

  1. 从头节点开始遍历链表，找到要删除的节点

  2. 情况一：删除的节点为头节点，更新头节点为下一个节点，更新下一个节点的prev域置为空。

    1706277210409

  3. 情况二：链表中只有一个元素，且正好要删除这个元素。

  4. 情况三：删除的节点为尾节点，更新尾节点为当前节点的上一个节点，上一个节点的next域置为空

    1706277783850

  5. 情况四：删除中间节点，当前节点的上一个节点的next域指向当前节点的下一个节点，更新下一个节点的prev域指向当前节点的上一个节点

    1706278104977

  6. 删除了节点就结束方法的执行

代码：

    @Override
    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 { // 链表中只有一个元素，且这个正好删除这个元素
                         last = null;
                     }
                 } else { // 删除中间节点
                     cur.prev.next = cur.next;
                     if (cur.next != null) {
                        cur.next.prev = cur.prev;
                     } else {
                         // 删除尾节点
                         last = cur.prev;
                     }
                 }
                 return;// 删除了节点就结束方法
             }
             cur = cur.next;
         }
    }

2.9 删除链表中所有指定元素

从头节点遍历链表，与删除指定元素的方式一样，删除节点后继续遍历链表，直到遍历完链表，删除所有指定的元素即可。

代码：

    @Override
    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 { // 链表中只有一个元素，且这个正好删除这个元素
                        last = null;
                    }
                } else { // 删除中间节点
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        cur.next.prev = cur.prev;
                    } else {
                        // 删除尾节点
                        last = cur.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }

2.10 统计链表元素个数

代码：

    @Override
    public int size() {
        int count = 0;
        ListNode cur = head;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

2.11 清空链表

将头节点和尾节点置为空，没有引用指向直接被JVM回收

    @Override
    public void clear() {
        head = null;
        last = null;
    }

2.12 打印链表

    @Override
    public void display() {
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

2.13 测试

public class Test {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        // 头插法
        myLinkedList.addFirst(1);
        myLinkedList.addFirst(2);
        myLinkedList.addFirst(3);
        // 打印链表
        myLinkedList.display();

        System.out.println("=========");

        // 尾插法
        myLinkedList.addLast(4);
        myLinkedList.addLast(5);
        myLinkedList.addLast(6);
        // 打印链表
        myLinkedList.display();

        System.out.println("=========");

        // 在4 位置插入7
        myLinkedList.addIndex(4,7);
        // 打印链表
        myLinkedList.display();

        System.out.println("=========");

        // 查找元素 7 8
        System.out.println(myLinkedList.contains(7));
        System.out.println(myLinkedList.contains(8));

        System.out.println("=========");

        // 删除3 6 4
        myLinkedList.remove(3);
        myLinkedList.display();
        System.out.println("=========");

        myLinkedList.remove(6);
        myLinkedList.display();
        System.out.println("=========");

        myLinkedList.remove(4);
        myLinkedList.display();
        System.out.println("=========");


        // 删除全部的2
        myLinkedList.addLast(2);
        myLinkedList.addLast(2);
        myLinkedList.addLast(2);
        myLinkedList.display();
        myLinkedList.removeAllKey(2);
        myLinkedList.display();

        System.out.println("=========");

        // 统计个数
        System.out.println(myLinkedList.size());

        System.out.println("=========");

        // 清空链表
        myLinkedList.clear();
        myLinkedList.display();
        System.out.println("=========");
        
        // 统计个数
        System.out.println(myLinkedList.size());
    }
}

// 运行结果
3 2 1 
=========
3 2 1 4 5 6 
=========
3 2 1 4 7 5 6 
=========
true
false
=========
2 1 4 7 5 6 
=========
2 1 4 7 5 
=========
2 1 7 5 
=========
2 1 7 5 2 2 2 
1 7 5 
=========
3
=========

=========
0

3.代码

MyLinkedList类：

public class MyLinkedList implements IList{

    static class ListNode {
        public int val; // 数值域 - 存放当前节点的值
        public ListNode next; // next域 指向下一个节点
        public ListNode prev; // prev域 指向上一个节点

        public ListNode(int val) {
            this.val = val;
        }
    }

    // 链表的属性 链表的头节点
    public ListNode head;
    // 链表的属性 链表的尾节点
    public ListNode last;

    /**
     * 头插法
     * @param data
     */
    @Override
    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;
        }
    }

    /***
     * 尾插法
     * @param data
     */
    @Override
    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;
        }
    }

    @Override
    public void addIndex(int index, int data) {
        if (index < 0 || index > size()) {
            throw new IndexException("index不合法：" + index);
        }
        ListNode node = new ListNode(data);
        if (head == null) {
            head = node;
            last = node;
            return;
        }
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size()) {
            addLast(data);
            return;
        }
        ListNode cur = findIndex(index);
        node.next = cur;
        node.prev = cur.prev;
        cur.prev = node;
        node.prev.next = node;
    }

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

    @Override
    public boolean contains(int key) {
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    @Override
    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 { // 链表中只有一个元素，且这个正好删除这个元素
                         last = null;
                     }
                 } else { // 删除中间节点
                     cur.prev.next = cur.next;
                     if (cur.next != null) {
                        cur.next.prev = cur.prev;
                     } else {
                         // 删除尾节点
                         last = cur.prev;
                     }
                 }
                 return;
             }
             cur = cur.next;
         }
    }

    @Override
    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 { // 链表中只有一个元素，且这个正好删除这个元素
                        last = null;
                    }
                } else { // 删除中间节点
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        cur.next.prev = cur.prev;
                    } else {
                        // 删除尾节点
                        last = cur.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }

    @Override
    public int size() {
        int count = 0;
        ListNode cur = head;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

    @Override
    public void clear() {
        head = null;
        last = null;
    }

    @Override
    public void display() {
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }
}

接口：

public interface IList {
    //头插法
    public void addFirst(int data);

    //尾插法
    public void addLast(int data);

    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data);

    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key);

    //删除第一次出现关键字为key的节点
    public void remove(int key);

    //删除所有值为key的节点
    public void removeAllKey(int key);

    //得到单链表的长度
    public int size();

    // 清空链表
    public void clear();

    // 打印链表
    public void display();
}

异常类：

public class IndexException extends RuntimeException{
    public IndexException() {

    }
    public IndexException(String msg) {
        super(msg);
    }
}

4. ArrayList和LinkedList的区别

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

在这里插入图片描述

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

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

相关文章

Oracle扩展ASM存储

Oracle扩展ASM存储

物理增加1T存储到服务器。 , 绑定裸设备 vi /etc/udev/rules.d/99-asmdevice.rules KERNEL"dm-*",ENV{DM_UUID}"mpath-360002ac000000000000001a700006bc6",NAME"asm_arch",OWNER"grid",GROUP"asmadmin",MODE"0660&q…
阅读更多...
第二百八十八回

第二百八十八回

文章目录 1. 概念介绍2. 使用方法2.1 实现步骤2.2 具体细节 3. 示例代码4. 内容总结 我们在上一章回中介绍了"如何获取文件类型"相关的内容&#xff0c;本章回中将介绍如何播放视频.闲话休提&#xff0c;让我们一起Talk Flutter吧。 1. 概念介绍 播放视频是我们常用…
阅读更多...
区块空间----流动性铭文

区块空间----流动性铭文

铭文正在改变加密世界&#xff0c;越来越多的人开始关注铭文&#xff0c;并参与进来&#xff01;铭文赛道的未来是非常具有潜力和想象力的&#xff0c;甚至能够达到加密货币的普及水平。当然&#xff0c;这需要更多的基础设施更多的用例支持&#xff0c;但是一切都才刚刚开始。…
阅读更多...
Go语言grpc服务开发——Protocol Buffer

Go语言grpc服务开发——Protocol Buffer

文章目录 一、Protocol Buffer简介二、Protocol Buffer编译器安装三、proto3语言指南四、序列化与反序列化五、引入grpc-gateway1、插件安装2、定义proto文件3、生成go文件4、实现Service服务5、gRPC服务启动方法6、gateway服务启动方法7、main函数启动8、验证 相关参考链接&am…
阅读更多...
Mysql-日志介绍 日志配置

Mysql-日志介绍 日志配置

环境部署 docker run -d -p 3306:3306 --privilegedtrue -v $(pwd)/logs:/var/lib/logs -v $(pwd)/conf:/etc/mysql/conf.d -v $(pwd)/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD654321 --name mysql mysql:5.7运行指令的目录下新建好这些文件&#xff1a; 日志类型 日…
阅读更多...
dhcp服务器的ip池的待分配ip地址是否冲突的检测机制

dhcp服务器的ip池的待分配ip地址是否冲突的检测机制

看到有的资料说&#xff0c;dhcp服务器在分配ip地址时&#xff0c;要检测是否待分配的ip地址是否存在冲突&#xff0c;会向广播域发出&#xff0c;对应ip发出icmp的ping消息来验证是否冲突。特地用自己的公司的交换机验证一下&#xff0c;在交换机上镜像抓包观察一下。 wiresha…
阅读更多...
社交媒体与新闻：Facebook在信息传播中的角色

社交媒体与新闻：Facebook在信息传播中的角色

社交媒体的崛起不仅改变了人们的日常交流方式&#xff0c;也对新闻传播产生了深远的影响。在众多社交媒体平台中&#xff0c;Facebook以其庞大的用户基础和强大的社交网络机制&#xff0c;成为信息传播的中流砥柱。本文将深入探讨Facebook在社交媒体与新闻传播的交汇点上扮演的…
阅读更多...
Qt应用开发(安卓篇)——调用java代码，使用安卓api

Qt应用开发(安卓篇)——调用java代码，使用安卓api

一、前言 在Qt on Android开发的时候&#xff0c;它不像在嵌入式linux&#xff0c;几乎全部的操作都是可以通过文件来完成。很多场景下的功能都需要使用安卓的API去实现&#xff0c;开发人员需要通过这些API进行编程&#xff0c;无需访问源码&#xff0c;或者理解内部的机制。比…
阅读更多...
IP报文格式

IP报文格式

IP报文格式 报文格式 图1 IP头格式 表1 IP头字段解释 字段长度含义Version4比特 4&#xff1a;表示为IPV4&#xff1b;6&#xff1a;表示为IPV6。IHL4比特首部长度&#xff0c;如果不带Option字段&#xff0c;则为20&#xff0c;最长为60&#xff0c;该值限制了记录路由选项。…
阅读更多...
阅读go语言工具源码系列之gopacket（谷歌出品）----第二集 layers-巧妙的抽象与无聊的协议包

阅读go语言工具源码系列之gopacket（谷歌出品）----第二集 layers-巧妙的抽象与无聊的协议包

上一集中我们讲到了wpcap.dll的go封装方法&#xff0c;对于linux系统下libpcap的go封装采用的是常用的cgo方式&#xff0c;想了解的可以看看pcap文件夹中的pcap_unix.go。 我们得到了wpcap.dll的go调用&#xff0c;就可以利用它来进行列举所有网络设备&#xff0c;例如以下代码…
阅读更多...
docker容器生命周期管理命令

docker容器生命周期管理命令

文章目录 前言1、docker create2、docker run2.1、常用选项2.2、系统2.3、网络2.4、健康检查 3、docker start/stop/restart4、docker kill5、docker rm6、docker pause/unpause总结 前言 在云原生时代&#xff0c;Docker已成为必不可少的容器管理工具。通过掌握Docker常用的容…
阅读更多...
派网AX50C做多宽带路由和核心交换机配置实战教程

派网AX50C做多宽带路由和核心交换机配置实战教程

接近300办公人员的工厂需要网络升级&#xff0c;我规划设计和部署实施了以下方案&#xff0c;同样是简约不简单&#xff0c;在满足性能需求稳定性的前提下&#xff0c;既有经济性&#xff0c;又有安全性。 派网做路由器&#xff0c;刚好开启默认防病毒策略&#xff0c;省下来一…
阅读更多...
【QT+QGIS跨平台编译】之十一：【libzip+Qt跨平台编译】（一套代码、一套框架，跨平台编译）

【QT+QGIS跨平台编译】之十一：【libzip+Qt跨平台编译】（一套代码、一套框架，跨平台编译）

文章目录 一、libzip介绍二、文件下载三、文件分析四、pro文件五、编译实践一、libzip介绍 libzip是一个开源C库，用于读取，创建和修改zip文件。 libzip可以从数据缓冲区，文件或直接从其他zip归档文件直接复制的压缩数据中添加文件。在不关闭存档的情况下所做的更改可以还原…
阅读更多...
TCP 状态转换以及半关闭

TCP 状态转换以及半关闭

TCP 状态转换&#xff1a; 上图中还没有进行握手的时候状态是关闭的。 三次握手状态的改变&#xff1a; 客户端发起握手。 调用 connect() 函数时状态转化为&#xff1a;SYN_SENT。调用 listen() 函数时状态转换为&#xff1a;LISTEN。ESTABLISHED是被连接的状态。 四次挥手…
阅读更多...
林浩然的哲学奇遇记：与罗素一起穿越西方哲学史

林浩然的哲学奇遇记：与罗素一起穿越西方哲学史

林浩然的哲学奇遇记&#xff1a;与罗素一起穿越西方哲学史 The Philosophical Adventures of Lin Haoran: Journeying Through Western Philosophy with Russell 在一个阳光灿烂的早晨&#xff0c;林浩然同学迎着微风&#xff0c;拿着一本厚重的罗素名著《西方哲学史》&#xf…
阅读更多...
了解维特比算法：通信系统和自然语言处理中解码的基石

了解维特比算法：通信系统和自然语言处理中解码的基石

一、介绍 在数字通信和信号处理领域&#xff0c;维特比算法是一种革命性的纠错和解码方法。该算法以 1967 年推出的 Andrew Viterbi 的名字命名&#xff0c;已成为数字通信和自然语言处理领域的基础。本文旨在深入研究维特比算法的复杂性&#xff0c;探讨其理论基础、实际应用以…
阅读更多...
通俗易懂理解小波池化以及WaveCNet网络模型

通俗易懂理解小波池化以及WaveCNet网络模型

重要说明&#xff1a;本文从网上资料整理而来&#xff0c;仅记录博主学习相关知识点的过程&#xff0c;侵删。 一、参考资料 github代码&#xff1a;WaveCNet 小波变换和曲波变换用于池化层 通俗易懂理解小波变换(Wavelet Transform) 二、相关介绍 关于小波变换的详细介绍…
阅读更多...
C#，数据检索算法之插值搜索（Interpolation Search）的源代码

C#，数据检索算法之插值搜索（Interpolation Search）的源代码

数据检索算法是指从数据集合&#xff08;数组、表、哈希表等&#xff09;中检索指定的数据项。 数据检索算法是所有算法的基础算法之一。 本文提供插值搜索&#xff08;Interpolation Search&#xff09;的源代码。 1 文本格式 using System; namespace Legalsoft.Truffer.…
阅读更多...
极限【高数笔记】

极限【高数笔记】

【分类】分为了两大类&#xff0c;一个是数列的极限&#xff0c;一个是函数的极限 【数列的极限】 1.定义&#xff1a; 简单来讲&#xff0c;就是&#xff0c;当n无限趋近于无穷时&#xff0c;数列{an}无限趋近一个常数A&#xff0c;此时&#xff0c;常数A就是它们此时情况下的…
阅读更多...
三极管实际电路设计

三极管实际电路设计

上图电路有个致命缺陷。那就是Q2正常我们是用NPN三极管。而上图用了PNP。导致MOS管高低电平都无法关闭。 解决方法&#xff1a; 把R2减小为200欧、或者330欧姆。 &#xff08;因为MOS打开需要压差&#xff0c;把SG端压差减小到规定以下就可以关闭&#xff09;。 同时增大R1为2…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023