初级算法-链表

最新推荐文章于 2024-06-11 20:33:14 发布
最新推荐文章于 2024-06-11 20:33:14 发布
阅读量270 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxq997997/article/details/129407739
版权

主要记录算法和数据结构学习笔记，新的一年更上一层楼！

初级算法-链表


链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。

  • 链表适用于顺序查找
  • 二分查找：表必须有序，按关键字，大小有序排列
  • 顺序查找在顺序线性表还是链式中时间复杂度都为O(n)
  • 递归表＞再入表＞纯表＞线性表
  • 字典可采用线性表、散列表、跳表组织方式
  • 线性表存在唯一的被称为“第一个”的数据元素，除第一个元素外，集合中的每个数据元素均只有一个直接前驱
    在这里插入图片描述
    单链表
    在这里插入图片描述
    双链表
    在这里插入图片描述
    循环链表 解决约瑟夫环
    在这里插入图片描述
    在这里插入图片描述

一、移除链表元素

1.题目：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
示例1：
在这里插入图片描述

输入：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
输出：[]

提示：
1.列表中的节点数目在范围 [0, 104] 内。
2.1 <= Node.val <= 50。
3.0 <= val <= 50。

2.解题思路：

/**
 * @param {ListNode} head
 * @param {number} val
 * @return {ListNode}
 */
var removeElements = function(head, val) {
//初始化一个空节点，初始赋值为0，并且ret的下一个next指针指向head，指针指向为ret
    const ret = new ListNode(0, head);
    let cur = ret;
    while(cur.next) {
        if(cur.next.val === val) {
            cur.next =  cur.next.next;
            continue;
        }
        cur = cur.next;
    }
    return ret.next;
};
// 运行时间：80ms
// 内存消耗：45.6MB

二、设计链表

1.题目：在链表类中实现这些功能：

  • get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
  • addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
  • addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
  • addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
  • deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

示例1
在这里插入图片描述
2.解题思路：

class LinkNode {
    constructor(val, next) {
        this.val = val;
        this.next = next;
    }
}

/**
 * Initialize your data structure here.
 * 单链表 储存头尾节点 和 节点数量
 */
var MyLinkedList = function() {
    this._size = 0;
    this._tail = null;
    this._head = null;
};

/**
 * Get the value of the index-th node in the linked list. If the index is invalid, return -1. 
 * @param {number} index
 * @return {number}
 */
MyLinkedList.prototype.getNode = function(index) {
    if(index < 0 || index >= this._size) return null;
    // 创建虚拟头节点
    let cur = new LinkNode(0, this._head);
    // 0 -> head
    while(index-- >= 0) {
        cur = cur.next;
    }
    return cur;
};
MyLinkedList.prototype.get = function(index) {
    if(index < 0 || index >= this._size) return -1;
    // 获取当前节点
    return this.getNode(index).val;
};

/**
 * Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. 
 * @param {number} val
 * @return {void}
 */
MyLinkedList.prototype.addAtHead = function(val) {
    const node = new LinkNode(val, this._head);
    this._head = node;
    this._size++;
    if(!this._tail) {
        this._tail = node;
    }
};

/**
 * Append a node of value val to the last element of the linked list. 
 * @param {number} val
 * @return {void}
 */
MyLinkedList.prototype.addAtTail = function(val) {
    const node = new LinkNode(val, null);
    this._size++;
    if(this._tail) {
        this._tail.next = node;
        this._tail = node;
        return;
    }
    this._tail = node;
    this._head = node;
};

/**
 * Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. 
 * @param {number} index 
 * @param {number} val
 * @return {void}
 */
MyLinkedList.prototype.addAtIndex = function(index, val) {
    if(index > this._size) return;
    if(index <= 0) {
        this.addAtHead(val);
        return;
    }
    if(index === this._size) {
        this.addAtTail(val);
        return;
    }
    // 获取目标节点的上一个的节点
    const node = this.getNode(index - 1);
    node.next = new LinkNode(val, node.next);
    this._size++;
};

/**
 * Delete the index-th node in the linked list, if the index is valid. 
 * @param {number} index
 * @return {void}
 */
MyLinkedList.prototype.deleteAtIndex = function(index) {
    if(index < 0 || index >= this._size) return;
    if(index === 0) {
        this._head = this._head.next;
        // 如果删除的这个节点同时是尾节点，要处理尾节点
        if(index === this._size - 1){
            this._tail = this._head
        }
        this._size--;
        return;
    }
    // 获取目标节点的上一个的节点
    const node = this.getNode(index - 1);    
    node.next = node.next.next;
    // 处理尾节点
    if(index === this._size - 1) {
        this._tail = node;
    }
    this._size--;
};

// MyLinkedList.prototype.out = function() {
//     let cur = this._head;
//     const res = [];
//     while(cur) {
//         res.push(cur.val);
//         cur = cur.next;
//     }
// };
/**
 * Your MyLinkedList object will be instantiated and called as such:
 * var obj = new MyLinkedList()
 * var param_1 = obj.get(index)
 * obj.addAtHead(val)
 * obj.addAtTail(val)
 * obj.addAtIndex(index,val)
 * obj.deleteAtIndex(index)
 */
// 运行时间：120ms
// 内存消耗：49.3MB

三、反转链表

1.题目：反转一个单链表。

示例1

输入: 1->2->3->4->5->NULL 
输出: 5->4->3->2->1->NULL

2.解题思路：
（1）双指针

/**
 * @param {ListNode} head
 * @return {ListNode}
 */

// 双指针：
var reverseList = function(head) {
    if(!head || !head.next) return head;
    let temp = null, pre = null, cur = head;
    while(cur) {
        temp = cur.next;
        cur.next = pre;
        pre = cur;
        cur = temp;
    }
    // temp = cur = null;
    return pre;
};
// 运行时间：64ms
// 内存消耗：42.8MB

（2）递归1

// 递归：
var reverse = function(pre, head) {
    if(!head) return pre;
    const temp = head.next;
    head.next = pre;
    pre = head
    return reverse(pre, temp);
}

var reverseList = function(head) {
    return reverse(null, head);
};
// 运行时间：72ms
// 内存消耗：43.3MB

（2）递归2

// 递归2
var reverse = function(head) {
    if(!head || !head.next) return head;
    // 从后往前翻
    const pre = reverse(head.next);
    head.next = pre.next;
    pre.next = head;
    return head;
}

var reverseList = function(head) {
    let cur = head;
    while(cur && cur.next) {
        cur = cur.next;
    }
    reverse(head);
    return cur;
};
// 运行时间：68ms
// 内存消耗：43.3MB

四、两两交换链表的结点

1.题目：
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例1

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

2.解题思路：

var swapPairs = function (head) {
  let ret = new ListNode(0, head), temp = ret;
  while (temp.next && temp.next.next) {
    let cur = temp.next.next, pre = temp.next;
    pre.next = cur.next;
    cur.next = pre;
    temp.next = cur;
    temp = pre;
  }
  return ret.next;
};
// 运行时间：64ms
// 内存消耗：41.3MB

五、删除链表的倒数第N个节点

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

进阶：你能尝试使用一趟扫描实现吗？
示例1

输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5] 示例 2：

输入：head = [1], n = 1 输出：[] 示例 3：

输入：head = [1,2], n = 1 输出：[1]

2.解题思路：

/**
 * @param {ListNode} head
 * @param {number} n
 * @return {ListNode}
 */
var removeNthFromEnd = function(head, n) {
    let ret = new ListNode(0, head),
        slow = fast = ret;
    while(n--) fast = fast.next;
    while (fast.next !== null) {
        fast = fast.next; 
        slow = slow.next
    };
    slow.next = slow.next.next;
    return ret.next;
};
// 运行时间：68ms
// 内存消耗：41.5MB

六、链表相交

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

示例 1：
在这里插入图片描述
2.解题思路：

var getListLen = function(head) {
    let len = 0, cur = head;
    while(cur) {
       len++;
       cur = cur.next;
    }
    return len;
}
var getIntersectionNode = function(headA, headB) {
    let curA = headA,curB = headB,
        lenA = getListLen(headA),   // 求链表A的长度
        lenB = getListLen(headB);  
    if(lenA < lenB) {       // 让curA为最长链表的头，lenA为其长度
    
        // 交换变量注意加 “分号” ，两个数组交换变量在同一个作用域下时
        // 如果不加分号，下面两条代码等同于一条代码: [curA, curB] = [lenB, lenA]
        
        [curA, curB] = [curB, curA];
        [lenA, lenB] = [lenB, lenA];
    }
    let i = lenA - lenB;   // 求长度差
    while(i-- > 0) {       // 让curA和curB在同一起点上（末尾位置对齐）
        curA = curA.next;
    }
    while(curA && curA !== curB) {  // 遍历curA 和 curB，遇到相同则直接返回
        curA = curA.next;
        curB = curB.next;
    }
    return curA;
};
#运行时间：96ms
#内存消耗：48.8MB

七、环形链表2

1.题目：给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。
在这里插入图片描述

// 两种循环实现方式
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
// 先判断是否是环形链表
var detectCycle = function(head) {
    if(!head || !head.next) return null;
    let slow =head.next, fast = head.next.next;
    while(fast && fast.next && fast!== slow) {
        slow = slow.next;
        fast = fast.next.next; 
    }
    if(!fast || !fast.next ) return null;
    slow = head;
    while (fast !== slow) {
        slow = slow.next;
        fast = fast.next;
    }
    return slow;
};
#运行时间：92ms
#内存消耗：43.9MB

// 两种循环实现方式
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var detectCycle = function(head) {
    if(!head || !head.next) return null;
    let slow =head.next, fast = head.next.next;
    while(fast && fast.next) {
        slow = slow.next;
        fast = fast.next.next;
        if(fast == slow) {
            slow = head;
            while (fast !== slow) {
                slow = slow.next;
                fast = fast.next;
            }
            return slow;
        }
    }
    return null;
};
#运行时间：96ms
#内存消耗：44.2MB

1 2

  1. 数组思路-双指针 ↩︎

  2. 数组思路-逆序 ↩︎

997and
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构第五章：数组和广义表
欢迎来到关关雎鸠儿的博客
08-30 5535
之前的线性结构的数据构成特点： 线性表的数据构成：原子类型数据对象 栈和队列的数据构成：原子类型的数据对象 串的数据构成：字符 实际上，线性结构可以包含更广泛的数据类型： 可以是原子类型的数据对象； 可以是结构类型的数据对象； 可以是混合类型的数据—广义表 1 数组的类型定义 1．一维数组 一维数组可看成是一个线性表或一个向量，存储在一块连续的存储单元中，适合于随机查找。一维数组记为A[n...
知识点梳理：数据结构与算法——高级数据结构
weixin_44548848的博客
01-04 424
知识点梳理：数据结构与算法——高级数据结构
广义表
Oligizzz
02-28 374
广义嘛，有点类似类比的意思，那么广义表就是线性表的推广，也称列表。 逻辑结构为 GL = (a1,a2,…ai,…an) 广义表具有以下的特性： 广义表中的数据元素是相对有次序的； 广义表的长度要取层次的最外层； 广义表的深度为包含括号的层数，比如原子是孤儿所以他就没有深度，空表连原子都没有偏偏就占一个深度； 广义i傲视可以被共享的，可以被共享的广义表被称为再入表（目前没发现有啥卵用）； 广...
线性表∈纯表(树)∈再入表∈递归表 。可见，广义表是对线性表和树的推广。
bg2bkk的专栏
09-09 4397
如果一个广义表的结点又可以被其他结点所共享，则这个表称为再入表  线性表∈纯表(树)∈再入表∈递归表 。可见，广义表是对线性表和树的推广。
广义表的概念
weixin_30267785的博客
03-28 310
广义表的概念 　广义表(Lists，又称列表)是线性表的推广。即广义表中放松对表元素的原子限制，容许它们具有其自身结构。1、广义表定义 　广义表是n(n≥0)个元素a1，a2，…，ai，…，an的有限序列。 其中： 　①ai--或者是原子或者是一个广义表。　 　②广义表通常记作： Ls=( a1，a2，…，ai，…，an)。　　 ...
Python《剑指offer》算法实现-链表中倒数第k个结点
12-25
1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,多和面试官沟通,然后开始做一些整体的设计和规划。不要急于提交,自己测试几个用例避免错误...
Python《剑指offer》算法实现-反转链表
12-25
1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,多和面试官沟通,然后开始做一些整体的设计和规划。不要急于提交,自己测试几个用例避免错误...
Python《剑指offer》算法实现-复杂链表的复制
12-25
1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,多和面试官沟通,然后开始做一些整体的设计和规划。不要急于提交,自己测试几个用例避免错误...
Python《剑指offer》算法实现-删除链表中重复的结点
12-25
1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,多和面试官沟通,然后开始做一些整体的设计和规划。不要急于提交,自己测试几个用例避免错误...
Python《剑指offer》算法实现-反向打印链表
12-25
1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,多和面试官沟通,然后开始做一些整体的设计和规划。不要急于提交,自己测试几个用例避免错误...
【数据结构学习笔记】广义表和数组
ZERO-JAN的博客
11-27 609
【自用笔记】数据结构-广义表和数组
递归与线性表
qq_40282585的博客
05-14 682
（学习记录） 今天我们来唠一唠，关于线性表和递归的一些想法 .一.我们先来谈一谈什么是递归1.递归，我们都不陌生。非常经典的递归模型就是关于汉诺塔问题，在盘子数量很少时、我们可以总结出来一些归律，发现这些盘子的移动都有共同点、总是先将n-1个盘子借助于辅助塔先从第n个盘子上挪开、然后将第n个放置指定位置、然后重复这个过程(递归调用自己)、求解。特点：1.把一个很大规模的问题转化为多个与原问题相似的...
顺序表应用1：多余元素删除之移位算法
颤抖的羽翼
09-19 3427
顺序表应用1：多余元素删除之移位算法 Time Limit: 1000ms   Memory limit: 2000K  有疑问？点这里^_^ 题目描述 一个长度不超过100数据的顺序表，可能存在着一些值相同的“多余”数据元素（类型为整型），编写一个程序将“多余”的数据元素从顺序表中删除，使该表由一个“非纯表”（值相同的元素在表中可能有多个）变成一个“纯表
广义表的基本操作
热门推荐
渴望飞翔的猪
11-15 1万+
这几天学《数据结构》，被其中的广义表难住了，经过这两天
图像检索
Major_S的博客
02-25 313
顺序表和链表的比较
递归与线性表的总结
qq_40282585的博客
05-16 399
一.我们先看看在什么时候通常适合递归,1.有许多数学公式、数列等等的定义是递归,比如阶乘、斐波那契数列都是可以将其递归定义转化为对应的递归算法.比如求n！递归算法如下：...
【代码随想录】【算法训练营】【第35天】[134]加油站 [135]分发糖果 [860]柠檬水找零 [406]根据身高重建队列
最新发布
weixin_54954007的博客
06-11 299
思路及算法思维，指路。题目来自。day 35，连休两天~
指针和数组
2301_77634163的博客
06-10 431
有3个指针，中间是一个数组arr，有个指针指向中间,其他两个指向两边，一个指向前面，一个人指向后面。虽然简化好，但是我们C语言要求是不允许这样写的,虽然大部分编译器是可以允许我这样写的。下面那个用数组名也是可以用的，因为他也表示一个地址，加1就会找后面那个元素的地址。我们C语言编译器中说指针允许往后比较大小，但不允许往前比面的指针比较大小。地址向后移，指针相比较，指针减减就是减去一个整数。同一指针相减的绝对值得到的是之间元素的个数。数组和指针的地址是一样的，说明是可以的。地址加地址，指针加指针没有意义。
Java初级数据结构与算法
07-29
Java初级数据结构与算法是指在Java编程语言中使用的基本数据结构和算法。在Java中，我们可以使用各种数据结构来存储和操作数据。常见的数据结构包括数组、链表、栈、队列和树等。这些数据结构可以用来解决各种实际问题，如搜索、排序、查找和插入等。 在Java中，我们可以使用ArrayList类来实现动态数组，LinkedList类来实现链表，Stack类来实现栈，Queue接口来实现队列，以及TreeSet和HashMap等类来实现树和哈希表等数据结构。这些数据结构提供了各种方法来操作和管理数据，如添加元素、删除元素、查找元素和遍历元素等。 此外，算法是解决问题的步骤和方法。在Java中，我们可以使用各种算法来处理数据结构中的数据。常见的算法包括线性搜索、二分搜索、冒泡排序、快速排序和图遍历等。这些算法可以帮助我们高效地处理和操作数据。 总结来说，Java初级数据结构与算法是指在Java编程语言中使用的基本数据结构和算法，包括数组、链表、栈、队列、树和哈希表等数据结构，以及搜索、排序、查找和遍历等算法。通过学习和掌握这些数据结构和算法，我们可以更好地解决实际问题并提高程序的效率。\[1\]\[2\]\[3\] #### 引用[.reference_title] - *1* [【Java】数据结构与算法入门](https://blog.csdn.net/LongLiveThePRC/article/details/124573277)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [1.0 JAVA数据结构与算法](https://blog.csdn.net/xiexieya233/article/details/124082025)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [java基础语法：数据结构和算法](https://blog.csdn.net/qq_50395011/article/details/109739043)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值