Leetcode链表专题专练-万字总结

已于 2023-01-17 15:03:08 修改
阅读量596 收藏 1
点赞数 1
分类专栏： 算法提炼 文章标签： 链表 leetcode 数据结构 算法 go
于 2023-01-17 14:50:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54174102/article/details/128695445
版权

文章目录

系列：链表专练
语言：java & go
题目来源：Leetcode
常考点： 单链表 & 双链表 &双指针

思路和参考答案

链表专题总结

在这里插入图片描述

  1. 链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域，一个是指针域(存放指向下一个节点的指针)，最后一个节点的指针域指向NULL(空指针)。
  2. 链表有三种，单链表，双链表，循环链表，存储方式不象数组那样子连续分布，而是通过指针域的指针来连接内存中各个节点的。分布是不连续的，是散乱分布在内存中的某地址上。
  3. 链表的长度是不固定的，可以动态增删，适合数量不固定，频闪增删，较少查询的场景。
  4. 常用虚拟头节点的添加来便捷链表之后的操作。

链表专练

  1. leetcode203. 移除链表元素 难度：简单

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

分析：如果需要删除第三个节点，那我们应该知道前一个节点才能完成相关操作。那么如果只有一个节点head时，如何进行操作呢，那就要进行相关判断，所以我们可以建一个虚拟头节点来使对每个符合条件的节点进行相同的删除操作，就是通过前一个节点来进行删除操作
java参考代码：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null){
            return head;
        }
        ListNode dummy = new ListNode(-1,head);
        ListNode pre = dummy;
        ListNode cur = head;
        while(cur!= null){
            if(cur.val == val){
                pre.next = cur.next;
            }else{
                pre = cur;
            }
            cur = cur.next;
        }
        //这里为什么要返回dummy.next 而不是head呢？
        //因为新的头节点使dummy.next，而不是原来的head了
        return dummy.next;
    }
}

go参考代码：

func removeElements(head *ListNode, val int) *ListNode {
	dummy := &ListNode{}
	dummy.Next = head
	cur := dummy
	for cur != nil && cur.Next != nil {
		if cur.Next.Val == val {
			cur.Next = cur.Next.Next
		} else {
			cur = cur.Next
		}
	}
	return dummy.Next
}
  1. Leetcode707. 设计链表 难度：中等

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
在链表类中实现这些功能：
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

这道题非常适合用来练习链表相关操作，可以多加练习熟悉链表的操作，这里使用的依然是添加虚拟头节点的前提，不懂的可以跟着先敲，多敲几遍就理解其中的含义了，我至少跟着敲了十遍，才渐渐明白链表的相关操作以及含义，好事多磨！

java解法：分为单链表实现和双链表实现

//单链表解法
class ListNode{
    int val;
    ListNode next;
    ListNode(){};
    ListNode(int val){
       this.val = val;
    }
}
class MyLinkedList {
    int size;
    ListNode head;
    ListNode dummy;
    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
        dummy = new ListNode(-1);
        head = dummy.next;
    }
    
    public int get(int index) {
        if(index < 0 || index >=size){
            return -1;
        }
        ListNode cur = dummy;
        for(int i =0;i<index;i++){
            cur = cur.next;
        }
        return cur.next.val;
    }
    
    public void addAtHead(int val) {
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
        if(index >size){
            return;
        }
        if(index < 0){
            index  = 0;
        }
        size++;
        ListNode perd = dummy;
        for(int i =0;i<index;i++){
            perd = perd.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = perd.next;
        perd.next = toAdd;
    }
    
    public void deleteAtIndex(int index) {
        if(index<0 || index >= size){
            return;
        }
        size--;
        ListNode perd = dummy;
        for(int i =0;i<index;i++){
            perd = perd.next;
        }
        perd.next = perd.next.next;
    }
}
//双链表写法
//双链表
class ListNode{
    int val;
    ListNode next,prev;
    ListNode() {};
    ListNode(int val){
        this.val = val;
    }
}


class MyLinkedList {  

    //记录链表中元素的数量
    int size;
    //记录链表的虚拟头结点和尾结点
    ListNode head,tail;
    
    public MyLinkedList() {
        //初始化操作
        this.size = 0;
        this.head = new ListNode(0);
        this.tail = new ListNode(0);
        //这一步非常关键，否则在加入头结点的操作中会出现null.next的错误！！！
        head.next=tail;
        tail.prev=head;
    }
    
    public int get(int index) {
        //判断index是否有效
        if(index<0 || index>=size){
            return -1;
        }
        ListNode cur = this.head;
        //判断是哪一边遍历时间更短
        if(index >= size / 2){
            //tail开始
            cur = tail;
            for(int i=0; i< size-index; i++){
                cur = cur.prev;
            }
        }else{
            for(int i=0; i<= index; i++){
                cur = cur.next; 
            }
        }
        return cur.val;
    }
    
    public void addAtHead(int val) {
        //等价于在第0个元素前添加
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        //等价于在最后一个元素(null)前添加
        addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
        //index大于链表长度
        if(index>size){
            return;
        }
        //index小于0
        if(index<0){
            index = 0;
        }
        size++;
        //找到前驱
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        //新建结点
        ListNode newNode = new ListNode(val);
        newNode.next = pre.next;
        pre.next.prev = newNode;
        newNode.prev = pre;
        pre.next = newNode;
        
    }
    
    public void deleteAtIndex(int index) {
        //判断索引是否有效
        if(index<0 || index>=size){
            return;
        }
        //删除操作
        size--;
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        pre.next.next.prev = pre;
        pre.next = pre.next.next;
    }
}

go参考代码： 分为单链表和双链表实现

//单链表实现
// 节点结构体
type Node struct {
    Val int
    Next *Node 
}
// MylinkedList是一个对象，需要去实现LinkedList接口的所有方法
type MyLinkedList struct {
    DummyHead *Node //虚拟头节点
    Size int //链表长度
}

//创建一个链表 
func Constructor() MyLinkedList { //成功
    // 创建一个虚拟头节点，非真正的头节点(真正的头节点是数组第一个节点)
    dummyHead := &Node{
        Val : -1,
        Next : nil,
    }
    return MyLinkedList{DummyHead: dummyHead,Size: 0}
}
// 获取index位置的元素Val
// 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
func (this *MyLinkedList) Get(index int) int {
    // 判断index是否非法
    if (index < 0) || (index > (this.Size - 1)) {
        return -1
    }
    // 查找
   var cur *Node = this.DummyHead// dummy节点的index = -1 
	for i := 0;i < index;i++ {//找到index为 index的节点
        cur = cur.Next //0,1,2,3,4....index
    }
	return cur.Next.Val
}

// 在头节点前面再次添加一个节点
func (this *MyLinkedList) AddAtHead(val int)  { //成功
    // 在dummy节点后面直接添加一个节点
	var newNode *Node = &Node{Val:val, Next:nil,} //所有变量都要显示的初始化
    newNode.Next = this.DummyHead.Next
    this.DummyHead.Next = newNode
    this.Size++
}


// 在尾结点添加节点
func (this *MyLinkedList) AddAtTail(val int)  {
    var newNode *Node = &Node{val, nil}
    cur := this.DummyHead
    for cur.Next != nil { //找到末尾节点
        cur = cur.Next
    }
	cur.Next = newNode //新元素添加到末尾节点后面
    this.Size++
}

// 在index节点前面添加一个节点 
func (this *MyLinkedList) AddAtIndex(index int, val int)  {
    if index > this.Size {
        return
    }else if index == this.Size { //直接添加到末尾
        this.AddAtTail(val) 
        return
    }else if index < 0 {
        index = 0
    }
    var newNode *Node = &Node{val, nil}
    cur := this.DummyHead
    for i:=0; i<index; i++ { //找到index为 index-1的节点,如果index=0，则不会进入循环，直接插入到dummy后面
        cur = cur.Next
    }
    newNode.Next = cur.Next
    cur.Next = newNode
    this.Size++
}
// 删除index节点
func (this *MyLinkedList) DeleteAtIndex(index int)  {
    // 判断是否有效
    if index > this.Size-1 || index < 0 {
        return
    }
    cur := this.DummyHead
    for i := 0; i < index; i++ {
        cur = cur.Next
    }
    cur.Next = cur.Next.Next
    this.Size--
}
// func main(){
//     obj := Constructor()
// 	obj.AddAtHead(1)
// 	obj.AddAtTail(2)
// 	obj.AddAtIndex(0,0)
// 	obj.DeleteAtIndex(0)
// 	fmt.Println(obj.Get(0),obj.Get(1),obj.Get(2))
	
// }


//双链表写法
//双链表解法
// 节点结构体
type Node struct {
	Val  int
	Next *Node
	Pre  *Node
}

// 链表对象
type MyLinkedList struct {
	DummyHead *Node
	DummyTail *Node
	Size      int
}

// 创建一个有虚拟首位节点的链表
func Constructor() MyLinkedList {
	dummyHead := &Node{-1, nil, nil}
	dummyTail := &Node{-1, nil, dummyHead}
	dummyHead.Next = dummyTail
	return MyLinkedList{dummyHead, dummyTail, 0}
}

// 获取index节点
func (this *MyLinkedList) Get(index int) int {
	if index >= this.Size || index < 0 {
		return -1
	} else {
		p := this.DummyHead
		for i := 0; i < index; i++ {
			p = p.Next
		}
		return p.Next.Val
	}
}

// 在头结点前面添加一个节点称为新的头节点
func (this *MyLinkedList) AddAtHead(val int) {
	var newNode *Node = &Node{val, nil, nil}
	//后插法添加节点
	newNode.Next = this.DummyHead.Next
	newNode.Pre = this.DummyHead
	this.DummyHead.Next.Pre = newNode
	this.DummyHead.Next = newNode
	this.Size++
}

// 在尾结点后面添加一个节点
func (this *MyLinkedList) AddAtTail(val int) {
	//在dummytail前面添加一个节点
	var newNode *Node = &Node{val, nil, nil}
	//前插法添加节点
	newNode.Next = this.DummyTail
	newNode.Pre = this.DummyTail.Pre
	this.DummyTail.Pre.Next = newNode
	this.DummyTail.Pre = newNode
	this.Size++
}

// 在指定位置插入一个节点
func (this *MyLinkedList) AddAtIndex(index int, val int) {
	if index > this.Size {
		return
	} else if index < 0 {
		this.AddAtHead(val)
	} else {
		p := this.DummyHead
		for i := 0; i < index; i++ {
			p = p.Next
		}
		var newNode *Node = &Node{val, p.Next, p}
		p.Next.Pre = newNode
		p.Next = newNode
		this.Size++
	}
}

// 删除指定index的节点
func (this *MyLinkedList) DeleteAtIndex(index int) {
	if index >= this.Size || index < 0 {
		return
	} else {
		p := this.DummyHead
		for i := 0; i < index; i++ {
			p = p.Next
		}
		p.Next.Next.Pre = p
		p.Next = p.Next.Next
		this.Size--
	}
}
  1. leetcode206. 反转链表 难度：简单

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

思路：通过快慢指针，来改变链表的指向，将链表的指向反过来，如果本来指针指向是1->2->3,我们将链表指向改为1<-2<-3,通过移动两个指针来实现，最后打印输出指针即可

java参考代码：双指针和递归

//双指针
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre=null ;
        ListNode temp =null;
        ListNode cur = head;
        while(cur != null){
            temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur= temp;
        }
        return pre;
    }
}
//递归
class Solution{
    public ListNode reverseList(ListNode head){
        return reverse(null,head);
    }
    private ListNode reverse(ListNode pre,ListNode cur){
        if(cur == null){
            return pre;
        }
        ListNode temp = null;
        temp = cur.next; //先保存下一个节点
        cur.next = pre; //反转
        //更新pre cur位置
        return reverse(cur,temp);
    }
}

go参考代码： 双指针和递归

//双指针
func reverseList(head *ListNode) *ListNode {
    var pre *ListNode
    cur := head
    for cur != nil {
        next := cur.Next
        cur.Next = pre
        pre = cur
        cur = next
    }
    return pre
}

//递归
func reverseList(head *ListNode) *ListNode {
    return help(nil, head)
}

func help(pre, head *ListNode)*ListNode{
    if head == nil {
        return pre
    }
    next := head.Next
    head.Next = pre
    return help(head, next)
}
  1. leetcode24. 两两交换链表中的节点 难度：中等

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

思路：有一点你需要明白，链表不同于其他类型，如果要交换两个节点的位置，需要改变的是指针的指向，比如dummy(虚拟头结点)->1->2->3->4,我们交换完后是dummy(虚拟头结点)->2->1->4->3，怎样实现：将头结点的next指向2，而不是指向1，将2的next指向1，1的next指向4,4的next指向3，这样的话就实现了交换两个节点。

java实现：

class Solution {
    public ListNode swapPairs(ListNode head) {
       ListNode dummy = new ListNode(-1,head);
        ListNode cur = dummy;
        ListNode temp;
        ListNode firstNode;
        ListNode secondNode;
        while(cur.next != null && cur.next.next != null){
            temp = cur.next.next.next;
            firstNode = cur.next;
            secondNode = cur.next.next;
            cur.next = secondNode;
            secondNode.next = firstNode;
            firstNode.next = temp; 
            cur = firstNode; //cur移动，准备下一轮交换
        }
        return dummy.next;
    }
}

go实现：

func swapPairs(head *ListNode) *ListNode {
    dummy := &ListNode{
        Next: head,
    }
    pre := dummy
    for head != nil && head.Next != nil{
        pre.Next = head.Next
        next := head.Next.Next
        head.Next.Next = head
        head.Next = next
        pre = head
        head = next
    }
    return dummy.Next
}
  1. leetcode19. 删除链表的倒数第 N 个结点 难度：中等

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

思路：双指针思路，：通过将slow和fast两个指针之间间隔为n，即fast比slow多走n步，然后根据判断fast的下一个节点是否是空，然后此时slow指向的刚好是目标节点的前一个节点，所以可以完成删除

//双指针解法：通过将slow和fast两个指针之间间隔为n，即fast比slow多走n步
//
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
       ListNode dummy = new ListNode(-1，head);
       ListNode fastNode = dummy;
       ListNode slowNode = dummy;
        for(int i =0;i<n;i++){
            fastNode = fastNode.next;
        }
        while(fastNode.next != null){
            fastNode = fastNode.next;
            slowNode = slowNode.next;
        }
        slowNode.next = slowNode.next.next;
        return dummy.next;
    }
}

go语言版本同样的道理：通过一快一慢指针，先将fast指针比slow指针快移动n步，然后再开始移动slow指针，类比上面java的思路 一样的

func removeNthFromEnd(head *ListNode, n int) *ListNode {
    dummy := &ListNode{}
    dummy.Next = head
    cur := head
    pre := dummy
    i:=1
    for cur!= nil{
        cur= cur.Next
        if i>n{
            pre = pre.Next
        }
        i++
    }
    pre.Next = pre.Next.Next
    return dummy.Next
}
  1. leetcode面试题 02.07. 链表相交

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

思路：首先要想比较两个链表的相同点，比较的不是开头，长的链表需要向后移动两个链表长度差，然后才能开始比较，这个是前提，所以我们同时也需要分别统计出链表a和链表b的长度；然后对齐后开始比较，有相同交点直接返回

java方法：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int lenA = 0,lenB = 0;
        while(curA != null){ //求链表A的长度
            lenA++;
            curA = curA.next;
        }
        while(curB != null){ //求链表B的长度
            lenB++;
            curB = curB.next;
        }
        curA = headA;
        curB = headB;
        if(lenB>lenA){
            int tmplen = lenA;
            lenA = lenB;
            lenB = tmplen;
            ListNode tmpNode =curA;
            curA = curB;
            curB = tmpNode;
        }
        //求长度差
        int gap = lenA-lenB;
        //让curA和curB在同一起点上(末尾位置对齐)
        while(gap-->0){
            curA = curA.next;
        }
        while(curA != null){
            if(curA == curB){
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }
}

go方法：

func getIntersectionNode(headA, headB *ListNode) *ListNode {
    curA := headA
    curB := headB
    lenA, lenB := 0, 0
    // 求A，B的长度
    for curA != nil {
        curA = curA.Next
        lenA++
    }
    for curB != nil {
        curB = curB.Next
        lenB++
    }
    var step int
    var fast, slow *ListNode
    // 请求长度差，并且让更长的链表先走相差的长度
    if lenA > lenB {
        step = lenA - lenB
        fast, slow = headA, headB
    } else {
        step = lenB - lenA
        fast, slow = headB, headA
    }
    for i:=0; i < step; i++ {
        fast = fast.Next
    }
    // 遍历两个链表遇到相同则跳出遍历
    for fast != slow {
        fast = fast.Next
        slow = slow.Next
    }
    return fast
}
  1. leetcode142. 环形链表 II 难度：中等

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

思路：首先判断是否有环，通过双指针进行判断，一快一慢，fast快指针比slow慢指针每次多走一步，如果有环的话，快慢指针会相遇的，否则无环；如果找到环的出口，因为每次fast快指针走的路程是慢指针走的路程的两倍，所以根据数学公式。
假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。
那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。
因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：
(x + y) * 2 = x + y + n (y + z)
两边消掉一个（x+y）: x + y = n (y + z)
因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。
所以要求x ，将x单独放在左面：x = n (y + z) - y ,
再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。
先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。
当 n为1的时候，公式就化解为 x = z

java解法：

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast){//有环
                ListNode index1 = fast;
                ListNode index2 = head;
                while(index1 != index2){
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
    }
}

go解法：

func detectCycle(head *ListNode) *ListNode {
    slow, fast := head, head
    for fast != nil && fast.Next != nil {
        slow = slow.Next
        fast = fast.Next.Next
        if slow == fast {
            for slow != head {
                slow = slow.Next
                head = head.Next
            }
            return head
        }
    }
    return nil
}

希望对您的算法学习能有所帮助，您的支持是我前进的最大动力，感谢您的关注和认可！！！
在这里插入图片描述

万物皆可der
关注
专栏目录
熬夜整理，五万字长文总结 C/C++ 知识点
编程与实战的博客
07-19 2016
这是一篇五万字的C/C++知识点总结，长文预警。能滑到留言区的，都是麒麟臂！学C/C++的同学，收藏起来哦~C/C++ 知识总结目录C/C++STL数据结构算法Problems操作系统计算...
【大总结2】大学两年，写了这篇几十万字的干货总结_万字 cndn
2401_84617533的博客
04-27 852
这部分在我看来是最有意思的，我们有必要了解底层数据结构的实现，这也是我最感兴趣的。比如，你知道redis中的字符串怎么实现的吗？为什么这么实现？你知道redis压缩列表是什么算法吗？你知道redis为什么抛弃了红黑树反而采用了跳表这种新的数据结构吗？你知道hyperloglog为什么用如此小的空间就可以有这么好的统计性能和准确性吗？你知道布隆过滤器为什么这么有效吗？有没有数学证明过？你是否还能很快写出来快排？或者不断优化性能的排序？是不是只会调库了甚至库函数怎么实现的都不知道？真的就是快排？
日常随笔-4-万字面经教你如何拿大厂offer(非科班)
houwanfeimark的专栏
12-30 1017
工作经历 最近换工作，先说结果吧，拿到最高的是的年薪40+，权衡之后选择了腾讯offer，其中也有要23k觉得要多了的，主要是上一家base太低了，有时候自己都不敢要太高，现在想通了，我来面试，通过了凭什么要拿上一家的base来压我，说出来不怕笑话在上一家年薪21+，哎，一言难尽。 回想起从毕业到现在也4年了，当初毕业的时候不是Java开发也不是计科出身，也没参加过培训班(我个人非常反感培训班)，只因偶然的实习走上Java开发这一条路。大学没有好好学习，参加工作以来，也是走过一些艰辛的道路，回想大学刚毕业那
万字长文一网打尽链表翻转相关技巧（挑战字节hard面试题）
清风微浪又何妨的博客
12-05 427
链表高频热门翻转题型+个人心法，适合有基础者配合LeetCode平台刷题时阅读。翻过这道槛，链表专题可以基本告一段落。
重磅干货 | 五万字长文总结 C/C++ 知识（上）
青春不老，奋斗不止！
06-09 2610
链接 | https://github.com/huihut/interviewC/C++ 知识总结这是一篇五万字的C/C++知识点总结，包括答案：这是上篇，下篇今天也推送了，需要的同学记...
五万字长文总结 C/C++ 知识
hhltaishuai的博客
07-13 713
来自：GitHub - huihut 链接：https://github.com/huihut/interview#cc C/C++ 知识总结 这是一篇五万字的C/C++知识点总结，包括答案，需要的同学记得去看看。 目录 C/C++ STL 数据结构 算法 Problems 操作系统 计算机网络 网络编程 数据库 设计模式 链接装载库 海量数据处理 音视频 其他 C/C++ const 作用 修饰变量，说明该变量不可以被改变； 修饰指针，分为指向常量的指针和指针常量； 常量引用，经常用于形参类型，即
重磅干货 ：五万字长文总结 C/C++ 知识（上）
weixin_45727359的博客
07-20 499
这是一篇五万字的C/C++知识点总结，包括答案：这是上篇。目录C/C++STL数据结构算法Problems操作系统计算机网络网络编程数据库设计模式链接装载库海量数据处理音视频其他C/C++...
超硬核十万字！全网最全 数据结构 代码，随便秒杀老师/面试官，我说的
热门推荐
少说，多做。
04-20 11万+
本文代码实现基本按照《数据结构》课本目录顺序，外加大量的复杂算法实现，一篇文章足够。能换你一个收藏了吧？
五万字长文:C/C++ 面试知识总结（中）
我的博客
04-20 3924
本文是：五万字长文:C/C++ 面试知识总结（上）的续篇 C++ 11 shared_ptr unique_ptr weak_ptr auto_ptr（被 C++11 弃用） Class shared_ptr 实现共享式拥有（shared ownership）概念。多个智能指针指向相同对象，该对象和其相关资源会在 “最后一个 reference 被销毁” 时被释放。为了在结...
【算法之LeetCode系列（8）】——双指针
summer爱前端
11-03 568
双指针真的很香，所以我又又又淦了 一万字 题解，快来看看吧
算法笔记知识点整理大全
weixin_46148956的博客
07-27 1887
第二章 C/C++快速入门 2.1 基本数据类型及输入输出 2.1.2 变量类型及输入输出 类型 取值范围 占用字节 格式符 int 10的9次方以内整数 4字节（32位） %d long long 10的10次方~10的18次方 8字节（64位） %lld float 6~7位有效精度 32字节 %f double 15~16位有效精度 64字节 %lf char -128~127 -128~127 %c(字符串%s不加&) bool 0/1 0/1 2.
immutablejs 是如何优化我们的代码的？
azl397985856的专栏
07-14 2538
点击蓝色“脑洞前端”关注我哟加个“星标”，带你揭开大前端的神秘面纱！❝这是脑洞前端第「98」篇原创文章❞前一段时间群里有小伙伴问 lucifer 我一个问题：”immutablejs 是...
2020年前端面试复习必读文章【超百篇文章赠复习导图】，移动开发工程师的发展路线
m0_64319112的博客
11-29 393
重新认识构造函数、原型和原型链 JavaScript深入之从原型到原型链 最详尽的 JS 原型与原型链终极详解，没有「可能是」。（一） 最详尽的 JS 原型与原型链终极详解，没有「可能是」。（二） 最详尽的 JS 原型与原型链终极详解，没有「可能是」。（三） JavaScript 引擎基础：原型优化 Prototypes in JavaScript JavaScript深入之创建对象的多种方式以及优缺点 详解JS原型链与继承 从__proto__和prototype来深入理解JS对象和原型链 代码复用模式.
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 214
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
leetcode209:长度最小的子数组
D2510466299的博客
10-12 566
我们需要从一个包含。
leetcode链表（四）-删除链表的倒数第N个节点
weixin_40198632的博客
10-11 377
给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。
【C++刷题】力扣-#118-杨辉三角
会写代码的饭桶
10-16 80
给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。在杨辉三角中，每个数是它正上方两个数的和。
【从零开始的LeetCode-算法】3099. 哈沙德数
qq_40878316的博客
10-15 148
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
【算法题】279. 完全平方数-力扣(LeetCode)
Janium的博客
10-10 639
1. **空间优化**：由于动态规划的状态转移方程只依赖于前一行的数据，可以将二维数组优化为一维数组。 2. **减少不必要的计算**：在构建完全平方数列表时，可以直接使用一个列表来存储这些数，而不需要每次计算平方。
LeetCode链表专题：高效反转策略与递归解法
"LeetCode算法数据结构专训笔记，涵盖了链表、栈、递归等常见数据结构和算法，旨在提升编程能力与解决问题的技巧。笔记详细解释了如何使用不同方法，如头插法和栈，来解决链表反转问题，并通过递归深入理解反转逻辑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

万物皆可der

感谢支持

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值