数据结构-链表

最新推荐文章于 2022-06-03 18:46:50 发布
最新推荐文章于 2022-06-03 18:46:50 发布
阅读量234 收藏
点赞数
分类专栏： JavaScript-数据结构 文章标签： 数据结构 链表 基础算法 案例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_NuoDaDa/article/details/81123547
版权

链表

链表主要分为三种形式，分别为单向链表、双向链表和循环链表；

一、单向链表

链表常用方法：

方法                                   原理

insert（data ）                   从插入数据

find（data ）                      查找数据

remove（）                        删除

首先我们需要创建一个方法，并创建头结点

//创建单向链表的节点  
function Node(element) {
    this.element = element;
    this.next = null;
}

function LList() {
        //创建链表的头结点
        this.head = new Node("head");
  }

基本方法实现

1.数据插入 

插入我们可以分为三种，其中最为基本的就是在链表最后插入数据；其二是在指定数据之前插入数据；其三为在指定数据之后插入数据；单向链表的插入的核心思想就是在插入的位置将node节点的next断开，然后再将前后两个旧节点与新节点的连接起来；

插入节点图示：

下面为具体代码：

//基本插入算法
this.insert=function (data) {
            //1,创建新的节点
            var buffer = new Node(data);
            //2,获得最后的节点
            var last = this.findLast();
            //3,把最后节点的next指向新节点
            last.next=buffer;
        }

 //在当前元素after之后插入数据element
this.insertAfter1=function (element,after) {
            //找到当前节点after
            let node=this.find(after);
            // 创建一个新节点
            let newNode= new Node(element);
            //将新节点的下一个节点与当前节点的下一个节点链接起来
            newNode.next=node.next;
            //将当前节点的下一个节点指向新节点
            node.next=newNode;
        }

 //在当前元素before之前插入数据element
this.insertBefore1=function (element,before) {
            //找到当前节点的之前的节点
            let preNode = this.findPrevious(before);
            // 创建一个新节点
            let newNode= new Node(element);
            //将新节点的下一个节点与当前节点的前一个节点连接起来
            newNode.next=preNode.next;
            //将当前节点的前一个节点的下一个节点指向新节点
            preNode.next=newNode;
        }

 

2.查找数据  

查找数据需要利用while循环，对链表进行遍历，其中最主要的就是while循环的循环条件

查找当前数据：

 this.find=function (data) {
           //创建一个节点
            let buffer=this.head;
            while(buffer!=null){
                if(buffer.element==data){
                    return buffer;
                }
                //将当前节点的下一个节点赋值给当前节点
                buffer=buffer.next;
            }
            //如果没有找到则返回空
            return buffer;
        }

查找当前节点的前一个节点：

this.findPrevious=function (data) {
            //创建一个节点
            let buffer=this.head;
            //找到当前节点
            let currentNode=this.find(data);
            //如果buffer的下一个节点是当前节点，则返回buffer
            while(buffer.next!=currentNode){
                //将当前节点的下一个节点赋值给当前节点
                buffer=buffer.next;
            }
            return buffer;
        }

3.删除节点

删除节点其实与插入节点的原理差不多，都是断开需要删除节点的前后节点的链接，然后将前后两个节点通过next链接在一起。关于单向链表的插入和删除其基本原理都是先断开节点然后是链接节点，所以要明确要断开的节点和要连接的节点，这样事情就很好理解了。

删除节点图示：

代码如下：

             this.remove = function (item) {
                //获得当前节点的前一个节点，调用this.findPrevious函数
                var prevNode = this.findPrevious(item);
                console.log(prevNode);
                if (!(prevNode.next == null)) {
                    prevNode.next = prevNode.next.next;
                }
            };

 4.遍历节点

代码如下：

         this.forEach=function(call) {
                //1,获得头节点
                var currNode = this.head;
                var index=0;
                //2,遍历节点数据
                while(currNode!=null){
                    call(currNode.element,index);
                    currNode=currNode.next;
                }
            };

5.将节点向前移动n个节点

有两种方法：

（1）假若向前移动2个节点，将element3节点向前移动2个节点，移动到element1 节点之前；我们则先找到element1节点，断开element1节点与前一个节点的链接和element2与element3节点之间和element3与next节点的链接；最后依次链接起来即可；图示：

代码如下：

           this.advance=function(currElement,n){
                //获得当前节点
                var currentNode = this.find(currElement);
                //获得当前节点的前一个节点
                var buffer = this.findPrevious(currElement);
                var preNode=buffer;
                while(preNode.element!='head'&&n>0){
                    preNode = this.findPrevious(preNode.element);
                    n--;
                }
                buffer.next=currentNode.next;
                currentNode.next=preNode.next;
                preNode.next=currentNode;
            }

 

（2）第二种方法是将当前节点与前一个节点不断的交换位置，知道element3节点交换到element1节点之前即可；图示：

交换位置具体做法，图示：

代码如下：

             //将当前节点想前移动n个节点
            this.advance=function(currElement,n){
                //获得当前节点
                var currentNode=this.find(currElement);
                while(prePreNode!=this.head&&n>0){
                    //获得当前节点的前一个节点
                    var preNode=this.findPrevious(currentNode.element);
                    //获得前一个节点的前一个节点
                    var prePreNode=this.findPrevious(preNode.element);
                    //将前一个节点与当前节点的next节点链接
                    preNode.next=currentNode.next;
                    //将当前节点与前一个节点链接起来
                    currentNode.next=preNode;
                    //将前前节点与当前节点链接
                    prePreNode.next=currentNode;
                    n--;
                }
            }

6.将当前节点向后移动n个节点

原理与向前移动相同；代码如下：

（1）第一种方法

             //将当前节点向后移动n个节点
            this.back=function(currElement,n){
                //1,获得当前的节点
                var currentNode = this.find(currElement);
                //2,假设当前的节点为最后的节点
                var lastNode=currentNode;
                //当前节点的前一个节点和当前节点的后一个节点连在一起
                var currentPre=this.findPrevious(currElement);
                //3,在n大于0的条件下，下一个节点为空的时候停下来
                while(lastNode.next!=null&&n>0){
                    lastNode = lastNode.next;
                    n--;
                }
                //4,currentNode节点和lastNode相等，说明currentNode本身就是最后的节点
                if(currentNode==lastNode){
                    return;
                }
                currentPre.next=currentNode.next;
                //把当前节点连在lastNode节点后面
                currentNode.next=lastNode.next;
                lastNode.next=currentNode;
            }

（2）第二种方法 

             //将当前节点向后移动n个节点
            this.back=function(currElement,n){
                //获得当前节点
                var currentNode=this.find(currElement);
                // var buffer=currentNode;
                while(currentNode.next!=null&&n>0){
                    //获得当前节点的前一个节点
                    var preNode=this.findPrevious(currentNode.element);
                    //获得当前节点的下一个节点
                    var nextNode=currentNode.next;
                    //将前一个节点与当前节点的next节点链接
                    preNode.next=currentNode.next;
                    currentNode.next=nextNode.next;
                    //将当前节点与前一个节点链接起来
                    nextNode.next=currentNode;
                    n--;
                }
            }

二、双向链表

双向链表与单向链表不同的地方就在于，双向链表不仅有后继同时还有前驱；

     function Node(element) {
            this.element = element;
            this.next = null;
            this.previous = null;
        }

1.数据插入

             //插入节点
            this.insert=function(element) {
                //创建新节点
                var newNode = new Node(element);
                //获得头节点
                var currNode = this.head;
                //获得最后的节点
                while(currNode.next!=null){
                    //把当前节点的下一个节点赋值给当前的节点
                    currNode= currNode.next;
                }
                //把新创建的节点插入到最后的节点
                currNode.next =newNode;
                //把最后的节点给新节点的前驱赋值
                newNode.previous=currNode;
            }

            this.insertAfter=function (element,after) {
                //找到当前after节点
                var currNode = this.find(after);
                //创建新的节点
                var newNode = new Node(element);
                if(currNode.next==null){
                    //把after节点的后继给新节点
                    currNode.next=newNode;
                    //新节点的前驱指向当前的节点
                    newNode.previous= currNode;
                }
                else{
                    //把after节点的后继给新节点的后继
                    newNode.next=currNode.next;
                    currNode.next.previous=newNode;
                    newNode.previous = currNode;
                    currNode.next=newNode;

                }
            }

2.遍历节点

            this.forEach=function (call) {
                //1,获得头节点
                var currNode = this.head;
                while(currNode!=null){
                    call(currNode);
                    currNode = currNode.next;
                }
            }

            //反序遍历
             this.forEachReverse=function (call) {
                //1 获得最后的节点
                var lastNode = this.findLast();
                //2,获得下标
                var index=this.length-1;
                //3,反向遍历
                while(lastNode!=null){

                    call(lastNode,index);
                    index--;
                    lastNode= lastNode.previous;
                }
            }

3.查找节点

             //查找当前节点
            this.find=function(element){
                //1,获得第一个节点
                var currNode = this.head;

                //2,遍历节点
                while(currNode!=null&&currNode.element!=element){
                    //3，把当前节点的下一个节点给当前节点赋值
                    currNode = currNode.next;
                }
                //返回当前节点
                return currNode;
            }

            //找到最后节点
            this.findLastNode=function () {
                //1,获得头节点
                var currNode = this.head;
                //2,遍历节点
                while(currNode.next!=null){
                    //3，把当前节点的下一个节点给当前节点赋值
                    currNode = currNode.next;
                }
                //3,返回当前的节点
                return currNode;
            }

4.删除节点

            this.remove = function (element) {
                //1,获得当前的节点
                var currNode = this.find(element);
                //2,判断当前节点是否是最后的节点，为空，说明是最后一个节点，不为空，说明不是最后一个节点
                if (currNode.next == null) {
                    //3，找到当前节点的前一个节点
                    var preNode = currNode.previous;
                    //4,前一个节点的后继为空
                    preNode.next = null;
                } else {
                    //3，找到当前节点的前一个节点
                    var preNode = currNode.previous;
                    //4,找到当前节点的后一个节点
                    var lastNode = currNode.next;
                    //5,前一个节点的next指向lastNode
                    preNode.next = lastNode;
                    //6,后一个节点的前驱指向前一个节点
                    lastNode.previous = preNode;
                }
            }

三、循环链表

循环链表的的最后一个节点与头结点相连；

         function LList() {
            this.head = new Node('head');

            //始终是在最后一个节点插入
            this.insert = function (element) {

                //1,设置当前的节点
                var currentNode = this.head;
                //2,创建新的节点
                var newNode = new Node(element);
                while (currentNode.next != null) {
                    //把当前节点的下一个节点给予当前的节点
                    currentNode = currentNode.next;
                }
                //当前节点的下一个节点指向新节点
                currentNode.next = newNode;
                //新的节点的前一个节点指向当前的节点
                newNode.previous = currentNode;


                //把后面的头节点连接在一起
                newNode.next = this.head;

                this.head.previous=newNode;

            }

            this.insertAfter = function (newElement, after) {
                var after = this.find(after);
                var newNode = new Node(newElement);

                if (after == null || after.next == null) {
                    after = this.findLast();
                    after.next = newNode;

                    newNode.previous = after;

                } else {
                    //after的后继的前驱指向当前的节点
                    after.next.previous = newNode;
                    newNode.next = after.next;

                    after.next = newNode;
                    newNode.previous = after;
                }

            }

            this.find = function (element) {
                var currentNode = this.head;

                while (currentNode != null && currentNode.element != element) {
                    currentNode = currentNode.next;
                }
                return currentNode;
            }

            this.forEach = function (call) {
                //1,获得当前的节点
                var currentNode = this.head.next;
                //2,设置遍历节点的下标
                var index = 0;

                var time = 0;
                //3,遍历节点
                while (currentNode != null&&currentNode.element!='head') {
                    call(currentNode, index);
                    //把当前的节点移动后面去
                    currentNode = currentNode.next;
                    //下标加1
                    index++;
                }
            }

            this.forEachReverse = function (call) {
                //1,找到最后的节点
                var lastNode = this.findLast();
                //2，反向的遍历
                while (lastNode != null) {
                    call(lastNode);
                    lastNode = lastNode.previous;
                }
            }

            this.findLast = function () {
                //当前的头节点
                var currentNode = this.head;
                //遍历
                while (currentNode.next != null) {
                    currentNode = currentNode.next;
                }
                return currentNode;

            }

            this.remove = function (element) {
                //1,获得头节点
                var currentNode = this.head;
                //2,遍历节点
                while (currentNode != null && currentNode.element != element) {
                    currentNode = currentNode.next;
                }
                currentNode.previous.next = currentNode.next;
                currentNode.next.previous = currentNode.previous;

            }

        }

 

 

 

 

 

 

A_NuoDaDa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
C语言数据结构-链表版学生管理系统
10-02
源码+可运行exe程序
（2）链表有哪几种分类——4
weixin_30782293的博客
03-26 308
从链表的实现方式可以把链表分为单链表，循环链表，双向链表。 单链表指的是链表中的元素的指向只能指向链表中的下一个元素或者为空，元素之间不能相互指向。也就是一种线性链表。 双向链表即是这样一个有序的结点序列，每个链表元素既有指向下一个元素的指针，又有指向前一个元素的指针，其中每个结点都有两种指针，即left和right。left指针指向左边结点，right指针指向右边结点。 tem...
快慢指针在链表中的使用
qq_45801780的博客
03-23 279
快慢指针在链表中的使用 链表毫无疑问是数据结构中最重要的知识点之一，因此许多面试官都很喜欢在链表上做文章。链表主要有这几种形式：单向链表，双向链表，循环链表。以链表为考点的面试题更是千变万化，令人眼花缭乱。下面让我们来看一道十分简单的题目： 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。 如果有两个中间结点，则返回第二个中间结点。 示例1： 输入：[1,2,3,4,5] 输出：...
八大数据结构——链表（三）
BaldIsImpossible的博客
02-23 379
//实现一个只有单向的链表 public class LinkedList<Type> { private Node<Type> firstNode;//头节点 private Node<Type> lastNode;//尾节点 private int size; public LinkedList(){ clear(); } public LinkedList(Type val) { c
数据结构—链表（三）
白夜行
12-01 422
主要内容： 检测链表是否有环、在不知道头指针的情况下怎么删除非末尾节点、判断两个链表是否相交、找到相交链表的交点。 重点是看懂解题思路，思路明白了，代码就非常好写了。 package com.sf.linkedlist; /** * Created by laxe on 2016/12/1. */ public class LinkedListDemo2 { static
《Effective C++》 总结篇(定制new和delete)
bwabdbkjdbkjwabd的博客
06-03 202
本章主要唠嗑一下new和delete。当operator new抛出异常以反应未获满足的内存需求之前会先调用new-handle。客户可以指定这个“用以处理内存不足”的函数，客户必须调用set_new_handler。(在标准库) 本例代码就是不断生成内存直到用尽，而抛出异常。为了防止当operator无法满足内存申请时反复调用new-handler函数，我们需要做以下事情: 1.让更多内存被使用。(调用new-handler之后将资源释放) 2.安装另一个new-hander。(当前的new-hander
数据结构-链表的C语言使用
03-25
数据结构-链表的用法，单链表，带头节点链表，循环链表等，C语言code
第11章 动态数据结构-链表-21
08-03
第11章 动态数据结构的C语言实现单向链表-2int power;struct node *next;建立一个单向链表1 创建节点：2 链：使每个节点的指针域存
数据结构-链表相关功能和算法
06-11
数据结构-链表相关功能和算法
数据结构-链表(LingkedList)介绍和Java示例代码
07-01
介绍数据结构链表(LingkedList)的概念、特点、优缺点、适用场景和Java示例代码
链表_数据结构--链表_
10-01
在windows端利用python实现链表的相关功能
数据结构-链表 JAVA语言实现
08-24
数据结构-链表 JAVA语言实现,包含单向链表、双向链表、循环链表的遍历、删除和插入 详细介绍：http://blog.csdn.net/z740852294/article/details/77369439
数据结构-链表-倒置.eddx
10-19
数据结构-链表-倒置.eddx
数据结构-链表的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 链表的部分实现代码（单向链表、双向链表、循环链表、约瑟夫环等），详细介绍参考数据结构--链表的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
c ringbuffer 源码_环形缓冲区ringbuffer c++类模版实现
weixin_36240219的博客
01-26 141
#pragma once#include "stdlib.h"#include #define MAX_ASK_FOR_CAP (1 << 16) // 64Kstruct BufferInfo{BufferInfo(unsigned int r = 0, unsigned int w = 0, unsigned int c = 0): read(r), write(w)...
线做缓冲区buffer出现null的解决办法
weixin_34177064的博客
01-31 1232
GeometryService geometryService = new GeometryService("http://tasks.arcgisonline.com/ArcGIS/rest/services/Geometry/GeometryServer"); geometryService.BufferCom...
memset函数详细说明
热门推荐
VC++/MFC的专栏
06-05 12万+
1。void *memset(void *s,int c,size_t n)总的作用：将已开辟内存空间 s 的首 n 个字节的值设为值 c。2。例子＃includevoid main(){char *s="Golden Global View";clrscr();memset(s,G,6);printf("%s",s);getchar();return 0;}　3。memset() 函数常用于
数据结构----单向链表
最新发布
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。 单向链表的特点是插入和删除操作的效率较高，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值