链表

/* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) {} };*/ class Partition { public: ListNode* partition(ListNode* pHead, int x) { // 如果链表为空，直接返回空 if(NULL == pHead) return NULL; //定义一个cur遍历pHead ListNode* cur = pHead; //定义两个结构体类型的变量，后面加（），赋初值 ListNode lessHead(0); ListNode greatHead(0); //定义两个链表，指向两个结构体类型的变量 ListNode* lessTail = &lessHead; ListNode* greatTail = &greatHead; //开始遍历pHead，分割数组 while(cur) { if(cur->val<x) { //将小的放在lessHead后面 lessTail->next = cur; lessTail = cur; } else { //大的放在greatHed后面 greatTail->next = cur; greatTail = cur; } //cur向后走 cur =

redis是一个存储键值对的内存数据库，并且持久化到磁盘。 1、简单动态字符串（Simple Dynamic String，简称SDS） 1）利用len记录字符串长度，使得strlen时间复杂度从O(N)变为O(1)。 // sds.h struct __attribute__ ((__packed__)) sdshdr64 { uint64_t len; // 字符串已用的长度 uint64_t alloc; // 分配的总长度 char buf[]; // 字符串内容 }; 2）利用类似vector的分配策略，append时预分配一倍空间，减少内存分配次数。 // sds.c/sdsMakeRoomFor if (avail >= addlen) return s; newlen = (len+addlen); if (newlen < SDS_MAX_PREALLOC) newlen *= 2; else newlen += SDS_MAX_PREALLOC; sdssetalloc(s, newlen); 2、双向链表（Doubly Linked List） 1）利用len，使得计算链表长度的时间复杂度从O(N)变为O(1)。 2）表头和表尾插入元素的时间复杂度都是O(1)。注：这是所有双向链表的特性。 // adlist.h typedef struct listNode

线性表的链式存储结构 目录 线性表的链式存储结构 单链表的相关运算 线性表基本运算在单链表上的实现 一道例题 在每个节点中除包含有数据域外，只设置一个指针域 ，用以指向其后继节点，这样构成的链接表称为线性单向链 接表，简称 单链表 ，为了便于插入和删除运算的实 现，每个链表带有一个头节点，并通过头节点的指针唯一标识该链表。 单链表的缺点 ：当访问过一个节点后，只能接着访问它的 后继节点，而无法访问它的前驱节点。 单链表的相关运算 先定定义一下链表的结构体 typedef struct Lnode { int data ; struct Lnode * next ; } LinkList ; 插入和删除节点 插入节点 LinkList * p //这是指向原来在链表中的 LinkList s //这是需要被插入的节点 s - > next = p - > next ; p - > next = s ; //：只需修改相关节点的指 针域，不需要移动节点 删除节点 LinkList * p // 指向链表 假设需要被删的元素是指 的后驱元素 p - > next = p - > next - > next ; 建立单链表： 头插法建表 特点：新节点插入到当前链表的表头上，最后得到的链表是一个与插入顺序相反的链表 void CreateHeadList ( LinkList * & L ,

一、测试源程序： 【 list.h 文件 】 1 #ifndef _LIST_HEAD_ 2 #define _LIST_HEAD_ 3 4 /* 链表节点结构 */ 5 struct list_head { 6 struct list_head *prev; 7 struct list_head *next; 8 }; 9 10 /* 初始化链表 */ 11 #define LIST_HEAD_INIT(name) \ 12 {&(name), &(name)} 13 14 /* 创建链表并初始化 */ 15 #define LIST_HEAD(name) \ 16 struct list_head name = LIST_HEAD_INIT(name) 17 18 /* 得到结构体头至某成员的偏移量 */ 19 #define offsetof(type, member) \ 20 ((void*)(&((type*)0)->member)) 21 22 /* 由成员地址得到结构体首地址 */ 23 #define container_of(ptr, type, member) \ 24 ((type*)((void*)ptr-offsetof(type, member))) 25 26 /* 链表中插入新节点 */ 27 static inline void _list

文章目录 1.单链表 2.静态链表 3.循环链表 4.双向链表 5.优缺点 1.单链表 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素 有时，我们在单链表的第一个节点之前附设一个结点，称为头结点。它的数据部分是空的或者存储链表的长度，指针指向第一个节点的指针 单链表的定义 typedef int ElemType ; typedef struct { ElemType data ; Node * next ; } Node , * LinkList ; 给出索引得到对应单链表元素的值 由此可见存取元素比顺序线性表要麻烦 若1<i<n，则频度为i-1，否则为n，所以时间复杂度为O(n) bool GetElem_L ( LinkList & L , int i , ElemType & e ) { int j = 0 ; Node * p = L -> next ; while ( p && j < i ) { p = p -> next ; ++ j ; } if ( ! p ) return false ; e = p -> data ; return true ; } 实现单链表的插入 时间复杂度为： O(n) bool ListInsert_L ( LinkList & L , int i , ElemType e ) { int j ; Node *

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。 思路：建立一个新的结点 然后list1和list2比较 谁小谁连接在新结点的后面。 public class Solution { public ListNode Merge(ListNode list1,ListNode list2) { ListNode head=new ListNode(-1); head.next=null; ListNode root =head; while(list1!= null && list2 != null){ if(list1.val < list2.val){ head.next=list1; head=list1; list1=list1.next; } else{ head.next=list2; head=list2; list2=list2.next; } } if(list1 != null){ head.next = list1; } if(list2 != null){ head.next = list2; } return root.next; } } 来源： https://www.cnblogs.com/nlw-blog/p/12421742.html

单链表删除重复数据 在日常的学习生活中，突然有一次实验报告让我写一个单链表删除重复数据的实验，就记录一下。 预定义： sLinkNode.h # include <malloc.h> # include <stdio.h> typedef int ElemType ; typedef struct node { ElemType data ; //数据域 struct node * next ; //指针域 } SLinkNode ; //单链表类型 void InitList ( SLinkNode * & L ) //L作为引用型参数 { L = ( SLinkNode * ) malloc ( sizeof ( SLinkNode ) ) ; //创建头结点*L L - > next = NULL ; } void DestroyList ( SLinkNode * & L ) { SLinkNode * pre = L , * p = pre - > next ; while ( p != NULL ) { free ( pre ) ; pre = p ; p = p - > next ; //pre、p同步后移 } free ( pre ) ; } void DispList ( SLinkNode * L ) //输出单链表 { SLinkNode * p = L -

题目描述 输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空） 思路： 遍历链表，复制每个节点，跟在每个节点后方，如A’=A.next 重新遍历链表，复制老节点的随机节点 A‘.random=A.random.next 拆分链表，将链表拆分成原链表和复制后的链表 # -*- coding:utf-8 -*- class RandomListNode : def __init__ ( self , x ) : self . label = x self . next = None self . random = None class Solution : # 返回 RandomListNode def Clone ( self , pHead ) : # write code here if not pHead : return None current_head = pHead #复制链表节点 while current_head : clone_node = RandomListNode ( current_head . label ) clone_node . next = current_head . next

/* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/ class Solution { public: ListNode* ReverseList(ListNode* pHead) { if (pHead ==NULL){ return NULL; } ListNode *pre = NULL; ListNode *cur = pHead; ListNode *temp = NULL; while (cur != NULL){ temp = cur->next;//在这里暂存一下下一个指针 cur->next = pre;//把当前的值指向前一个值 pre = cur;//前一个值向后走一步 cur = temp;// 把下一个值付给当前的值 } return pre; } }; 来源： CSDN 作者： ttomchy 链接： https://blog.csdn.net/ttomchy/article/details/104678146

Data Structures 【原文见： http://www.topcoder.com/tc?module=Static&d1=tutorials&d2=dataStructures 】 作者 By timmac TopCoder Member 翻译 农夫三拳@seu drizzlecrj@gmail.com 即使计算机能够毫不夸张的每秒执行上百万次的数学运算，当一个问题变得庞大且复杂时，性能仍然是一个很重要的考虑方面。最至关紧要的关于快速解决问题的方面之一就是数据在内存中是如何存储的。 为了举例说明这点，可以试想你进入一个图书馆去查找某个学科的一本书。最有可能的是你能够使用一些电子参考或者在最坏情况下，有一个卡片目录来帮助你找到你想要的书的名称和作者。由于书籍都是按目录进行排放的并且在每一个目录中是按照作者的姓名排序的，因此这是一个直接并且轻松的过程，那么然后你就可以在书架上找到你想要的书了。 现在，假定你去图书馆找一本特定的书，然而这里没有排放好的书架，只有在房间角落有一些排成行的袋子，里面放满了可能相关可能不相关的书。这样就可能需要数个小时甚至数天来找到你需要的书了，这是一个对比性强的道理。这就是数据在没有存储为与应用相关的格式时软件运行的情况。 简单的数据结构（Simple Data Structures） 最简单的数据结构是原生的变量。他们存放单个值，并且使用中受限