带头单向链表源码及相关练习

news2025/1/10 16:47:18

目录

移除链表元素

链表的中间节点

链表倒数第k个节点

 合并两个有序链表

相交链表

环形链表

环形链表2

分割链表

回文链表

 

 

public class MySingleList {
    //内部类的使用
    class ListNode {
        public int val;
        public ListNode next;

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

    public ListNode head;//永远指向我的头节点

    public void createTree() {
        ListNode A = new ListNode(13);
        ListNode B = new ListNode(14);
        ListNode C = new ListNode(19);
        A.next = B;
        B.next = C;
        this.head = A;
    }

    public void show() {
        //定义一个引用变量
        //只有new的时候才是定义了一个节点
        ListNode cur = head;
        while (cur != null) {//因为最后一个地址是空
            System.out.println(cur.val + " ");
            cur = cur.next;
        }
    }

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

    public boolean contains(int key) {
        ListNode cur = head;
        while (cur != null) {
            //如果是引用类型呢？，用.equals()来比较
            if (cur.val == key) {
                return true;
            }
            cur = cur.next;

        }
        return false;
    }

    public void addVal(int index, int val) {
        //判断index的合法性
        if (index < 0 || index > size()) {
            throw new RuntimeException("越界了");
        }
        if (index == 0) {
            insertList(val);
            return;
        }
        if (index == size() - 1) {
            addTail(val);
            return;
        }
        ListNode node = new ListNode(val);
        ListNode cur = head;
        while (index - 1 != 0) {
            cur = cur.next;
            index--;
        }
        node.next = cur.next;
        cur.next = node;
    }

    public void remove(int key) {
        if (head == null) return;
        if (head.val == key) {
            head = head.next;
        }

        ListNode prev = searchPrev(key);
        if (prev == null) {
            return;
        }
        prev.next = prev.next.next;
    }

    public ListNode searchPrev(int key) {
        ListNode prev = head;
        while (prev != null) {
            if (prev.next.val == key) {

                return prev;

            } else {
                prev = prev.next;
            }

        }
        return null;
    }

    public void insertList(int val) {
        ListNode node = new ListNode(val);
        //才开始没有节点也行
        node.next = head;
        head = node;
    }

    //找index-1位置的节点
    public ListNode findIndex(int index) {
        ListNode cur = head;
        while (index - 1 != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }

    public void addTail(int val) {
        ListNode node = new ListNode(val);
        ListNode cur = head;
        if (head == null) {
            //空指针异常
            head = node;
            return;
        }
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = node;
    }

    public void delete(int val) {
        if (head == null) return;
        ListNode cur = head;
        while (cur.val != val) {

        }
    }

    public static void main(String[] args) {
        MySingleList m = new MySingleList();
        m.createTree();
        //System.out.println(m.size());
        // System.out.println(m.contains(14));
        // m.insertList(m.new ListNode(99));
        // m.addTail(100);
        // m.show();
        // m.addTail(11);
        m.addVal(1, 111);
        m.show();


    }

    public void clear() {

    }

    /***
     * 要求遍历链表一遍，删除所有值为key的节点
     * 双指针
     * cur节点代表当前要删除节点，prev是要删除节点的上一个节点
     *
     * **/
    public void deleteAllKey(int key) {
        if (head == null) {
            return;
        }
        ListNode prev = head;
        ListNode cur = prev.next;

        while (cur != null) {//遍历完了
            if (cur.val == key) {
                prev.next = cur.next;
                cur = cur.next;
                //先别急着走prev，因为可能有连着好几个的要删除的值
            } else {
                prev = cur;
                cur = cur.next;
            }
        }
        if(head.val==key){
            head=head.next;
        }
    }
    //cur!=null,while循环结束走到最后一个节点的位置，
    //cur.next！=null,while循环结束走到最后一个节点后面的位置


}

203. 移除链表元素

移除链表元素

难度简单1217

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

 

示例 1：

0cc0e9e0a4bae8db9485c34262d12b15.jpeg

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1
输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]
class Solution {
    public ListNode removeElements(ListNode head, int val) {
         if (head == null) {
            return null;
        }
        ListNode prev = head;
        ListNode cur = prev.next;

        while (cur != null) {//遍历完了
            if (cur.val == val) {
                prev.next = cur.next;
                cur = cur.next;
                //先别急着走prev，因为可能有连着好几个的要删除的值
            } else {
                prev = cur;
                cur = cur.next;
            }
        }
        if(head.val==val){
            head=head.next;
        }
        return head;
    }
}

链表的中间节点

a84c5c163b6f45a988c32312ac733cc6.png

 

class Solution {
    public ListNode middleNode(ListNode head) {
        if(head==null) return null;
        if(head.next==null) return head;
        //使用快慢指针
        ListNode fast=head;
        ListNode slow=head;
        while(fast!=null&&fast.next!=null){
            //考虑这个判断的先后顺序
            //考虑是||还是&&
            //为了避免空指针异常
            slow=slow.next;
            fast=fast.next.next;
        }
        
        return slow;
    }
}

链表倒数第k个节点

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

 

示例：

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

0b10e574a6544a2e8edfa52f20e232dd.png

让fast先走k-1步数，然后俩指针同时走

class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode fast=head;
        ListNode slow=head;
        while(k!=0){
            fast=fast.next;
            k--;
        }
        while(fast!=null){
            fast=fast.next;
            slow=slow.next;
        }
        return slow;

    }
}

 合并两个有序链表

/**
 * 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 mergeTwoLists(ListNode l1, ListNode l2) {
        // ListNode newHead=new ListNode();
        // ListNode tempH=newHead;
        // while(list1!=null&&list2!=null){
        //     if(list2.val<list1.val){
        //         tempH.next=list2;
        //         tempH=tempH.next;
        //         list2=list2.next;
        //     }else{
        //         tempH.next=list1;
        //         tempH=tempH.next;
        //         list2=list2.next;
        //     }
        // }
        // if(list1!=null){
        //     tempH.next=list1;
        // }
        // if(list2!=null){
        //     tempH.next=list2;
        // }
        // return newHead.next;
        // 类似归并排序中的合并过程
        ListNode dummyHead = new ListNode(0);
        ListNode cur = dummyHead;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                cur.next = l1;
                cur = cur.next;
                l1 = l1.next;
            } else {
                cur.next = l2;
                cur = cur.next;
                l2 = l2.next;
            }
        }
        // 任一为空，直接连接另一条链表
        if (l1 == null) {
            cur.next = l2;
        } else {
            cur.next = l1;
        }
        return dummyHead.next;

    }
}

相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

cc172cc404084b3a8d1867581d5ca1ad.png

 

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //1.计算长度查
        ListNode plong=headA;
        ListNode pshort=headB;
        int lenA=0;
        int lenB=0;
        while(plong!=null){
            lenA++;
            plong=plong.next;
        }
        while(pshort!=null){
            lenB++;
            pshort=pshort.next;
        }
        plong=headA;
        pshort=headB;
        int len=lenA-lenB;
        //2.保证长链表是plong,短链表是pshort
        if(len<0){
            plong=headB;
            pshort=headA;
            len=lenB-lenA;
        }
        //3.长链表先走差值步
        while(len!=0){
            plong=plong.next;
            len--;
        }
        //4.一起走直到相遇
        while(plong!=pshort){
            plong=plong.next;
            pshort=pshort.next;
        }
        return plong;

        
    }
}
//如何说明相交
 //val值相同并且next值相同
 //从相交节点开始后，长度就是一样的了
 //从头往后走，长度差的地方就是相交节点之前
 //此时复杂度接近O（N)


public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode pA = headA, pB = headB;
        while (pA != pB) {
            pA = pA == null ? headB : pA.next;
            pB = pB == null ? headA : pB.next;
        }
        return pA;
    }
}

环形链表

* 1.如果存在环，，那么当两个引用速度不一样时，一定会在环里相遇
* fast走2,slow走1
* 那为啥是这种速度差？
* fast走3,slow走1，不可以！比如：环形链表中只有2个节点
* 上述情况就可能错过或者很晚相遇。
*2.扩充
如何找到入口点

一个指针从相遇点开始走,另一个从头开始,遇见就是入口点

* */

 结论：转一圈的情况下，起始点到入口点和 相遇点到入口点的距离时一样的

05d1016641184ad5bda0d7608c4a4b09.png

 

 

so速度一样，路程一样，一个指针从相遇点开始走,另一个从头开始,遇见就是入口点

 

 

 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head==null) return false;
        ListNode fast=head;
        ListNode slow=head;
        while(fast!=null&&fast.next!=null){
            //避免空指针
            fast=fast.next.next;
            slow=slow.next;
            if(fast==slow){
                return true;
            }
        }
        return false;
        
    }
}

环形链表2

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

 

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

 

public class Solution {
       public ListNode detectCycle(ListNode head){
        if(head==null) return null;
        ListNode fast=head;
        ListNode slow=head;
        while(fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
            if(fast==slow){
                //说明找到相遇点了
                break;
            }
        }
        //万一根本就没有相遇的点呢
        //就是上一个循环的结束条件不是因为break
        //而是因为上面找不到，
        
        if(fast==null||fast.next==null){
            return null;
        }
        fast=head;
        while(fast!=slow){
            fast=fast.next;
            slow=slow.next;
        }
        //此时就相遇了
        //找到入口点了
        return slow;
    }
}

分割链表

class Solution {
    public ListNode partition(ListNode head, int x) {
        ListNode as=null;
        ListNode ae=null;
        ListNode bs=null;
        ListNode be=null;
        ListNode cur=head;
        while(cur!=null){
            if(cur.val<x){
                if(bs==null){
                    bs=cur;
                    be=cur;
                }else{
                    be.next=cur;
                    be=cur;
                }

            }else if(cur.val>=x){
                if(as==null){
                    as=cur;
                    ae=cur;
                }else{
                    as.next=cur;
                    ae=cur;
                }

            }
            cur=cur.next;

        }
        //考虑两个段都有数据码
        if(bs==null){
            return as;
        }
        be.next=as;
        if(as!=null){
            ae.next=null;
        }
        return bs;
    }
}

回文链表

d12f5dc8972d44b38e73a7693574ca6e.png

 53a19885cdc745889537874722ff7360.png

2fdd6c40182d424c843d99ed25bc6f5d.png

对于奇数个节点的链表，1.先找中间节点，2.反转中间节点后面的链表，3.两指针分别从后从前遍历直到两者相遇。 
class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head==null) return true;
        //1.先找中间节点
        ListNode fast=head;
        ListNode slow=head;
        while(fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
        }
        //此时slow就在中间节点了
        //2.翻转中间节点后的节点
        ListNode cur=slow.next;
        while(cur!=null){//结束后cur为空，也就是最后一个节点的后一个位置
            ListNode curNext=cur.next;
            cur.next=slow;
            slow=cur;
            cur=curNext;

        }
        //翻转完后slow再最后一个节点了
        //判断是否是回文
        //考虑奇数偶数，奇数的fast指针刚好走到最后一个节点，但是偶数的fast指针走到最后一个节点的后一个
        while(head!=slow){
            if(head.val!=slow.val){
                return false;
            }
            //专门针对偶数再写一个回文
             if(head.next==slow){
                return true;
            }
            head=head.next;
            slow=slow.next;
        }
        return true;
    }
}

 

 

public class SingleLinkedList{
 
    static class ListNode {
        public int val;//数值域public ListNode next;//存储下一个节点的地址
 
        public ListNode(int val) {
            this.val = val;
        }
    }
 
    public ListNode head;//代表单链表的头结点的引用
 
    /**
     * 这里只是简单的进行，链表的构造。
     */public void createList() {
        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;
    }
 
 
    public void display() {
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }
 
    /**
     * 从指定的节点开始答应
     * @param newHead
     */public void display(ListNode newHead) {
        ListNode cur = newHead;
        while (cur != null) {
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }
 
 
    /**
     * 头插法
     * OaddLast
     */public void addFirst(int data){
        ListNode node = new ListNode(data);
        /*if(this.head == null) {
            this.head = node;
        }else {
            node.next = this.head;
            this.head = node;
        }*/
        node.next = this.head;
        this.head = node;
    }
 
    //尾插法 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;
        }
    }
 
    /**
     * 任意位置插入,第一个数据节点为0号下标
     * 指定位置插入
     */
 
    public void addIndex(int index,int data) throws MySingleListIndexOutOfException{
        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;
    }
 
    /**
     * 找到index-1位置的节点
     * @param index
     * @return 该节点的地址
     */private ListNode findIndexSubOne(int index) {
        ListNode cur = this.head;
        while (index-1 != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }
 
    private void checkIndexAdd(int index) {
        if(index < 0 || index > size()) {
            throw new MySingleListIndexOutOfException("任意位置插入的时候，index不合法！");
        }
    }
 
    //查找是否包含关键字key是否在单链表当中  314public boolean contains(int key) {
        //head == null
        ListNode cur = this.head;
        //cur != null 说明 没有遍历完 链表while (cur != null) {
            if(cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
 
    //删除第一次出现关键字为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;
        }
    }
    //删除所有值为key的节点public void removeAllKey(int key){
        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;
        }
    }
 
    //得到单链表的长度public int size(){
        int count = 0;
        ListNode cur = this.head;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }
 
    /**
     * 当我们 执行clear这个函数的时候，会将这个链表当中的所有的节点回收
     */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;
    }
}

 

 

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

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

相关文章

Java基础：容器知识点

Java基础：容器知识点

目录 1、Java容器都有哪些&#xff1f; 2、Collection 和 Collections 区别&#xff1f; 3、List、Set、Map 间的区别&#xff1f; 4、HashMap 和 Hashtable 区别&#xff1f; 5、如何决定用 HashMap 还是 TreeMap&#xff1f; 6、HashMap 的实现原理&#xff1f; 7、说…
阅读更多...
浮点型在内存中的存储

浮点型在内存中的存储

常见的浮点数&#xff1a; 3.14159 1E10&#xff08;科学计数法&#xff1a;1.0*10^10&#xff09; 浮点数家族包括&#xff1a; float、double、long double 类型 浮点数表示的范围&#xff1a;float.h中定义 下面举一个例子&#xff1a; int main() {int n 9;float *pFloat…
阅读更多...
动态规划专练（一）

动态规划专练（一）

文章目录 前言一、斐波那契数1.题目介绍2.思路3.代码 二、爬楼梯1.题目介绍2.思路3.代码 三、使用最小花费爬楼梯1.题目介绍2.思路3.代码 前言 此篇为动态规划的初阶篇&#xff0c;所以比较简单&#xff0c;适合刚入门的新手学&#xff0c;如果你已经入门了&#xff0c;就无需看…
阅读更多...
[LeetCode]杨辉三角

[LeetCode]杨辉三角

给定一个非负整数 numRows&#xff0c;生成「杨辉三角」的前 numRows 行。 在「杨辉三角」中&#xff0c;每个数是它左上方和右上方的数的和。 给定一个非负整数 numRows&#xff0c;生成「杨辉三角」的前 numRows 行。 在「杨辉三角」中&#xff0c;每个数是它左上方和右上…
阅读更多...
（三）Python-tkinter桌面应用（爱心雨）

（三）Python-tkinter桌面应用（爱心雨）

&#xff08;三&#xff09;Python-tkinter桌面应用&#xff08;爱心雨&#xff09; 一、前言 我们已经了解到tkinter可以制作爱心&#xff0c;弹幕&#xff0c;为了能让他看起来更加的充满心意&#xff0c;于是&#xff0c;我们决定将他制作为爱心雨。让它看起来更加的特别&a…
阅读更多...
字节测试总监深度剖析，都2023年了，测试用例还不重视起来

字节测试总监深度剖析，都2023年了，测试用例还不重视起来

​ 测试用例对于测试工作的作用&#xff1a; 1、指导测试的实施 测试用例主要适用于集成测试、系统测试和回归测试。在实施测试时测试用例作为测试的标准&#xff0c;测试人员一定要按照测试用例严格按用例项目和测试步骤逐一实施测试。并对测试情况记录在测试用例管理软件中…
阅读更多...
超长JVM总结,面试必备

超长JVM总结,面试必备

目录 什么是JVM JVM内存区域 JVM运行时内存(jdk1.7) 垃圾回收与算法 分代收集算法 GC 分代收集算法 VS 分区收集算法 GC 垃圾收集器 什么是JVM JVM 是可运行 Java 代码的假想计算机 &#xff0c;包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收&#xff0c;…
阅读更多...
ChatGPT已死？AutoGPT太强？

ChatGPT已死？AutoGPT太强？

今天聊聊 AutoGPT。 OpenAI 的 Andrej Karpathy 都大力宣传&#xff0c;认为 AutoGPT 是 prompt 工程的下一个前沿。 近日&#xff0c;AI 界貌似出现了一种新的趋势&#xff1a;自主人工智能。 这不是空穴来风&#xff0c;最近一个名为 AutoGPT 的研究开始走进大众视野。特斯拉…
阅读更多...
PYTHON中的常见离散分布

PYTHON中的常见离散分布

1.什么是伯努利分布&#xff1f; 伯努利分布是一种二元随机变量的概率分布&#xff0c;其中一个结果的概率为p&#xff0c;另一个结果的概率为1-p。伯努利分布通常用于模拟二项分布&#xff0c;其中n个独立的伯努利试验被执行&#xff0c;每个试验有两个可能的结果&#xff08…
阅读更多...
Unity VFX -- （5）VFX Graph基础

Unity VFX -- （5）VFX Graph基础

在Unity中&#xff0c;还有一种完全不同的创建VFX的工作流&#xff0c;VFX Graph。VFX Graph能够生成出和粒子系统相同或更好的效果。 相比于粒子系统&#xff0c;VFX Graph的一个最大的好处是它能够在保持应用良好性能的情况下&#xff0c;模拟出多得多的粒子。对于VFX艺术家来…
阅读更多...
人生是一个长期的均值回归

人生是一个长期的均值回归

到了现在这个阶段&#xff0c;总想说点什么。 我一直觉得记录并收藏每个阶段的状态是一件很有意义且奇妙的事&#xff0c;尤其是多少年后还能清晰地回忆其当初的心境&#xff0c;联想到曾经所设立的一些目标以及为之做出的努力&#xff0c;这些人生经历的脉纹清晰而完整&#x…
阅读更多...
机器学习算法 KNN

机器学习算法 KNN

文章目录 一、概述二、代码实现三、K值的选择四、距离计算五、总结1. K-近邻算法2. 优缺点 一、概述 k-近邻算法&#xff08;k-Nearest Neighbour algorithm&#xff09;&#xff0c;又称为KNN算法&#xff0c;是数据挖掘技术中原理最简单的算法。 KNN的工作原理&#xff1a;…
阅读更多...
QT学习笔记6

QT学习笔记6

一.QLable控件使用&#xff1a; 创建控件&#xff1a; 方式一&#xff1a;代码 文本&#xff1a; QLabel *labelnew QLabel(this);//建立标签 label->setText("这是代码创建标签"); 超链接&#xff1a; label->setText("<h1><a href\"h…
阅读更多...
面向对象三大特性之一：封装

面向对象三大特性之一：封装

目录 什么是封装&#xff1f; 封装的优点 封装的实现 总结 在C中&#xff0c;类和对象是面向对象编程的基础&#xff0c;而封装是面向对象编程的三大特性之一。封装的作用是将数据和行为组合在一起&#xff0c;形成一个类&#xff0c;对外部隐藏实现细节&#xff0c;从而提高…
阅读更多...
【C++】位图模拟实现

【C++】位图模拟实现

文章目录 需要实现的接口构造函数如何得知要设置的元素的位置setresetfliptestsizecountanynoneall打印位图的信息 bitset.h 需要实现的接口 namespace Mango {template<size_t N> //N表示开多少个比特位class bitset{public://构造函数bitset();//设置位,将某一个数对应…
阅读更多...
Error：java: 程序包lombok不存在

Error：java: 程序包lombok不存在

Error&#xff1a;java: 程序包lombok不存在 有时候明明代码窗口里可以看到有这个类,但是启动就是报错说不存在(图1,图2),试过很多办法 1.查看工具中maven的设置,setting文件目录,maven目录,本地仓库目录 2.删除本地maven中的包,重新import, 3.jdk版本是否和pom里面的一致 4.重…
阅读更多...
一文教你快速搭建数据驱动自动化测试框架

一文教你快速搭建数据驱动自动化测试框架

目录 1. 什么是数据驱动自动化测试框架 2. 搭建数据驱动自动化测试框架的步骤 步骤1&#xff1a;确定测试需求 步骤2&#xff1a;准备测试数据 步骤3&#xff1a;编写测试脚本 步骤4&#xff1a;选择测试工具 步骤5&#xff1a;搭建测试环境 步骤6&#xff1a;执行测试 …
阅读更多...
二叉树相关基础选择填空题

二叉树相关基础选择填空题

目录 1、二叉树的( )遍历相当于广度优先遍历&#xff0c;( )遍历相当于深度优先遍历 2、已知某二叉树的前序遍历序列为5 7 4 9 6 2 1&#xff0c;中序遍历序列为4 7 5 6 9 1 2&#xff0c;则其后序遍历序列为&#xff08; &#xff09; 3、已知某二叉树的中序遍历序列为JGDHK…
阅读更多...
信号平滑处理

信号平滑处理

信号平滑处理 此示例说明如何使用移动平均滤波器和重采样来隔离一天中时间的周期性分量对每小时温度读数的影响&#xff0c;以及如何去除开环电压测量中不需要的电线噪声。该示例还说明如何通过使用中位数滤波器对时钟信号的水平进行平滑处理&#xff0c;同时保留边沿。该示例…
阅读更多...
c++算法初级8——递推

c++算法初级8——递推

c算法初级8——递推 文章目录 c算法初级8——递推递推递推思想的运用错位排序杨辉三角&#xff08;二维递推&#xff09; 递推 递推思想&#xff1a; 根据已有的东西一点点地推出未知的东西。 使用递推解题三步骤&#xff1a; 数学建模找出递推式和初始条件写出代码。 张爽…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023