p5-哈希表+有序表+链表

最新推荐文章于 2024-07-12 19:12:35 发布
最新推荐文章于 2024-07-12 19:12:35 发布
阅读量112 收藏
点赞数
分类专栏： java leetcode 文章标签： 链表 面试 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43295763/article/details/120071715
版权

p5-哈希表+有序表+链表

set与map

  1. set与map区别仅在于有无伴随数据，其他部分是相同的
  2. 增 put, 删 remove, 改put, 查get; 时间是常数级别，但可能是一个比较大的常数
  3. 哈希表内放入的是基础类型，如Integer、String（虽然String不是基础类型，但也会这样操作），是按值传递，哈希表会拷贝一份进去，内存占用就是该数据本身。
  4. 哈希表内放的不是基础类型，如自定义的Node、Student,是按引用传递，哈希表不会拷贝东西进去，而是记录内存地址，内存占用一律占 8 字节。

有序表 TreeSet， TreeMap

  1. 在哈希表的基础上，还保持内部数据的有序
  2. TreeSet与TreeMap区别仅在于有无伴随数据，其他部分是相同的
  3. 由于有序，所以有一些额外功能如，以一个递增的有序表为例：firstKey()找最小, lastKey()找最大, floorKey(8)找第一个小于等于 8 的数, ceilingKey(8)找第一个大于等于 8 的数
  4. 性能上，增删改查均为O(LogN)级别，比哈希表快
  5. 红黑树、AVL树、size-balance树、跳表均属于有序表结构，只是底层具体实现不同
  6. 有序表内放入的是基础类型，如Integer、String（虽然String不是基础类型，但也会这样操作），是按值传递，有序表会拷贝一份进去，内存占用就是该数据本身。
  7. 有序表内放的不是基础类型，如自定义的Node、Student,必须提供比较器，内部是按引用传递，有序表不会拷贝东西进去，而是记录内存地址，内存占用一律占 8 字节。

链表

  1. 牵扯到更改头节点，那么可以添加哑节点。如果不牵扯，则不用添加哑节点。
  2. 笔试：不用太在乎空间复杂度，一切为了时间复杂度
  3. 面试：时间复杂度放在第一，但一定找到空间最省的方法
  4. 练习时一定笔试面试都练
  5. 重要技巧：额外数据结构记录（哈希表），快慢指针

判断回文

如：1 2 3 3 2 1 回文， 1 20 3 20 1 回文，来判断单链表是否回文
笔试遇到：
节点放于栈中，弹栈与从头双指针判断，是否相同。空间N
优化一下：使用快慢指针，快走到头时，将慢走的压栈，这也可以只利用一半的N。
**注：**快慢指针在不同情境下，要求不同，有时要求快走到头时，慢走到一半，有时要求慢走到一半的前一个位置，有时对数据奇偶也有要求，所以需要自己练习。

面试遇到：空间O（1）
首先快慢指针找到中点，然后将中点往后的节点逆序，然后从头和新头一起遍历，如果同时走到中点，且内容正确，那么认为是回文，注意链表还得逆序回去。

代码如下：

class Solution {
    public boolean isPalindrome(ListNode head) {
        // 面试写法，占用空间O(1)，方法是首先快慢指针找中点，然后将中点后面的链表反转，获得两个头节点，双指针遍历判断，最后再反转回来
        ListNode fast = head;
        ListNode slow = head;
        // while(fast.next!=null&&fast.next.next!=null){
        //     // 此条件下最终slow会停留在中点处，偶数情况会停留在中间左侧那里
        //     fast = fast.next.next;
        //     slow = slow.next;
        // }
        while(fast!=null&&fast.next!=null){
            // 此条件下最终slow会停留在中点处，偶数情况会停留在中间右侧那里
            fast = fast.next.next;
            slow = slow.next;
        }
        ListNode head2 = reverse(slow);
        ListNode p1 = head;
        ListNode p2 = head2;
        while(p2!=null){
            if(p1.val!=p2.val){
                return false;
            }
            p1 = p1.next;
            p2 = p2.next;
        }
        reverse(head2);
        return true;
    }
    public ListNode reverse(ListNode head){
        ListNode fast = head;
        ListNode slow = null;
        while(fast!=null){
            ListNode temp = fast.next;
            fast.next = slow;
            slow = fast;
            fast = temp;
        }
        return slow;
    }
}

单链表划分左小中等右边大的形式

笔试：链表内容放入Node[]数组中，对这个数组进行 partition， 最后将其串起来
面试：6个变量，小于部分的头尾，等于部分的头尾，大于部分的头尾，初值为空。首次遇到某区域值，将头尾均指向它；每次遇到新值时，将其加入尾后面，尾更新。最终将6个变量首尾相连。
但是如果三个区域有一部分缺失，那么就不能这样穿起来，所以要讨论清楚边界。

public class NetherlandFlag {

    public static ListNode linkerPartition1(ListNode head, int num){
        // 笔试做法，定义一个ListNode数组，对该数组进行partition，然后将数组串起来
        int nodeLength = 0;
        ListNode curr = head;
        while(curr!=null){
            nodeLength++;
            curr = curr.next;
        }
        ListNode[] nodes = new ListNode[nodeLength];
        curr = head;
        int index = 0;
        while(curr!=null){
            nodes[index++] = curr;
            curr = curr.next;
        }

        // 进行partition
        int left = -1;// 左区间的边界，闭区间
        int right = nodeLength;
        index = 0;
        while(index<right){
            if(nodes[index].val<num){
                swapNode(nodes, ++left, index++);
            }else if(nodes[index].val>num){
                swapNode(nodes, --right, index);
            }else{
                index++;
            }
        }
        ListNode dummy = new ListNode(0);
        curr = dummy;
        for(ListNode node:nodes){
            curr.next = node;
            curr = curr.next;
            curr.next = null;
        }
        for(ListNode node:nodes){
            System.out.print(node.val + " ");
        }
        System.out.println();
        printListNode(dummy.next);
        return head;
    }

    public static void swapNode(ListNode[] nodes, int index1, int index2){
        // System.out.println(nodes[index1]);
        ListNode temp = nodes[index1];
        nodes[index1] = nodes[index2];
        nodes[index2] = temp;

    }

    public static ListNode linkerPartition2(ListNode head, int num){
        // 面试写法，六个指针来搞它
        ListNode leftHead = null;
        ListNode leftTail = null;
        ListNode midHead = null;
        ListNode midTail = null;
        ListNode rightHead = null;
        ListNode rightTail = null;
        ListNode curr = head;
        while(curr!=null){
            ListNode temp = curr.next;
            curr.next = null;
            if(curr.val<num){
                if(leftHead==null){
                    leftHead = curr;
                    leftTail = curr;
                }else{
                    leftTail.next = curr;
                    leftTail = leftTail.next;
                }
            }else if(curr.val==num){
                if(midHead==null){
                    midHead = curr;
                    midTail = curr;
                }else{
                    midTail.next = curr;
                    midTail = midTail.next;
                }
            }else{
                if(rightHead==null){
                    rightHead = curr;
                    rightTail = curr;
                }else{
                    rightTail.next = curr;
                    rightTail = rightTail.next;
                }
            }
            curr = temp;
        }
        /*
        // 分为 8 种情况，
        // 如果都没有
        if(leftHead==null&&midHead==null&&rightHead==null){// 000
            return null;
        }
        if(leftHead==null&&midHead==null&&rightHead!=null){// 001
            rightTail.next = null;
            return rightHead;
        }
        if(leftHead==null&&midHead!=null&&rightHead==null){// 010
            midTail.next = null;
            return midHead;
        }
        if(leftHead==null&&midHead!=null&&rightHead!=null){// 011 
            midTail.next = rightHead;
            rightTail.next = null;
            return midHead;
        }
        if(leftHead!=null&&midHead==null&&rightHead==null){// 100
            leftTail.next = null;
            return leftHead;
        }
        if(leftHead!=null&&midHead==null&&rightHead!=null){// 101
            leftTail.next = rightHead;
            rightTail.next = null;
            return leftHead;
        }
        if(leftHead!=null&&midHead!=null&&rightHead==null){// 110
            leftTail.next = midHead;
            midTail.next = null;
            return leftHead;
        }
        if(leftHead!=null&&midHead!=null&&rightHead!=null){// 111
            leftTail.next = midHead;
            midTail.next = rightHead;
            rightTail.next = null;
            return leftHead;
        }
        */
        // 合并一下
        if(leftHead==null){
            if(midHead!=null){
                // 010 011
                midTail.next = rightHead;
                return midHead;
            }else{
                return rightHead;
            }
        }else{
            if(midHead!=null){
                // 110 111
                leftTail.next = midHead;
                midTail.next = rightHead;
            }else{
                // 100 101
                leftTail.next = rightHead;
            }
            return leftHead;
        }
    }

    public static void printListNode(ListNode head){
        while(head!=null){
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }
    public static void main(String[] args) throws Exception {
        int[] nums = new int[]{5,4,2,1};
        ListNode dummy = new ListNode(0);
        ListNode last = dummy;
        for(int num:nums){
            ListNode now = new ListNode(num);
            last.next = now;
            last = now;
        }
        printListNode(dummy.next);
        // linkerPartition1(dummy.next, 8);
        ListNode temp = linkerPartition2(dummy.next,2);
        printListNode(temp);

    }
}

复制含有随机指针节点的链表

特殊单链表节点

class Node{
    int value;
    Node next;
    Node rand;
    ...
}

rand可能指向链表中任一个节点，也可能指向null。给定一个Node节点组成的无环单链表的头节点，实现一个函数完成这个链表的复制，并返回复制的新链表的头节点。要求时间 N，空间 1
笔试：哈希表记录，key为老节点，value为新节点。首先遍历一遍，同时克隆一个新节点放入map中。再遍历链表，更改next指针与rand指针指向新的克隆的节点。最后返回新的头
面试：
遍历链表，生成新节点串在老节点的下一个。如1->2->3 1->1`->2->2`->3->3`
然后就可以一对一对拿出新老节点。那么针对每一个老节点的rand指针，新节点均可以指向老节点的next来实现。这样一来新节点的rand也成功了。最后删除老节点。
为什么能省去hash表的空间？通过位置关系，来节省了哈希表空间

public class RandomList {
    /*
    特殊单链表节点
    ```java
    class Node{
        int value;
        Node next;
        Node rand;
        ...
    }
    ```
    rand可能指向链表中任一个节点，也可能指向null。给定一个Node节点组成的无环单链表的头节点，实现一个函数完成这个链表的复制，并返回复制的新链表的头节点。要求时间 N，空间 1
    **笔试**：哈希表记录，key为老节点，value为新节点。首先遍历一遍，同时克隆一个新节点放入map中。再遍历链表，更改next指针与rand指针指向新的克隆的节点。最后返回新的头
    **面试**：
    遍历链表，生成新节点串在老节点的下一个。如1->2->3  1->1\`->2->2\`->3->3\`
    然后就可以一对一对拿出新老节点。那么针对每一个老节点的rand指针，新节点均可以指向老节点的next来实现。这样一来新节点的rand也成功了。最后删除老节点。
    为什么能省去hash表的空间？通过位置关系，来节省了哈希表空间  
    */

    public static RandomNode randomList1(RandomNode head, int num){
        // 笔试做法，利用哈希表来记录老节点
        Map<RandomNode, RandomNode> map = new HashMap<>();
        RandomNode temp = head;
        while(temp!=null){
            map.put(temp, new RandomNode(temp.val));
            temp = temp.next;
        }
        for(Entry<RandomNode, RandomNode> entry:map.entrySet()){
            RandomNode oldNode = entry.getKey();
            RandomNode newNode = entry.getValue();
            newNode.next = map.get(oldNode.next);
            newNode.rand = map.get(oldNode.rand);
        }
        return map.get(head);
    }

    public static RandomNode randomList2(RandomNode head, int num){
        // 面试做法：遍历一遍，将原链表每个节点后新增一个链表来确定两者关系
        if(head == null){
            return null;
        }
        RandomNode curr = head;
        while(curr!=null){
            RandomNode temp = curr.next;
            curr.next = new RandomNode(curr.val);
            curr.next.next = temp;
            curr = temp;
        }
        // printListNode(head);
        // 为新节点新增rand指针
        curr = head;
        while(curr!=null){
            // 如果传入链表为空怎么办？
            RandomNode newNode = curr.next;
            newNode.rand = curr.rand==null?null:curr.rand.next;
            curr = curr.next.next;
        }
        // 断开新老节点得联系
        curr = head.next;
        while(curr!=null&&curr.next!=null){
            curr.next = curr.next.next;
            curr = curr.next;
        }

        return head.next;
    }


    public static void printListNode(RandomNode head){
        while(head!=null){
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }
    public static void main(String[] args) throws Exception {
        int[] nums = new int[]{5,4,2,1};
        RandomNode dummy = new RandomNode(0);
        RandomNode last = dummy;
        for(int num:nums){
            RandomNode now = new RandomNode(num);
            last.next = now;
            last = now;
        }
        // 添加rand指针
        RandomNode curr1 = dummy.next; // 5
        RandomNode curr2 = curr1.next; // 4
        RandomNode curr3 = curr2.next; // 2
        RandomNode curr4 = curr3.next; // 1
        curr1.rand = curr3;
        curr2.rand = curr4;
        curr3.rand = curr3;
        curr4.rand = null;
        
        printListNode(dummy.next);
        // linkerPartition1(dummy.next, 8);
        RandomNode temp = randomList2(dummy.next,2);
        printListNode(temp);

        // 验证rand指针
        curr1 = temp; // 5
        curr2 = curr1.next; // 4
        curr3 = curr2.next; // 2
        curr4 = curr3.next; // 1

        System.out.println(curr1.rand.val);
        System.out.println(curr2.rand.val);
        System.out.println(curr3.rand.val);
        System.out.println(curr4.rand);

    }
}

单链表相交的问题

题目：给定两个可能有环也可能无环得单链表 head1， head2。实现函数，如果链表相交，则返回第一个相交得节点，否则返回null。
要求：链表长之和为N，时间O(N), 空间O(1)
例如：a - b - c - d 相交为b
e/

问题1：判断单链表有环无环，并返回第一个入环节点。
解：笔试哈希表，遍历时，首先判断是否在set中，是得话就是入环节点。面试快慢指针，快两步，慢一步。直到两者相遇。此时快指针从头走，两者同时走一步，再次相遇时会在第一个入环节点处。记住即可

原问题：用问题1来获得两个入环节点 loop1， loop2。分情况

  1. loop1 = null, loop2 = null:说明要么他们都是单独的，要么两者相交。先求两个链表长度与终点，如果终点不同，那么说明不相交；如果终点相同，那么两个指针从头往后走，到头的从另一个链表开始走，最终一定相遇于相交节点。也可以长链表先走长度差步数，然后长短一起走，最终相遇于相交节点。
  2. loop1,loop2一个为空，一个非空。不可能相交。
  3. loop1,loop2均非空；那么1：各自成环，2：共用环，且入环节点相同，3：共用环，但入环节点不同

如果loop1 == loop2,则是共用环且入环节点相同的情况。此情况可以将loop作为尾节点，套用无环判断相交的写法。
让loop1继续走，直到走到loop1之前，遇不到则是情况1，返回空；如果遇到loop2，则是情况3，返回loop1，2都对，两者都是第一个相交节点。

public class Solution {

    public static ListNode detectCycle(ListNode head) {
        // 判断单链表有环无环，并返回第一个入环节点。
        if(head==null||head.next==null||head.next.next==null){
            return null;
        }
        ListNode fast = head.next.next;
        ListNode slow = head.next;
        while(slow!=fast){
            if(fast.next==null||fast.next.next==null){
                return null;
            }
            fast = fast.next.next;
            slow = slow.next;
        }
        fast = head;
        while(fast!=slow){
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }

    public static ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 解决无环链表首次相交节点的问题
        ListNode p1 = headA;
        ListNode p2 = headB;
        int m = 0;
        while(p1!=null){
            m++;
            p1 = p1.next;
        }
        while(p2!=null){
            m--;
            p2 = p2.next;
        }
        if(p1!=p2){
            return null;
        }
        p1 = m>=0?headA:headB;
        p2 = p1 == headA?headB:headA;
        m = Math.abs(m);
        while(m-->0){
            p1 = p1.next;
        }
        while(p1!=p2){
            p1 = p1.next;
            p2 = p2.next;
        }
        return p1;
    }

    public static ListNode findFirstIntersectNode(ListNode head1, ListNode head2){
        ListNode loop1 = detectCycle(head1);
        ListNode loop2 = detectCycle(head2);
        if(loop1==null&&loop2==null){
            return getIntersectionNode(head1, head2);
        }else if(loop1!=null&&loop2!=null){
            if(loop1==loop2){
                ListNode p1 = head1;
                ListNode p2 = head2;
                while(p1!=p2){
                    p1 = p1==loop1?head2:p1.next;
                    p2 = p2==loop1?head1:p2.next;
                }
                return p1;
            }else{
                ListNode curr = loop1;
                while(curr!=loop1){
                    if(curr == loop2){
                        return loop1;
                    }
                    curr = curr.next;
                }
                return null;
            }
        }else{
            return null;
        }
    }

    public static void printListNode(ListNode head){
        while(head!=null){
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }
    public static ListNode createList(int[] nums){
        ListNode dummy = new ListNode(0);
        ListNode last = dummy;
        for(int num:nums){
            ListNode now = new ListNode(num);
            last.next = now;
            last = now;
        }
        return dummy.next;
    }
    public static void main(String[] args) throws Exception {
        int[] nums = new int[]{7,8,6,9};
        int[] nums2 = new int[]{5,4,2,1};
        ListNode head1 = createList(nums);
        ListNode head2 = createList(nums2);
        // 目前是两个无交点无欢单链表
        System.out.println(findFirstIntersectNode(head1,head2));

        ListNode tail2 = head2.next.next.next;
        tail2.next = head1.next.next;
        // 目前是两个有交点, 无环单链表，链表2的结尾指向了链表1的第三个节点即6
        System.out.println(findFirstIntersectNode(head1,head2).val);

        
        head1.next.next.next.next = head1.next.next;
        head2.next.next.next.next = head2.next.next;
        // 目前是两个无交点, 各自成环单链表
        System.out.println(findFirstIntersectNode(head1,head2));

        tail2.next = head1.next;
        // 目前是两个有交点, 共用一个环的单链表，链表2的结尾指向链表1的第二个节点即8
        System.out.println(findFirstIntersectNode(head1,head2).val);

        tail2.next = head1.next.next;
        // 目前是两个有交点, 共用一个环的单链表，链表2的结尾指向链表1的第三个节点，即6
        System.out.println(findFirstIntersectNode(head1,head2).val);

    }
}
技不如人，甘拜下风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现哈希表（源码+解析）
03-13
哈希表节点结构 struct Node：表示哈希表中的一个节点，包含键、值以及指向下一个节点的指针。 哈希表结构 struct HashTable：...销毁哈希表函数 destroyHashTable：释放哈希表的内存，包括每个链表的节点和数组本身。
【力扣刷题】数组-链表-哈希-双指针
06-21
哈希的实现方式有很多种，例如哈希表、哈希链表等。哈希的优点是可以快速地查找元素，但缺点是可能出现哈希冲突。 双指针是一种常用的算法技巧，用于解决链表、数组等数据结构的问题。双指针的优点是可以快速地解决...
有序表哈希表查找
wei_915539507的博客
06-26 588
#include&lt;stdio.h&gt;  #include&lt;stdlib.h&gt;   void Sort(int ST[],int len)  {     inti,j,index,min,temp;       for(i=0;i&lt;len;i++)   {       min= ST[i];     for(j=i;j&lt;len;j++)          if(ST...
4，链表【p5】
m0_53514934的博客
08-05 119
链表的大部分做题方法、哈希表、有序表
剑指offer-链表&数组
albyc22660的专栏
09-01 189
1.圆圈中最后剩下的数 每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0...m-1...
c++链表
Python自学记录
03-16 292
线性表的顺序存储：连续的内存空间； 线性表的链式存储：不连续的内存空间； 链表概念 链表由一系列结点组成，每个节点包含两个域，最后一个节点的指针域为空，头结点不保存信息； 链表框架 linklist.h文件 //linklist.h：定义链表结点和方法。 #include <string> using namespace std; struct Info//节点存放的数据 { s...
通过数据结构 -- acwing
Alex_Miller的博客
10-18 217
数据结构实现
阿里P5-集合相关
weixin_46610759的博客
10-06 332
阿里P5-集合相关 1.描述下Java常用集合类的继承关系？ Java是一门面向对象的语言，在实际的编程中也常常会对多个对象进行操作，此时常常就需要用到集合来存储多个对象。数组虽然也可以存储对象，但长度是固定的；集合长度是可变的，数组中可以存储基本数据类型，集合只能存储对象，集合长度是可变的，可以存储不同类型的对象。 Collection （集合的最大接口）继承它的常用子类有： ——List　可以存放重复的内容 ——Set　　不能存放重复的内容，所以的重复内容靠hashCode()和equals()两个方
哈希表
Junhan's Blog
04-09 462
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 哈希函数
全网首发：阿里技术官纯手打 Java架构师 进阶宝典，P5-P8完整覆盖
m0_62051288的博客
11-30 378
可能有些人会常常有这样的感觉，同是开发有些人比我工资高却什么代码都不写呢？当我听到这个问题的时候第一次映入脑海的就是：工程师的分类。初中级开发工程师一般的初中级开发工程师要求不是特别的高，很多都是要求你会在公司干活，然后能够对公司项目进行代码的编写，和业务的实现。一般要求熟悉 Spring boot，Spring等框架；熟悉dubbo框架、redis等；熟悉Unix/Linux系统，精通数据库Oracle、MySQL 等的开发，精通SQL及存储过程编写能力；就行了。高级Java开发工程师。
掌握P5级Java面试技巧
热门推荐
Java程序员廖志伟
03-25 3万+
HashMap底层原理，扩容机制，jdk8以后会使用红黑树优化？红黑树和二叉平衡树的区别，红黑树和B树，B+树的区别，Mysql二大引擎索引底层实现，HashMap在多线程环境中为何出错？ConcurrentHashMap底层实现，CAS，原子引用，ABA问题，volatile，如何解决HashMap出现的OOM问题？（WeakHashMap） HashMap是Map的一个实现类，它是以键值对存储数据的，Key-Value都是Map.Entry中的属性。当我们向HashMap中存放一个元素(k1,v1)
Java实现 LeetCode 706 设计哈希映射（数组+链表）
01-20
不使用任何内建的哈希表库设计一个哈希映射 具体地说，你的设计应该包含以下的功能 put(key, value)：向哈希映射中插入(键,值)的数值对。如果键对应的值已经存在，更新这个值。 get(key)：返回给定的键所对应的值，...
上机作业-链表.cpp
09-19
接下来，"数据结构"是一个更广泛的概念，它包含了链表、数组、栈、队列、树、图、哈希表等多种不同的数据组织方式。在给定的文件中，我们可以看到一些具体的数据结构实例，如： 1. **栈**：栈是一种后进先出（LIFO...
哈希表经典讲解+各项优化+分析
02-08
2. **链地址法**：在每个哈希桶内使用链表连接所有映射到该位置的元素，这样即使多个元素哈希到同一位置，也能通过链表进行后续操作。 3. **再哈希法**：使用另一个哈希函数来解决冲突，直至找到未被占用的哈希地址...
面试题 21：解释 Python 中的 help() 函数和 dir() 函数？
专注于全栈开发领域
07-10 731
在Python中，help()和dir()是两个非常有用的内置函数，它们可以帮助开发者更好地了解Python对象和模块。
Bilibili Android一二面凉经(2024)
景三的专栏
07-09 1085
笔者作为一名双非二本毕业7年老Android, 最近面试了不少公司, 目前已告一段落, 整理一下各家的面试问题, 打算陆续发布出来, 供有缘人参考。今天给大家带来的是《bilibili Android一二面凉经(2024)》。
面试算法心得——反转链表
晴天学长
07-12 256
注意，每个链表最后一个节点就是null，所以头节点应该是null。
Java基础面试题大全
最新发布
m0_58466443的博客
07-12 583
在Java中，创建子类对象时，如果没有用 super() 来调用父类特定的构造方法，则会调用父类中“无参构造方法”。如果此时父类没有无参构造，则编译报错。解决方案是要么给子类加上super指定父类的具体构造函数，要么给父类加上无参构造函数。方法的返回值：是指我们想要得到某个方法体中的代码执行后产生的结果！无参无返回值有参无返回值有返回值有参有返回值无参从 Java5 开始，Java 支持定义可变长参数，就是允许在调用方法时传入不定长度的参数，定义方法就是在参数类型后面加三个点。
数据结构课程设计----哈希表设计
12-24
哈希表是一种常用的数据结构，它可以高效地存储和检索数据。在哈希表中，数据元素通过哈希函数转换为索引，然后存储在数组中。哈希函数将数据元素映射到数组的特定位置，这样可以快速地访问和操作数据。 下面是一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值