链表

特点：用一组任意的存储单元存储线性表的数据元素，这组存储单元可以存在内存中未被占用的任意位置。 存取数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称为指针或链。这两部分信息组成数据元素称为存储映像，称为结点。 单链表 因为每个结点中只包含一个指针域，所以称为单链表。 我们把链表中第一个结点的存储位置叫做头指针，最后一个结点指针为空(NULL)。 头指针： - 头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针。 - 头指针具有标识作用，所以常用头指针冠以链表的名字，(指针变量的名字)。 - 无论链表是否为空，头指针均不为空。 - 头指针是链表的必要元素。 头结点： - 头结点是为了操作的统一和方便而设立的，放在第一个元素的结点之前，其数据域一般无意义(但也可以用来存放链表的长度) - 有了头结点，对于在第一元素结点前插入结点和删除第一结点起操作与其他结点的操作就统一了。 - 头结点不是链表的必要元素。 PS：我们所看到的结点是由存放数据元素的数据域和存放后继结点地址的指针域组成。 来源： https://www.cnblogs.com/strator/p/7219915.html

237. 删除链表中的节点 请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。 现有一个链表 -- head = [4,5,1,9]，它可以表示为: 示例 1: 输入: head = [4,5,1,9], node = 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9. 示例 2: 输入: head = [4,5,1,9], node = 1 输出: [4,5,9] 解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9. 说明: 链表至少包含两个节点。 链表中所有节点的值都是唯一的。 给定的节点为非末尾节点并且一定是链表中的一个有效节点。 不要从你的函数中返回任何结果。 解法一 //时间复杂度O(1), 空间复杂度O(1) /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: void deleteNode(ListNode*

单链表： 概念： 1、由于线性表的顺序存储在插入与删除时需要移动大量元素，适用于不经常改变元素的情况，那么当我们需要经常操作元素时该怎么办，这就有了接下来的线性表的链式存储结构 2、单链表在内存的存储位置不一定是一段连续的位置，它可以存放在内存中任何地方 3、单链表中除了用于存放数据的数据域外，还有存放指针的指针域，指针域的作用是指向链表的下一个节点（因为链表的元素在内存中的存放时任意位置的，所以需要指向下一个节点） 4、单链表第一个节点存储的位置叫做头指针，整个单链表的存取都是从头指针开始，单链表的最后一个节点是指针指向空（NULL） 单链表的操作： 1 package com.alibaba.test03; 2 3 import org.junit.jupiter.api.Test; 4 5 6 /** 7 * 1. 单链表的具体实现及操作 8 * @author wydream 9 * 10 */ 11 12 public class SingLeLinkedList { 13 14 private int size;//链表节点的个数 15 private Node head;//头结点 16 17 public SingLeLinkedList() { 18 size=0; 19 head=null; 20 } 21 22 //链表中的每个节点类 23 private

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。 说明: 1 ≤ m ≤ n ≤ 链表长度。 示例: 输入: 1->2->3->4->5->NULL, m = 2, n = 4 输出: 1->4->3->2->5->NULL 1 #include "_000库函数.h" 2 3 4 struct ListNode { 5 int val; 6 ListNode *next; 7 ListNode(int x) : val(x), next(NULL) {} 8 }; 9 10 11 //只能扫描一遍 12 //将中间要反转的数取出来在放入链表中 13 class Solution { 14 public: 15 ListNode* reverseBetween(ListNode* head, int m, int n) { 16 if (!head || m <= 0 || n <= 0 || n <= m)return head; 17 //加头 18 ListNode*p = new ListNode(-1); 19 p->next = head; 20 head = p; 21 22 stack<int>s; 23 ListNode*pre = new ListNode(0); 24 while (p && n >0) { 25 --m; 26 if (m == 0

方法一： /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { if(l1 == NULL) return l2; if(l2 == NULL) return l1; ListNode* head; ListNode* end; head=(ListNode*)malloc(sizeof(ListNode)); head->next=NULL; end=head; while(l1&&l2) { if(l1->val<=l2->val) { end->next=l1; end=end->next; l1=l1->next; } else { end->next=l2; end=end->next; l2=l2->next; } } if(l1) { end->next=l1; } if(l2) { end->next=l2; } return head->next; } }; 方法二： ////

题目 代码 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode* rotateRight(ListNode* head, int k) { if(head==nullptr) return nullptr; auto ptr = head; int length = 0; while (ptr != nullptr) { ptr = ptr->next; length++; } k=k%length; if(k==0) return head; //54321 2 auto newHead = ReverseList(head, length); if(k==length) return newHead; //45321 2 newHead = ReverseList(newHead, k); //45123 2 int num = k; auto nextHead = newHead; while (num > 0) { nextHead = nextHead->next; num--;

3. 无重复字符的最长子串 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。 示例 1: 输入: "abcabcbb" 输出: 3 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。 示例 2: 输入: "bbbbb" 输出: 1 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。 示例 3: 输入: "pwwkew" 输出: 3 解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。 请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/longest-substring-without-repeating-characters 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 class Solution: def lengthOfLongestSubstring(self, s: str): st = {} i, ans = 0, 0 for j in range(len(s)): if s[j] in st: i = max(st[s[j],i]) ans = max(ans, j-i+1) st[s[j]] = j + 1 return ans 141. 环形链表

题目 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道题？ 分析 1.迭代反转 对于一个没有头节点的链表进行反转：起码需要只要反转哪个节点（pcur)以及反转后指向哪个节点(pre)。迭代过程需要更新，反转当前节点之后，需要反转的下一个节点是哪个（pnext)。首先初始化，反转之后的最后一个节点就是原链表的第一个节点，所以第一个节点反转之后指向NULL。所以初始化 p r e = N U L L pre=NULL p r e = N U L L , p c u r = H e a d pcur=Head p c u r = H e a d .反转完第一个节点之后，需要反转第二个节点，所以更新 p c u r pcur p c u r 为 p n e x t pnext p n e x t ， p r e pre p r e 也就是之前的 p c u r pcur p c u r (第一个节点）. ListNode * reverseList ( ListNode * head ) { if ( head == NULL ) return NULL ; if ( head - > next == NULL ) return head ;

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 示例 : 给定这个链表：1->2->3->4->5 当 k = 2 时，应当返回: 2->1->4->3->5 当 k = 3 时，应当返回: 3->2->1->4->5 说明 : 你的算法只能使用常数的额外空间。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 /* * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ //反转区间[a,b)的元素 ListNode * reverse ( ListNode * a , ListNode * b ) { ListNode * pre , * cur , * nxt ; pre = NULL ; cur

#include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define SWAP(x,y) {t=x,x=y,y=t;} typedef int ElemType; typedef int Status; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; Status Create_LinkList_Head(LinkList &L,int n)//头插法 { LinkList s; L=(LinkList)malloc(sizeof(LNode)); L->next=NULL; for(int i=0 ; i<n ; i++) { if(!(s=(LinkList)malloc(sizeof(LNode)))) { printf("内存分配失败！"); exit(OVERFLOW); } scanf("%d",&s->data); s->next=L-