链表

参考来源 > 自己的理解 Node cur = head . next ; Node cur_next = null ; Node reverseHead = new Node ( 0 ) ; //全新的空节点，用于存放反转的节点 while ( cur != null ) { //cur不为空即为遍历结束 cur_next = cur . next ; cur . next = reverseHead . next ; //这里的rhead.next会把ur.next给占用了，因此需要提前保留cur.next到cur_next reverseHead . next = cur ; cur = cur_next ; System . out . println ( reverseHead . toString ( ) ) ; // System.out.println(); } head . next = reverseHead . next ; 假设链表为 1>2>3>4 （1）不算头结点，把第一个节点设置为当前节点，即为cur，此时的cur的next 是指向原链表(2,3,4)，需要把这个指向关系给断掉，就让cur的next指向一个新建q为null，这个时候第一个节点和q就组成了新的链表，cur.next是null，就不是原链表(2,3,4)了，这个时候再把第一个节点(cur

-- 暑假已经过去一周了，由于昨天一直在弄小学期实验的验收，所以没来得及写这篇周总结，今天来谈一下这一周的收获，还有还有发现的问题。 这一周是我们的小学期，经过为期十天的集中编程能力训练，我们的编程能力得到了明显的提升。 这次小学期编程技能训练，不但应用了这一年学习的这些知识（ C 、 C++ ），而且在编程中发现了自己的薄弱点进行了弥补与拓展例如：以前不太明白链表这一块儿改怎么应用不理解链表的运行机制，通过这次链表类的训练让我初步掌握了链表的应用，还比如以前不太会文件流操作，通过系统类的训练，与询问同学，上网查资料让我掌握了文件流的操作。这次训练还让我学到了我以前没接触过的东西，通过上网查询解决了训练中遇到的问题比如游戏类的随机数还有权重。 总的来说小学期不但锻炼了我的编程能力，还增强了我编程的兴趣。暑假一定继续努力，学好 Java ，为下学期做准备！ 从明天开始要为下学期的课程做准备！ 来源： https://www.cnblogs.com/mac-13/p/11157285.html

数据结构的三要素： 1.数据的逻辑结构 2.数据的物理结构（存储结构） 3.数据的运算 一、数据的逻辑结构 线性表 1.1 一般线性表 1.2 受限线性表 1.2.1 栈 1.2.2 队列 1.3 线性表推广 1.3.1 数组 1.3.2 广义表 非线性表 2.1 集合 2.2 树形结构 2.2.1 一般树 2.2.2 二叉树 2.3 图状结构 2.3.1 有向图 2.3.2 无向图 二、数据的物理结构（存储结构） 顺序存储 2. 链表存储 3. 索引存储 4. 散列存储 三、数据的运算 如：检索、插入、删除、更新、排序等。 ———————————————— 版权声明：本文为CSDN博主「superjoson21」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/superjoson21/article/details/8147014 来源： CSDN 作者： OneITman 链接： https://blog.csdn.net/OneITman/article/details/104343387

链表思想 链表是以节点的方式进行存储 每个节点包含两个域：data+next:指向下一个节点 链表的各个节点并不一定是连续存储的 链表分为带头节点的链表和不带头节点的链表,根据实际需求来选择 我们以水浒英雄好汉的排名来解释链表结构在Java中的实现 class HeroNode { int id ; String name ; Hero next ; } 每个英雄节点包含一个id,一个姓名（data域） 和指向下一个节点的引用next. 单链表-英雄好汉 现在我们有一个需求，就是向单链表中添加多个英雄好汉的节点。 添加节点思想：先创建一个head头节点，表示单链表的头 （case 1）每添加一个节点，添加到单链表的最后 找到最后一个节点，将最后节点的next指向 新的节点 （case 2）按排名添加到链表对应位置，如果该位置已经被占用，则返回错误信息 通过辅助节点找到新添加的节点的位置（遍历) 新的节点.next = temp.next temp.next = 新的节点 遍历链表思想：通过一个辅助变量来遍历整个单链表 删除节点思想：先找到要删除节点的前一个节点temp,temp.next = temp.next.next; 被删除的节点将不会有其他引用指向，会被垃圾回收。 查找单链表中倒数第K个节点(新浪) 1）编写一个方法，接受head参数+k参数 2）先遍历整个列表

首先啊哈算法的链表建立简单易懂，是这样的 # include <stdio.h> # include <stdlib.h> struct node { int data ; struct node * next ; } ; int main ( ) { struct node * head , * p , * q , * t ; int i , n , a ; scanf ( "%d" , & n ) ; head = NULL ； for ( i = 1 ; i <= n ; i ++ ) { scanf ( "%d" , & a ) ; p = ( struct node * ) malloc ( sizeof ( struct node ) ) ; p -> data = a ; p -> next = NULL ; if ( head == NULL ) { head = p ; else q -> next = p ; } q = p ; } return 0 ; } C编程书上的是这样的： # include <stdio.h> # include <stdlib.h> struct student { char name [ 20 ] ; int number ; struct student * next ; } ; int icount ; struct

双向链表 定义 ：每个节点有两个指针域，分别知道 直接前驱 和 直接后继 节点 ， 特点是可以重 任意节点 出发，从 两个方向 遍历链表 数据结构 typedef struct node { int data ; struct node * font ; struct node * next ; } NODE , * LinkList ; 插入 // p 为链中节点 s 为待插入节点 把s 放在p前 s -> font = p -> font ; // s 的前驱在是 p 的前驱节点 p -> font -> next = s ; // p 前驱节点的 后继节点是 s s -> next = p ; p -> font = s ; 删除 p -> font -> next = p -> next ; // p 的前驱节点的后继 是 p 的后继节点 p -> next -> font = p -> font ; // p 的后继节点 的前驱节点 是 p 的前驱节点 free ( p ) ; 循环链表 定义 ：在单向或双向链表的基础上令表尾节点的指针指向第一个节点，构成循环 静态链表 定义 ： 借数组来描述线性表的链式存储，用数组元素的下标表示元素所在节点的指针 指针域代表的下一个值得地址 数据结构 typedef struct node { int index ; // 指针 int

算法思路 1. 求链表总长度，取得一半数，遍历链表一半的数量，取得中间节点 2. 用两个指针，一个每次都移动一回，一个每两次移动一回，当第一个指针遍历完链表，后一个指针就正好指向中间 代码实现1 st_dataNode * getListMidNode(st_dataNode * head){ if(NULL == head){ printf("%s: param error\n",__func__); return NULL; } int len = 0; int m = 0; st_dataNode * mid = NULL; len = getListLen(head); m = (len / 2 - 1); // 注意应该建议，因为下标是从0开始的 if(m == 0){ return head; } mid = head; while(m > 0){ mid = mid->next; m--; } return mid; } 代码实现2 /* 通过一次遍历来完成寻找中间节点 */ st_dataNode * getListMidNode2(st_dataNode * head){ if(NULL == head){ printf("%s: param error\n",__func__); return NULL; } int step1 = 0, step2 = 0;

一.线程不安全的HashMap 多线程环境下，使用HashMap进行put操作会引起死循环（jdk1.7 Entry链表形成环形数据结构），导致CPU利用率接近100%。 结构：数组 table[]＋链表entry<k,v> put 对key做hash 默认初始化数组长度 16 加载因子 0.75 扩容 大于16*0.75时 rehash hash冲突:链表解决。原来的entry移出去，后来的进来，然后next指向原来的entry 线程不安全:多个线程扩容时闭环，引起死循环。 为什么会形成闭环: 线程1 A>B>C 线程2 B>A倒置。会变成A>B>A 解决: 1.8 红黑树:数组＋链表＋红黑树。阈值:8 hashmap扩容过程: 传入新的容量 初始化新的Entry数组，将数据转移到新的Entry数组里(遍历旧数组，取得每个元素，释放旧数组的引用，重新计算位置) table属性引用新的entry数组 修改阈值 hash算法:取key的hashcode值，高位运算，取模运算 1.8的优化 1.resize时不需要重新计算hash，只要看看原来的hash新增的那个bit是0还是1。0的话索引没变，1的话索引变成原索引加oldcap。找到新数组下标，确定索引位置，增加随机性。 2.不会形成闭环，扩容时不再使用头插法改成尾插法。 二.效率低下的HashTable

struct Edge { int to, w, next;// to:边的终点 w:边的权值 next:链表的下一条边 }edges[MAXM]; int head[MAXN], cnt; // cnt为当前边的编号 void add(int from, int to, int w) { ++cnt;//拿出一个元素用于存储 edges[cnt].w = w; //边权为w edges[cnt].to = to; //该边的终点为to edges[cnt].next = head[from];//当前边作为以from开头的链表的第一条边 head[from]=cnt; } 思想具体是：我们开设一个足够大的用于存边的内存池，每次需要存边时从内存池中拿出一个元素用来存储（对应了++cnt）。用head[i]表示以i为出发点的可到达的边集中的第一条边，现在我们假设存储一条从from 到 to 的 权值为w的边，具体步骤如下: 1.从内存池中拿出一个元素用于存储 ++cnt 2.设置边权和到达节点:edges[cnt].w=w;edges[cnt].to=to; 3.将新增的边链接到from对应的链表的头上去，和链表的头插法类似 edges[cnt].next=head[from];head[from]=cnt; 当然不要忘记最重要的初始化是让所有的head[i]都预先指向-1。

删除链表中重复的结点：较难 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5 public class Solution { public ListNode deleteDuplication(ListNode pHead) { if(pHead==null||pHead.next==null)return pHead; ListNode p0=new ListNode(-2147483648);//构造前站节点来防止第一个节点被删除的惨剧 ListNode p1=p0; ListNode p2=pHead; int temp=pHead.val; int dup=0;//dup==1表示有重复 while (p2.next!=null){//循环外还有处理? if(p2.next.val==temp){ dup=1; p2=p2.next;// } else{ if (dup==0){ p1.next=p2; p1=p1.next; } dup=0; temp=p2.next.val; p2=p2.next; } } if (dup==0)p1.next=p2; if (dup==1)p1.next=null;//p1每次接收都是后面一串 p0=p0