链表

目录 前言 为什么需要使用Hashcode，可以从Java集合的常用需求来描述： 更深入的介绍 先来些简单的问题 HashMap的0.75负载因子 总结 我在网上看到的这篇文章，介绍的很不错，但是我看的那篇文章也是转载的，我也不知道原作者是谁，只能注明我是转载的 前言 首先再次强调hashcode （==）和equals的真正含义（我记得以前有人会说，equals是判断对象内容，hashcode是判断是否相等之类）： equals：是否同一个对象实例。注意，是“实例”。比如String s = new String(“test”); s.equals(s), 这就是同一个对象实例的比较； 等号(==)：对比对象实例的内存地址（也即对象实例的ID），来判断是否是同一对象实例；又可以说是判断对象实例是否物理相等； Hashcode：我觉得可以这样理解：并不是对象的内存地址，而是利用hash算法，对对象实例的一种描述符（或者说对象存储位置的hash算法映射）——对象实例的哈希码。 为什么需要使用Hashcode，可以从Java集合的常用需求来描述： Java中的集合（Collection）有两类，一类是List，再有一类是Set。前者集合内的元素是有序的，元素可以重复；后者元素无序，但元素不可重复。那么这里就有一个比较严重的问题了：要想保证元素不重复

查找链表中间节点位置有多种方式，首先会想到先遍历一遍获知节点个数，然后取一半作计数器控制访问步数。 另一种常会用到的是设置两个指针：fast_p, slow_p,步长分别为2和1，这样根据物理中 路程公式 s = v * t; fast_p走过的路程是slow_p的两倍，fast_p走到链表尾部时，slow_p一定在中间或中间左边第一个节点。 切记，循环终止条件是 （fast == null || fast.next == null) 不需要判断slow的状态。 如上图，序号分表代表第几次循环，同一序号左端的是slow节点，右边的是fast fast遇到终止条件的时候（fast == null or fast.next == null) slow正好在n/2处。 运用，如果回文以链表存储时，如问题 Palindrome Linked List 需要从slow.next的位置开始比较。 来源： https://www.cnblogs.com/vin-yuan/p/5380177.html

list是一个双链表。 函数 描述 void l.assign (int n, const val) void l.assign (it first, it last) 将链表 l 初始化为 n 个相同的 val 元素。 将链表 l 初始化为从 first 到 last 指针所指向的这一段区域内的元素。 It 指针同 l 是一个类型的。方便将另一个链表中的某一段连续的元素 copy 到新链表。 reference l.back () 返回最后一个元素。经测试，可以直接 l.back()= 元素。 It l.begin() 返回第1 个元素的地址。 Void l.clear() 清空链表。 bool l.empty() 判断链表中是否有元素，若有，返回true 。 It l.end() 返回最后一个元素的下一个元素的地址，即此地址没有实际元素。 it l.erase (it pos);it l.erase (it first, it last); 删除链表中 it 指针所指向的元素，返回被删元素的下一个元素地址。 删除从 first 到 last 这一段的所有元素，返回最后一个被删元素的下一个元素地址。 reference l.front () 返回第一个元素。假如 a=l.front() ，那么 a 只是一个备份，对 a 修改不影响链表。 get_allocator()

c++货物管理 用链表管理货物，用指针指向这个个链表 定义一个类goods ,定义一个goods *next; 方法buy(head,w)，sale(head),在buy中会调用有参数的构造函数，使得总重加上w，并且将新的货物加入链表，sale只使得货物从链表删除即可，因为减重是自动调用析构函数得到的，因为sale中用了delete,会触发析构 // panduan.cpp: 定义控制台应用程序的入口点。 // # include "stdafx.h" # include <iostream> # include <math.h> using namespace std ; class Goods { public : Goods ( ) { weight = 0 ; next = NULL ; cout << "创建了weight为" << weight << "的货物" << endl ; } Goods ( int w ) { //创建一个重量为weight的货物，并且total_weiht要加上这个重量 weight = w ; next = NULL ; total_weight + = w ; cout << "创建了weight为" << weight << "的货物" << endl ; } ~ Goods ( ) { //total

栈的定义： 所有的插入和删除操作都限制在线性表的同一端进行，是一种后进先出的线性表。 表尾端称栈顶，表头端称栈底。 栈的基本运算 initstack（）：初始化栈 push（）：元素入栈 pop（）：栈顶元素出栈 gettop（）；取栈顶元素 stackempty（）：判断是否为空 栈的分类 由于栈是一种线性表，则可将栈分为顺序栈和链式栈 ①顺序栈可借助数组进行建立，在建立初边分配好了空间，所以在每次入栈的时候，都必 须根据栈顶和栈底的差来判断是否栈满。 ②链式栈是一种单向链表，表头即是栈顶指针，每次添加元素时，便是在栈顶指针和第一个 数据之间进行添加。由于链式存储动态分配内存的原因，理论上栈长可以非常大，因此可 不用判断栈满，若有这一需求，可在节点数据域添加长度变量进行判断。 栈的简单使用（数制转换） 此处以链式栈为例： ①定义节点 class NumStackNode{ private String num; private NumStackNode nextNode; //相应get、set方法 } ②定义栈结构及相关函数 class LinkStack{ private NumStackNode headNode; //初始化 public void initStack() { this.headNode = new NumStackNode(); this

之前的文章「递归反转链表的一部分」讲了如何递归地反转一部分链表，有读者就问如何迭代地反转链表，这篇文章解决的问题也需要反转链表的函数，我们不妨就用迭代方式来解决。 本文要解决「K 个一组反转链表」，不难理解： 这个问题经常在面经中看到，而且 LeetCode 上难度是 Hard，它真的有那么难吗？ 对于基本数据结构的算法问题其实都不难，只要结合特点一点点拆解分析，一般都没啥难点。下面我们就来拆解一下这个问题。 一、分析问题 首先，前文 学习数据结构的框架思维 提到过，链表是一种兼具递归和迭代性质的数据结构，认真思考一下可以发现 这个问题具有递归性质 。 什么叫递归性质？直接上图理解，比如说我们对这个链表调用 reverseKGroup(head, 2) ，即以 2 个节点为一组反转链表： 如果我设法把前 2 个节点反转，那么后面的那些节点怎么处理？后面的这些节点也是一条链表，而且规模（长度）比原来这条链表小，这就叫 子问题 。 我们可以直接递归调用 reverseKGroup(cur, 2) ，因为子问题和原问题的结构完全相同，这就是所谓的递归性质。 发现了递归性质，就可以得到大致的算法流程： 1、先反转以 head 开头的 k 个元素 。 2、将第 k + 1 个元素作为 head 递归调用 reverseKGroup 函数 。 3、将上述两个过程的结果连接起来 。

题目： 实现一种算法，删除单向链表中间的某个节点（除了第一个和最后一个节点，不一定是中间节点），假定你只能访问该节点。 示例： 输入：单向链表a->b->c->d->e->f中的节点c 结果：不返回任何数据，但该链表变为a->b->d->e->f 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/delete-middle-node-lcci 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 ------------------------------------------------------------------------------------------------------------------------- 第一次： class Solution { public: void deleteNode(ListNode* node) { node->val = node->next->val; node->next = node->next->next; } }; 总结： 1. 直接把要删除节点的后继节点赋值给该节点，链表就会变成如下所示： 要删除第2个节点 则将第3个节点的值和指针赋值给第2个节点 此时第2个节点指针指向 第4个节点，但这时候只是断开了第2个节点和第3个节点的连接

本文始发于个人公众号： TechFlow ，原创不易，求个关注 链接 Merge k Sorted Lists 难度 Hard 描述 Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 给定K个有序链表，要求将它所有的元素归并到一个链表，并且有序。 样例: Input: [ 1->4->5, 1->3->4, 2->6 ] Output: 1- >1->2->3->4->4->5->6 题解 按照惯例，我们还是先来看最简单的解法，也就是暴力法。 暴力 这题当中，暴力的方法也很简单，非常简单粗暴，那就是先把所有元素取出来，排序之后再放到链表当中去。但是这么做说实话有点脱裤子放屁，我们分析一下复杂度也会发现，假设所有的元素个数是n，那么最后的复杂度应该就是排序所消耗的复杂度，也就是 \(O(nlogn)\) ，和K没有一点关系，而且我们也完全没有用上这K个链表当中的元素都是有序的这个信息，显然这是不科学的。 我们对上面的纯暴力方法稍稍做一些优化，想办法把K个链表当中元素有序的信息用上。用上的方法也很简单，我们之前做归并排序的时候曾经做过两个数组的归并，我们用同样的方法，只不过我们这次换成是K个链表而已。也就是说我们每次遍历这K个链表的头元素

/*#include <stdio.h> #include <stdlib.h> struct ListNode { int val; ListNode* next; ListNode(int x) :val(x), next(NULL){ } }; class Solution { public: ListNode* partionNode(ListNode* head, int x){ ListNode less_head(0); ListNode more_head(0); ListNode* less_ptr = &less_head; ListNode* more_ptr = &more_head; while (head) { if (head->val<x) { less_ptr->next = head; less_ptr = head; } else { more_ptr->next = head; more_ptr = head; } head = head->next; } less_ptr->next = more_head.next; more_ptr->next = NULL;//将more_ptr即链表尾结点置为空 return less_head.next; } }; int main() { ListNode a(1); ListNode b(4)

数据结构 单链表 代码: 为了避免同一个头文件被包含（include）多次，C/C++中有两种宏实现方式：一种是#ifndef方式；另一种是#pragma once方式。 # pragma once //或者 # ifndef __AAAA__ # define __AAAA__ /* */ # endif # pragma once # include <stdio.h> # include <stdlib.h> typedef int Status ; typedef int Elemtype ; # define OK 1 # define FAIL 0 # define EXITFLOW -1 typedef struct CirCalList { Elemtype data ; struct CirCalList * next ; } CirCalList , * CirCalLNode ; //初始化单链表 CirCalLNode Init_list ( ) ; //毁坏单链表 Status Destroy_list ( CirCalLNode L ) ; //清除单链表 Status Clear_list ( CirCalLNode L ) ; //获得单链表第i个值 Status Get_Element ( CirCalLNode L , int i ,