链表

在单链表中，我们需要在内部有一个头节点，我们可以通过这个头节点找到其他的节点，相当于一个线索。 纵观顺序结构的线性表和单链表的实现，难点基本上都在于添加和删除操作。基于数组的线性表中，数组的索引就相当于是线性表的序号，但在单链表中，我们没有序号这个东西，所以在添加和删除操作中，我们需要先找到指定的元素，然后才能继续进行操作。在插入操作中，我们需要同时保存有当前节点的前一个节点和当前的节点，因为当前要插入的节点要放在前一个节点的Next引用域，而当前节点要放在要插入节点的next域。删除节点与此相似。 using System ; using System . Collections . Generic ; using System . Linq ; using System . Text ; namespace DataStructure { class LinkList < T > : IListDS < T > { class Node < T > { private T data ; /// <summary> /// 数据域 /// </summary> public T Data { get { return data ; } set { data = value ; } } private Node < T > next ; /// <summary> /// 引用域

函数顺序依次为单链表的创建（头插和尾插法）， 初始化，判空，遍历，求链表长度，按值查找，按位查找，插入，删除，销毁 操作 并且在主函数中举例说了链表的创建，遍历，求长，删除，插入操作; 进阶操作: c循环链表 http://blog.csdn.net/bestsort/article/details/78715889 http://blog.csdn.net/bestsort/article/details/78715962 #include <stdio.h> #include <stdlib.h> typedef int DataType; //用DataType 替代 int方便修改数据类型 typedef struct Node{ DataType data; //数据域 struct Node *next; //指针域 }Node; //建立单链表(尾插法） //比如说数据1 2 3 4 5 //链表中从头指针开始数据顺序为1 2 3 4 5 //每次从链表末尾插入 Node *CreatTailList(DataType a[],int n){ Node *s = NULL,*r = NULL; Node *first = (Node *)malloc( sizeof(Node)); r = first;//尾指针初始化 first -> next = NULL;

单链表插入排序 #include<bits/stdc++.h> using namespace std; struct LNode { int data; LNode *next; }; void creathead(LNode *&L,int a[],int n)///尾插法 { LNode *r,*s; L=(LNode*)malloc(sizeof(LNode)); L->next=NULL; r=L; for(int i=0; i<n; i++) { s=(LNode*)malloc(sizeof(LNode)); s->data=a[i]; r->next=s; r=r->next; } r->next=NULL; } ///插入排序思想 void insertsort(LNode *&L) { LNode *p,*q,*r; p=L->next->next;///插入排序从第二个元素开始 L->next->next=NULL; while(p) { q=p->next;///p接着的元素节点 r=L; while(r->next!=NULL && r->next->data < p->data)///找p应该插入的位置 r=r->next; ///头插 p->next=r->next; r->next=p; p=q;///继续下一个 } } int main() {

链表中最小值移到表头 #include<bits/stdc++.h> using namespace std; struct LNode { int data; LNode *next; }; void creathead(LNode *&L,int a[],int n)///尾插法 { LNode *r,*s; L=(LNode*)malloc(sizeof(LNode)); L->next=NULL; r=L; for(int i=0; i<n; i++) { s=(LNode*)malloc(sizeof(LNode)); s->data=a[i]; r->next=s; r=r->next; } r->next=NULL; } void solve(LNode *&L) { LNode *p,*minn,*pre,*minpre; p=L->next; pre=L; minn=p; while(p!=NULL) { if(p->data<minn->data) { minn=p; minpre=pre; } pre=p; p=p->next; } if(minn!=L->next) { minpre->next=minn->next; minn->next=L->next; L->next=minn; } } int main() { LNode *L,*B; int n

一、什么是链表？ 链表是一种物理上 非连续 、 非顺序 的存储结构，数据元素之间的顺序是通过每个元素的 指针 （类似C语言中的指针，Java中是引用）关联的。 链表由一系列节点组成，每个节点一般至少会包含两部分信息：一部分是元素数据本身，另一部分是指向下一个元素地址的“指针”。这样的存储结构让链表相比其他线性的数据结构来说，操作会复杂一些。 说到链表，我们经常拿来与数组比。我们先看下面一张图再来对比它们的各自的优劣。 从图中我们看到，数组需要一块 连续 的内存空间来存储，对内存的要求比较高。如果我们申请一个 100MB 大小的数组，当内存中没有连续的、足够大的存储空间时，即便内存的剩余总可用空间大于 100MB，仍然会申请失败。 而链表恰恰相反，它并不需要一块连续的内存空间，它通过“指针”将一组零散的内存块串联起来使用，所以如果我们申请的是 100MB 大小的链表，根本不会有问题。 这里先思考一下下面这个问题。 Q：数组在实现上为什么使用的是连续的内存空间？ A：可以借助 CPU 的缓存机制，预读数组中的数据，所以访问效率更高。而链表在内存中并不是连续存储，所以对 CPU 缓存不友好，没办法有效预读。 Q：上一答案中CPU缓存机制指的是什么？为什么就数组更好了？ A： CPU在从内存读取数据的时候，会先把读取到的数据加载到CPU的缓存中

大纲： 1，线性表的定义和基本操作 定义： 线性表是具有 相同类型 的n(n>=0)个元素的 有限序列 ，其中n为表长，当n=0时，该表为空表。 基本操作： 初始化表：构造一个空的线性表 销毁操作：销毁线性表，并释放线性表L所占用的内存空间。 按值查找：在表L中查找具有给定关键字值的元素。 按位查找：取表L中第i个位置的元素的值。 插入操作：在表L中的第i个位置插入指定元素e。 删除操作：删除表L中第i个位置的元素，并用e返回删除元素的值。 输出操作：按前后顺序输出线性表L的所有元素的值。 判空操作：若L为空表，则返回TRUE，否则返回FALSE。 求表长：返回线性表L的长度，即L中的元素个数。 2，线性表的顺序表示 一般采用数组储存 数组起点为0，线性表起点为1 数组不可以动态增加长度 线性表可以动态增加长度 3，线性表的链式表示 线性表的链式存储又称单链表 。 。 。 。 。 。 。 有空再写 。 。 。 。 来源： CSDN 作者： 王跃坤 链接： https://blog.csdn.net/qq_43652327/article/details/104446416

前言 # 哈希表，又名散列表。是非常常用的一种数据结构，C#的Hashtable、字典，Java的HashMap，Redis的Hash，其底层实现都是散列表。而在一些互联网公司的面试中，更是技术面试官们必问的一道题目。本文将简单了解哈希表(散列表)这种数据结构。 一、散列表 # 1.1 散列表 # 散列表(哈希表)，其思想主要是基于数组支持按照下标随机访问数据时间复杂度为O(1)的特性。可是说是数组的一种扩展。假设，我们为了方便记录某高校数学专业的所有学生的信息。要求可以按照学号(学号格式为:入学时间+年级+专业+专业内自增序号，如2011 1101 0001)能够快速找到某个学生的信息。这个时候我们可以取学号的自增序号部分，即后四位作为数组的索引下标，把学生相应的信息存储到对应的空间内即可。 如上图所示,我们把学号作为key,通过截取学号后四位的函数后计算后得到索引下标，将数据存储到数组中。当我们按照键值(学号)查找时，只需要再次计算出索引下标，然后取出相应数据即可。以上便是散列思想。 1.2 散列函数 # 上面的例子中，截取学号后四位的函数即是一个简单的散列函数。 Copy //散列函数 伪代码 int Hash(string key) { // 获取后四位字符 string hashValue =int.parse(key.Substring(key.Length-4, 4)

public class Node { public Object data; public Node next; public Node(){} public Node(Object data,Node next){ this.data = data; this.next = next; } } 　　 public class CirSingleLink { private Node node = null; private int size = 0; public void init(){ node = new Node(); node.data = null; //头结点指向头结点 node.next = node; } //从尾结点进行插入 public void add(Object i){ Node newNode = new Node(i,node); if(node.next == node){ node.next = newNode; }else{ Node tmp = node; while (tmp.next != node){ tmp =tmp.next; } tmp.next = newNode; } size ++; } public void delete(Object i){ Node tmp = node; while(tmp.next !=

LinkedHashSet集合概述和特点 LinkedHashSet集合特点 哈希表和链表实现的Set接口， 具有可预测的迭代次序; 由链表保证元素有序,也就是说元素的存储和取出顺序是一致的; 由哈希表保证元素唯一， 也就是说没有重复的元素; 存储字符串并遍历： public class LinkedHashSetTest { public static void main ( String [ ] args ) { LinkedHashSet < String > linkedhs = new LinkedHashSet < > ( ) ; linkedhs . add ( "hello" ) ; linkedhs . add ( "world" ) ; linkedhs . add ( "java" ) ; linkedhs . add ( "world" ) ; for ( String s : linkedhs ) { System . out . println ( s ) ; } } } 来源： CSDN 作者： August98_LYH 链接： https://blog.csdn.net/qq_43472877/article/details/104457401

1.3 链表：从尾到头打印链表 题目描述 输入一个链表，按链表从尾到头的顺序返回一个ArrayList。 栈思路： class Solution { public: vector<int> printListFromTailToHead(ListNode* head) { vector<int> value; ListNode *p=NULL; p=head; stack<int> stk; while(p!=NULL){ stk.push(p->val); p=p->next; } while(!stk.empty()){ value.push_back(stk.top()); stk.pop(); } return value; } }; 数组翻转：数组翻转可以用C++自带的函数，也可以自己实现 class Solution { public: vector<int> printListFromTailToHead(ListNode* head) { vector<int> value; ListNode *p=NULL; p=head; while(p!=NULL){ value.push_back(p->val); p=p->next; } //reverse(value.begin(),value.end()); //C++自带的翻转函数 int temp=0; int