链表

LinkList.h #pragma once #include <iostream> using namespace std; class LNode { friend class LinkList; int data; LNode* next; }; class LinkList { private: LNode* first; public: LinkList() { first = new LNode(); first->data = 666; first->next = nullptr; } void show() { LNode* p; p = first->next; int i = 0; while (p!= nullptr) { cout << i << ":"; cout << p->data << " "; i++; p = p->next; } putchar('\n'); } void insert(int index, int e) { LNode* p = new LNode(); LNode* q = first; p->data = e; for (int i = 0; i < index; i++) { q = q->next; } p->next = q->next; q->next = p; } void remove(int index)

问题描述 给定一个链表，判断链表中是否有环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 示例 ： 输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。 双指针法 快慢指针，快指针每走两步慢指针走一步，二者相遇的话说明有环 代码 class Solution : def hasCycle ( self , head : ListNode ) - > bool : fast = head slow = head while fast and slow and fast . next : fast = fast . next . next slow = slow . next if slow == fast : return True return False 运行结果 O(1)空间复杂度居然只击败了7%的提交 看了讨论区的大佬们的破坏链表元素和"bjfuvth"做法之后。。。无语.jpg 来源： CSDN 作者： Formaterror 链接： https://blog.csdn.net/fromatlove/article/details/104759276

题目描述 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。例如，链表1->2->3->3->4->4->5处理后为1->2->5。 struct ListNode { int val ; struct ListNode * next ; ListNode ( int x ) : val ( x ) , next ( NULL ) { } } ; 看题目的第一眼以为很容易，做过很多删除链表结点的题目了感觉很熟悉，但是上手后发现并不容易，一般的删除重复结点的题目是要求重复的结点只保留一个，而本题要求 链表中重复的节点都不保留 。 思路 设置指针pre指向访问过的最后一个不重复的结点，设置工作指针p指向当前处理的结点，设置q指针检测当前结点后的重复结点。 题解 class Solution { public : ListNode * deleteDuplication ( ListNode * pHead ) { if ( pHead == NULL ) { return pHead ; } ListNode * pre = NULL ; //指向访问过的最后一个不重复的结点 ListNode * p = pHead ; //指向当前结点 ListNode * q = NULL ; //指向当前结点后的结点，用于判断后面的结点是否重复

11. 输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。 解：如果一个整数不为0，那么这个整数至少有一位是1。如果我们把这个整数减1，那么原来处在整数最右边的1就会变为0，原来在1后面的所有的0都会变成1(如果最右边的1后面还有0的话)。其余所有位将不会受到影响。 举个例子：一个二进制数1100，从右边数起第三位是处于最右边的一个1。减去1后，第三位变成0，它后面的两位0变成了1，而前面的1保持不变，因此得到的结果是1011.我们发现减1的结果是把最右边的一个1开始的所有位都取反了。这个时候如果我们再把原来的整数和减去1之后的结果做与运算，从原来整数最右边一个1那一位开始所有位都会变成0。如1100&1011=1000.也就是说，把一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0.那么一个整数的二进制有多少个1，就可以进行多少次这样的操作。 链接：https://www.nowcoder.com/questionTerminal/8ee967e43c2c4ec193b040ea7fbb10b8?f=discussion 来源：牛客网 public class Solution { public int NumberOf1 ( int n ) { int count = 0 ; while ( n != 0 ) { count ++ ; n = n &

环形链表 描述 给定一个链表，判断链表中是否有环。 思路和代码 思路1:用一个哈希表,将每一个遍历到的节点加入哈希表中,如果遍历到节点已经出现在了哈希表中则证明有环. 思路2:一个指针走一步,一个指针走两步,若有环,则两个指针必会相遇. /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public : bool hasCycle ( ListNode * head ) { ListNode * fast = head ; ListNode * slow = head ; while ( fast && fast - > next ) { slow = slow - > next ; fast = fast - > next - > next ; if ( fast == slow ) return true ; } return false ; } } ; 环形链表2 描述 在有环的基础上,返回入环的第一个节点 快指针和慢指针,快指针走两步,慢指针走一步,若相遇则有环 相遇之后,快指针返回head,慢指针在相遇这一点

题目链接 点击打开链接 题目描述 题解 是否是循环链表 使用 快慢指针法 ，慢指针一次走1个结点，快指针一次走2个结点，从头开始走会出现下面两种情况： 快指针变成 NULL ，说明链表不循环。 快慢指针相遇，说明链表循环，但循环节的起始位置未知。 注意这里快指针走的路程是慢指针走的路程的2倍。 找出循环节的起始位置 上一步相遇的位置是个关键，在这一结点上， 快指针走的路程 = 慢指针走的路程 * 2。 我们让一个指针从这个结点出发，另一个结点从开头出发，步长均为1，这两个指针 一定还会在这个位置相遇 。 那么它们在相遇前就会齐头并进一会，所以这两个指针在相遇的时候就是循环节的开始。 代码 /* * @lc app=leetcode.cn id=142 lang=cpp * * [142] 环形链表 II * * 思路：快慢指针法，快指针一次走2步，慢指针一次走1步。 * 如果快指针遇见NULL，表示无循环，否则总会相遇，这个时候，快指针的路是慢指针的2倍。 * 然后一个指针从慢指针开始，一个指针从开头开始，步长均为1， * 因为上一步相遇的位置快指针的路是慢指针的2倍，所以这么走下去两个指针一定会在同样的位置相遇。 * 既然会在同一位置相遇，且步长都为1，所以两者在进入循环结点的时候就一定相遇了。 * 这样就可以找到循环结点的位置啦。 * */ // @lc code=start

顺序表结构(技术)是组织一组元素的最重要方式，它可以直接地实现线性表也是许多其他数据结构的实现基础采用顺序表结构实现线性表，重要问题是加入1删除等操作的效率这类操作改变表中元素序列的结构，是典型的变动操作由于元素在存储区里连续排列。加入/删除操作需要移动(可能很多的)元素，操作代价高。表结构不够灵活，不容易调整和变化。如果一个表在使用中经常需要修改结构，用顺序表实现就不很方便，操作代价可能很高，根源在于元素存储的集中方式和连续性如果程序里需要巨大的线性表，采用顺序表实现。就需要很大块的连续存储空间，这也可能造成存储管理方面的困难。 链接表实现的基本需要: 能够找到表中的首元素(无论直接或间接，通常很容易做到)。 从表里的任一个元素出发，可以找到它之后的下一个元素，显然，把表元素保存在连续的存储区里，自然满足这两个需求，顺序关联是隐含的。但满足这两种需求，并不一定要连续存储元素。实现线性表的另一方式是基于链接结构，用链接显式地表示元素之间的顺序关联。基于链接技术实现的线性表称为链接表或链表实现链接表的基本想法:把表元素分别存储在一批独立的存储块(称为结点)里。保证从一个元素的结点可找到与其相关的下一个元素的结点。在结点里用链接的方式显式记录元素(结点)之间的关联，这样只要知道表中第一个结点， 就能顺序找到表里其他元素。 来源： CSDN 作者： 想飞的蓝笨笨 链接： https:/

利用map的特性，将第一次遇到的值装入map中，同时更新链表 若是键值的值大于0，则跳过当前节点， 最后记得要在遍历完链表后将新链表的末尾置为NULL， 即list->next=NULL 链表的题目都值得注意的就是地址不要弄串了，每次都应该多申请一个地址来记录原本的头节点，最后直接返回pre->next /** Definition for singly-linked list. struct ListNode { int val;shen ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; / class Solution { public: ListNode removeDuplicateNodes(ListNode* head) { map<int,int>cc; ListNode* pre=new ListNode(NULL); ListNode* list=pre; while(head!=NULL) { if(cc[head->val]==0) { cc[head->val]++; list->next=head; list=list->next; head=head->next; } else { head=head->next; } } list->next=NULL; return pre-

题目描述: Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x. You should preserve the original relative order of the nodes in each of the two partitions. For example, Given 1->4->3->2->5->2 and x = 3, return 1->2->2->4->3->5. /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ 代码： class Solution { public: ListNode *partition(ListNode *head, int x) { if(head == nullptr) return head; ListNode dummy1 = ListNode(-1); ListNode dummy2 =

环形链表 给定一个链表，判断链表中是否有环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 /** * Definition for singly-linked list. * class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } */ public class Solution { public boolean hasCycle ( ListNode head ) { while ( head != null ) { if ( head == head . next ) { return true ; } if ( head . next != null ) { head . next = head . next . next ; } head = head . next ; } return false ; } } 执行结果：通过 执行用时 :0 ms, 在所有 Java 提交中击败了100.00%的用户 内存消耗 :41.3 MB, 在所有 Java 提交中击败了5.02%的用户 思路：当 head.next 不为空时，将head