数据结构与算法-链表

最新推荐文章于 2022-08-04 13:41:03 发布
最新推荐文章于 2022-08-04 13:41:03 发布
阅读量199 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 java 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Zy1_6_2/article/details/119385185
版权
本文详细介绍了使用单链表、双向链表和单向循环链表实现水浒英雄排行榜的管理，包括增删改查操作。在单链表中，提供了添加到尾部和指定位置的方法，双向链表则允许更灵活的查找和删除，而单向循环链表用于解决约瑟夫问题。文章通过实例代码展示了各种链表操作的实现细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

链表

1、单链表

链表是有序的列表，但是它在内存中存储如下：
在这里插入图片描述
小结：

  1. 链表是以节点的方式来存储，是链式存储。
  2. 每一个节点包含data域，next域：指向下一个节点。
  3. 链表的各个节点不一定是连续存储。
  4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。

1.1单链表的应用（使用带head头的单向链表实现-水浒英雄排行榜管理）

  • 完成对英雄人物的增删改查操作.
  • 第一种方式在添加英雄时，直接添加到链表的尾部。
  • 第二种方式在添加英雄时，根据排名将英雄插入到指定的位置（如果这个排名存在，则添加失败，并给出提示）

在这里插入图片描述

1.1.1 方式一，添加到链表的尾部

添加（创建）：

  1. 先创建一个head头节点，作用是表示单链表的头。
  2. 后面我们每添加一个节点，就直接加入到链表的最后。
  3. 遍历：通过一个辅助变量变量，帮助遍历整个链表。

具体代码：

//先初始化一个头节点，头节点不要动,不存放具体的数据
private HeroNode head=new HeroNode(0, "", "");

/**添加结点到单向链表最后
 * 思路
 * 1、找到当前链表的最后一个结点
 * 2、将最后一个结点的next指向新的结点
 */
public void add(HeroNode heroNode) {
	//设置一个辅助变量
	HeroNode temp=head;
	boolean flag=false; //判断是否已经存在
	while(true) {
		//判断是否到达链表最后
		if(temp.next==null) {
			break;
		}
		//判断是否已经存在
		if(temp.next.no==heroNode.no) {
			flag=true;
			break;
		}
		//不是最后就继续后移
		temp=temp.next;
	}
	if(flag) {
		System.out.println("英雄编号"+heroNode.no+"已经存在！");
	}else {
		//到达最后的节点以后，指向新的结点
		temp.next=heroNode;
	}
}

1.1.2 方式二，添加到指定的位置

添加（创建）：

  1. 首先找到新添加的节点的位置，是通过辅助变量（指针），遍历找到。
  2. 新节点.next=temp.next。
  3. 将temp.next=新的节点。
  4. 如图:
    在这里插入图片描述

具体代码：

//根据排名添加英雄
public void addByOrder(HeroNode heroNode) {
	//定义一个辅助变量、一个标识(用于查看新的结点是否存在)
	HeroNode temp=head;
	boolean flag=false;
	while(true) {
		if(temp.next==null) {
			break;
		}
		//比较辅助变量的下一结点的编号 和 插入的结点编号的大小
		if(temp.next.no>heroNode.no) {
			break;
		}
		//判断是否已经存在
		if(temp.next.no==heroNode.no) {
			flag=true;
			break;
		}
		//用于遍历
		temp=temp.next;
	}
	
	if(flag) {
		System.out.println("英雄编号"+heroNode.no+"已经存在！");
		return;
	}else {
		//插入到链表中
		heroNode.next=temp.next;
		temp.next=heroNode;
	}
}

1.1.3 修改节点的信息

思路：

  1. 修改节点的信息，根据编号来修改。
  2. 根据编号找到这个节点，再将对应的值赋值给这个节点。

具体代码：

//修改结点的信息，通过no编号来修改
	public void update(HeroNode newheroNode) {
		//判空处理
		if(head.next==null ) {
			System.out.println("链表为空！");
			return;
		}
		//找到需要修改的结点
		HeroNode temp=head.next;
		//标识是否找的要修改的结点编号
		boolean flag=false;
		while(true) {
			if(temp==null) {
				break;//遍历完了
			}
			//找到
			if(temp.no==newheroNode.no) {
				flag=true;
				break;
			}
			temp=temp.next;//推动遍历
		}
		if(flag){
			//将要修改的编号的信息填入
			temp.name=newheroNode.name;
			temp.nickname=newheroNode.nickname;
		}else {
			System.out.println("您要修改的编号"+newheroNode.no+"没有找到！");
		}
	}

1.1.4 删除节点的信息

思路：

  1. 先找到需要删除的这个节点的前一个节点temp
  2. temp.next=temp.next.next;
  3. 被删除的节点，将不会有其他的引用指向，会被垃圾回收机制回收。

具体代码：

//从单链表中删除指定的结点
	public void delete(int no) {
		HeroNode temp=head;
		boolean flag=false;
		while(true) {
			//表示遍历完了
			if(temp.next==null) {
				break;
			}
			//找到了
			if(temp.next.no==no) {
				flag=true;
				break;
			}
			temp=temp.next;
		}
		if(flag) {
			//temp==temp.next==temp.next.next||现在要删除temp.next
			temp.next=temp.next.next;
		}else {
			System.out.println("您要删除的编号"+no+"没有找到！");
		}
	}

1.1.5 完整代码

main测试，list查看，完整的HeroNode

public class SingleLinkedListDemo {
	public static void main(String[] args) {
		HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
		HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
		HeroNode hero3 = new HeroNode(3,"吴用","智多星");
		HeroNode hero4 = new HeroNode(4,"林冲","豹子头");
		
		SingleLinkedList singleLinkedList = new SingleLinkedList();
		
		//添加【依次添加，不按编号顺序】

//		singleLinkedList.add(hero3);
		singleLinkedList.add(hero1);
		singleLinkedList.add(hero4);
		singleLinkedList.add(hero2);
		singleLinkedList.add(hero2);
		System.out.println("不按编号顺序的链表:");
		singleLinkedList.list();
		
		//添加【按编号顺序】
//		singleLinkedList.addByOrder(hero2);
//		singleLinkedList.addByOrder(hero1);
//		singleLinkedList.addByOrder(hero4);
		
		singleLinkedList.addByOrder(hero3);
		System.out.println("按编号顺序的链表：");
		singleLinkedList.list();
		
		HeroNode newhero = new HeroNode(2,"小卢","*玉麒麟*~");
		singleLinkedList.update(newhero);
		System.out.println("经过修改操作后的链表：");
		singleLinkedList.list();
		
		singleLinkedList.delete(1);
		System.out.println("经过删除操作后的链表：");
		singleLinkedList.list();
	}
}

//定义SingleLinkedList，用于管理我们的英雄
class SingleLinkedList{
	//先初始化一个头节点，头节点不要动,不存放具体的数据
	private HeroNode head=new HeroNode(0, "", "");
	
	/**添加结点到单向链表
	 * 思路
	 * 1、找到当前链表的最后一个结点
	 * 2、将最后一个结点的next指向新的结点
	 */
	public void add(HeroNode heroNode) {
		//设置一个辅助变量
		HeroNode temp=head;
		boolean flag=false; //判断是否已经存在
		while(true) {
			//判断是否到达链表最后
			if(temp.next==null) {
				break;
			}
			//判断是否已经存在
			if(temp.next.no==heroNode.no) {
				flag=true;
				break;
			}
			//不是最后就继续后移
			temp=temp.next;
		}
		if(flag) {
			System.out.println("英雄编号"+heroNode.no+"已经存在！");
		}else {
			//到达最后的节点以后，指向新的结点
			temp.next=heroNode;
		}
	}
	
	//根据排名添加英雄
	public void addByOrder(HeroNode heroNode) {
		//定义一个辅助变量、一个标识(用于查看新的结点是否存在)
		HeroNode temp=head;
		boolean flag=false;
		while(true) {
			if(temp.next==null) {
				break;
			}
			//比较辅助变量的下一结点的编号 和 插入的结点编号的大小
			if(temp.next.no>heroNode.no) {
				break;
			}
			//判断是否已经存在
			if(temp.next.no==heroNode.no) {
				flag=true;
				break;
			}
			//用于遍历
			temp=temp.next;
		}
		
		if(flag) {
			System.out.println("英雄编号"+heroNode.no+"已经存在！");
			return;
		}else {
			//插入到链表中
			heroNode.next=temp.next;
			temp.next=heroNode;
		}
	}
	
	//修改结点的信息，通过no编号来修改
	public void update(HeroNode newheroNode) {
		//判空处理
		if(head.next==null ) {
			System.out.println("链表为空！");
			return;
		}
		//找到需要修改的结点
		HeroNode temp=head.next;
		//标识是否找的要修改的结点编号
		boolean flag=false;
		while(true) {
			if(temp==null) {
				break;//遍历完了
			}
			//找到
			if(temp.no==newheroNode.no) {
				flag=true;
				break;
			}
			temp=temp.next;
		}
		if(flag){
			//将要修改的编号的信息填入
			temp.name=newheroNode.name;
			temp.nickname=newheroNode.nickname;
		}else {
			System.out.println("您要修改的编号"+newheroNode.no+"没有找到！");
		}
	}
	
	//从单链表中删除指定的结点
	public void delete(int no) {
		HeroNode temp=head;
		boolean flag=false;
		while(true) {
			//表示遍历完了
			if(temp.next==null) {
				break;
			}
			//找到了
			if(temp.next.no==no) {
				flag=true;
				break;
			}
			temp=temp.next;
		}
		if(flag) {
			//temp==temp.next==temp.next.next||现在要删除temp.next
			temp.next=temp.next.next;
		}else {
			System.out.println("您要删除的编号"+no+"没有找到！");
		}
	}
	
	//查看链表数据
	public void list() {
		//设置一个辅助变量
		HeroNode temp=head.next;
		//判断链表是否为空
		if(temp==null) {
			System.out.println("该链表为空！");
			return;
		}
		//遍历
		while(true) {
			//判断是否到最后
			if(temp==null) {
				break;
			}
			//输出节点的信息
			System.out.println(temp);
			//将节点后移
			temp=temp.next;
		}
	}
}

//定义HeroNode，每一个对象都是一个结点
class HeroNode{
	public int no;
	public String name;
	public String nickname;
	public HeroNode next; //指向下一个结点 

	//构造器
	public HeroNode(int no, String name, String nickname) {
		this.no = no;
		this.name = name;
		this.nickname = nickname;
	}

	@Override
	public String toString() {
		return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
	}
}

2、双向链表

2.1双向链表的应用（使用带head头的双向链表实现-水浒英雄排行榜管理）

单向链表的缺点分析：
1) 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
2) 单向链表不能自我删除，需要辅助节点，而双向链表则可以自我删除，在单向链表中的删除，我们总是找到temp(temp是待删除节点的前一个节点)

双向链表如图：

在这里插入图片描述

2.1.1 思路分析

  1. 遍历
    方法和单向链表一样，只是可以向前，也可以向后查找。
  2. 添加（默认添加到双向链表的最后）
    (1)先找到双向链表的最后这个节点。
    (2)temp.next=newHeroNode;
    (3)newHeroNode.pre=temp;
  3. 修改
    和单向链表的思路和原理一样。
  4. 删除
    (1)因为是双向链表，因此，我们可以实现自我删除某个节点。
    (2)直接找到要删除的这个节点。
    (3)temp.pre.next=temp.next;
    (4)temp.next.pre=temp.pre;（这里需要判断是否为最后一个节点）
    (5)如图 :
    在这里插入图片描述

2.1.2 完整代码

public class DoubleLinkedListDemo {
	public static void main(String[] args) {
		HeroNode hero1=new HeroNode(1, "宋江", "及时雨");
		HeroNode hero2=new HeroNode(2, "吴用", "智多星");
		HeroNode hero3=new HeroNode(3, "卢俊义", "玉麒麟");
		HeroNode hero4=new HeroNode(4, "林冲", "豹子头");
		HeroNode hero5=new HeroNode(5, "张顺", "浪里白条");
		HeroNode hero6=new HeroNode(6, "公孙胜", "入云龙");
		HeroNode hero7=new HeroNode(6, "公孙胜", "入云龙~~");
		DoubleLinkedList DLL=new DoubleLinkedList();
		
		DLL.add(hero1);
//		DLL.add(hero2);
		DLL.add(hero3);
		DLL.add(hero4);
		DLL.add(hero5);
		
		DLL.addByOrder(hero2);
		DLL.addByOrder(hero6);
		
		System.out.println("原始双向链表：");
		DLL.list();
		
		DLL.update(hero7);
		System.out.println("修改操作后的双向链表：");
		DLL.list();
		
		DLL.delete(6);
		System.out.println("删除操作后的双向链表：");
		DLL.list();
	}
}


class DoubleLinkedList{
	//先初始化一个头节点，头节点不要动
	private HeroNode head=new HeroNode(0, "", "");
	
	//获取头节点
	public HeroNode getHead() {
		return head;
	}
	
	//查看链表数据
	public void list() {
		//设置一个辅助变量
		HeroNode temp=head;
		//判断链表是否为空
		if(temp.next==null) {
			System.out.println("链表为空！");
			return;
		}
		while(true) {
			if(temp.next==null) {
				break;
			}
			//后移
			temp=temp.next;
			System.out.println(temp);
		}
	}
	
	//添加默认添加到链表的末尾
	public void add(HeroNode headNode) {
		//辅助变量
		HeroNode temp=head;
		boolean flag=false; //用于判断要添加的结点是否已经存在
		while(true) {
			if(temp.next==null) {
				//此时已经遍历完了
				break;
			}
			//判断是否已经存在
			if(temp.next.no==headNode.no) {
				flag=true;
				break;
			}
			//后移，遍历
			temp=temp.next;
		}
		if(flag) {
			System.out.println("英雄编号"+headNode.no+"已经存在！");
			return;
		}else {
			//到达最后的节点以后，指向新的结点
			temp.next=headNode;
			//最后一个结点的pre指向前一个结点
			headNode.pre=temp;
		}
	}
	
	//修改结点信息
	public void update(HeroNode newHeroNode) {
		HeroNode temp=head.next;
		boolean flag=false; //辨识要修改的结点是否存在
		if(temp==null) {
			System.out.println("链表为空！");
			return;
		}
		while(true) {
			if(temp==null) {
				break;
			}
			if(temp.no==newHeroNode.no) {
				flag=true;
				break;
			}
			temp=temp.next;
		}
		if(flag) {
			temp.name=newHeroNode.name;
			temp.nickname=newHeroNode.nickname;
			return;
		}else {
			System.out.println("英雄编号"+newHeroNode.no+"没有找到！");
			return;
		}
	}
	
	//删除结点
	//1对于双向链表,我们可以直接找到要删除的这个节点
	//2找到后,自我删除即可
	public void delete(int no) {
		HeroNode temp=head.next;
		boolean flag=false;
		if(temp==null) {
			System.out.println("链表为空！");
			return;
		}
		while(true) {
			//遍历完
			if(temp==null) {
				break;
			}
			//找到
			if(temp.no==no) {
				flag=true;
				break;
			}
			temp=temp.next;
		}
		if(flag) {
			temp.pre.next=temp.next;
			//判断是否到达最后一个结点
			if(temp.next!=null) {
				temp.next.pre=temp.pre;
				return;
			}
		}else {
			System.out.println("英雄编号"+no+"没有找的！");
		}
	}
	
	//根据英雄编号的大小进行添加
	public void addByOrder(HeroNode heroNode) {
		HeroNode temp=head;
		boolean flag=false;
		boolean flag1=false;
		while(true) {
			if(temp.next==null) {
				break;
			}
			if(temp.next.no==heroNode.no) {
				//表示已经存在
				flag=true;
				break;
			}
			if(temp.next.no>heroNode.no) {
				flag1=true;
				break;
			}
			temp=temp.next;
		}
		if(flag) {
			System.out.println("英雄编号"+heroNode.no+"已经存在！");
			return;
		}
		
		if(flag1){
			heroNode.next=temp.next;
			heroNode.pre=temp;
			temp.next.pre=heroNode;
			temp.next=heroNode;
			return;
		}else {
			//到达最后的节点以后，指向新的结点
			temp.next=heroNode;
			//最后一个结点的pre指向前一个结点
			heroNode.pre=temp;
		}
	}
}


//定义HeroNode，每一个对象都是一个结点
class HeroNode{
	public int no;
	public String name;
	public String nickname;
	public HeroNode next; //指向下一个结点 
	public HeroNode pre;//指向上一个结点

	//构造器
	public HeroNode(int no, String name, String nickname) {
		this.no = no;
		this.name = name;
		this.nickname = nickname;
	}

	@Override
	public String toString() {
		return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
	}

}

3、单向循环链表

3.1 josephu（约瑟夫）问题

3.1.1 描述

Josephu问题为:设编号为1，2,… n的n个人围坐一圈，约定编号为k ( 1<=k<=n)的人从1开始报数，数到m的那个人出列，它的下—位又从1并始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

3.1.2 思路

用一个不带头结点的循环链表来处理Josephu问题:先构成一个有n个结点的单循环链表，然后由k结点起从1开始计数，计到m时，对应结点从链表中册除,然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中册除算法结束。

如图所示： 出列顺序为：2->4->1->5->3。
从1开始数，数到2的出列，循环直到最后一个。
在这里插入图片描述
构建一个单向循环链表思路

  1. 先创建第一个节点，让first指向该节点，并形成环状。
  2. 后面当我们没创建一个新的节点，就把该节点，加入到已有的环形链表中即可。

遍历环形链表

  1. 先让一个辅助指针（变量）curboy,指向first节点。
  2. 然后通过一个while循环遍历该环形链表即可curboy.next == first结束。
    在这里插入图片描述

出圈思路：

  1. 需求创建一个辅助指针（变量）helper,事先应该指向环形链表的最后这个节点。
  2. 当小孩报数时，让first和helper指针同时的移动m-1次。
  3. 这时就可以将first指向的小孩节点出圈
    first=fist.next;
    helper.next=first
    原来的first指向的节点就没有任何引用，就会被回收。
    在这里插入图片描述

3.1.3 代码实现

public class Josephu {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入小孩的个数：");
		int num=sc.nextInt();
		CircleSingleLinkedList CSLL = new CircleSingleLinkedList();
		CSLL.addBoy(num);
		System.out.println("~~~~~~~~~~~查看信息~~~~~~~~~~~");
		CSLL.showBoy();
		//测试
		System.out.println("~~~~~~~~~~~出圈操作~~~~~~~~~~~");
		CSLL.countNum(1,3,num);
	}
}

class CircleSingleLinkedList{
	//创建一个first结点，当前没有编号
	private Boy first=null;
	
	//【添加】小孩结点，构建一个环形的链表
	public void addBoy(int nums) {
		//定义一个辅助指针
		Boy curBoy=null;
		
		//nums做一个数据校验
		if(nums<1) {
			System.out.println("nums的值不正确");
			return;
		}
		//循环创建我们的环形链表
		for(int i=1;i<=nums;i++) {
			//根据编号，创建小孩结点
			Boy boy=new Boy(i);
			//如果是第一个小孩
			if(i==1) {
				first=boy;
				first.setNext(first); //构建环
				curBoy=first; //让curboy指向第一个小孩
			}else {
				curBoy.setNext(boy);
				boy.setNext(first);
				curBoy=boy;
			}
		}
	}
	
	//【显示】遍历当前的环形链表
	public void showBoy() {
		//判断链表是否为空！
		if(first==null) {
			System.out.println("一个小孩都没有！");
			return;
		}
		//因为first不能动，因此我们还是需要一个辅助指针完成遍历
		Boy curBoy=first;
		while(true) {
			System.out.println("小孩的编号为："+curBoy.getNo());
			//判断是否遍历完
			if(curBoy.getNext()==first) {
				break;
			}
			curBoy=curBoy.getNext();
		}
	}
	
	/**
	 * 出圈
	 * @param startNo 开始位置
	 * @param countNum 数的数字
	 * @param nums 圈中人数
	 */
	public void countNum(int startNo,int countNum,int nums) {
		//先对数据进行校验
		if(first==null || startNo<1 || startNo>nums) {
			System.out.println("参数输入有误！");
			return;
		}
		Boy helper=first;
		//创建一个辅助指针(变量)helper,事先应该指向环形链表的最后一个结点
		while(true) {
			if(helper.getNext()==first) {
				break;
			}
			//不是，就要进行后移
			helper=helper.getNext();
		}
		//小孩报数前，显然first和helper移动k-1次
		for(int j=0;j<startNo-1;j++) {
			first=first.getNext();
			helper=helper.getNext();
		}
		//直到圈中只有一个结点
		while(true) {
			if(helper==first) {
				break;
			}
			//first和helper移动k-1次
			for(int j=0;j<countNum-1;j++) {
				first=first.getNext();
				helper=helper.getNext();
			}
			//这时first指向的结点，就是要出圈的小孩结点
			System.out.println("小孩"+first.getNo()+",出圈!");
			//将first后移，再把helper.next指向新定义的first 
			first=first.getNext();
			helper.setNext(first);
		}
		System.out.println("最后一个圈中的小孩编号为："+first.getNo());
	}
}

//创建一个boy类，表示一个结点
class Boy{
	private int no;
	private Boy next;//指向下一个结点
	
	public Boy(int no) {
		super();
		this.no = no;
	}
	
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public Boy getNext() {
		return next;
	}
	public void setNext(Boy next) {
		this.next = next;
	}
}
数据结构与算法 -- 链表
u012967763的专栏
08-21 666
一点一滴学算法，算法从入门到放弃
数据结构与算法：链表
baiyechangjiu的博客
08-21 370
链表是物理存储单元上非连续的，非顺序的存储结构，链表是由一个个结点，通过指针来联系起来的，其中每个结点包含数据和指针： 或者我们采用另一张更加明显的图： 因为在C++语言中，当我们生成一个数组的时候，就要声明数组的长度，如此计算机便会在内存上开辟一个连续的不间断的内存空间来存储数据，因为存在着这样的一种可能，也就是数组所使用的内存空间之后的内存空间已经被使用，所以C++中一旦数组的大小明确了，就不能够再改变了。而且因为数组是存储一系列的同一类型的变量的集合，所以构成数组的每一个元素占用的内存空间
数据结构与算法--链表
R.先森的博客
12-28 338
概述 数组需要连续的内存空间来储存，所以对内存要求比较高，如果我们申请一个100MB的数组，如果内存中没有连续的，内存足够大的空间时，即使剩余总内存大于100MB，也会申请失败 链表需要不连续的内存空间来储存，他通过指针，把一组不连续的内存块连接起来使用，所以如果申请100MB的链表，不会有问题 常见的链表有，单链表，循环链表，和双向链表，我们先看一下单链表 单链表 链表通过指针，将一组不连续的...
链表 - 数据结构与算法 - 链表算法
最新发布
11-01
链表在数据结构与算法的学习中，是一个非常基础且重要的部分。掌握链表的原理和操作，对于理解更复杂的算法，如排序算法（归并排序）、查找算法（哈希表）以及各类树结构的实现等，都有着不可替代的作用。学习链表...
cailingling721#data-structures-and-algorithms#数据结构和算法-链表实战-环形链表I
07-25
链表实战题目4 - 链表入环的第一个节点给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。为了表示给定链表中的环，我们使用整数 pos
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
cailingling721#data-structures-and-algorithms#数据结构和算法-链表实战-两两交换链
07-25
# 将第一个节点指向第三个节点# 第二个节点指向第一个节点# 节点first指向第二个节点# 当前节点后移动，记得a.next是节点3，相当于跳了一个节点，往后
数据结构和算法-思维导图.pdf
05-26
以上是根据文件的标题、描述、标签和部分预览内容总结出的数据结构与算法知识点。这些知识点是IT行业中软件开发人员必备的基础知识，广泛应用于软件设计、算法实现、系统优化等众多领域。掌握这些知识点能够帮助IT...
《数据结构与算法》之链表
菜鸟的向往
05-14 336
最近因为在学习《数据机构与算法》，所以有一段时间没有更新博客了。现在通个写一篇关于链表的博客和一个demo来巩固一下最近的学习，把理论转换为“实战”。 链表结构五花八门，其中最常见的链表结构有单链表、双向链表和循环链表。顺便一提，如果在面试中涉及到到链表，面试官老喜欢问你一句：数组和链表的区别。只要我们理解掌握了什么是链表才能从结构、存储数据、插入、删除上的差异来回答。 在这篇文章先说一下单链表。 首先手写一个单链表 要写一个单链表就必须弄清楚它的数据结构，来一张图看下它长什么样子 清楚了它的数据结构
数据结构与算法—链表
weixin_49757069的博客
05-22 370
链表 链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称指针或链接）组成。 链表与数组的对比： 相对于传统的数组，链表的一个好处在于，添加或移除元素的时候不需要移动其他元素。在数组中，我们可以直接访问任何元位置的任何元素，而要想访问链表中间的一个元素，则需要从起点（表头）开始迭代链表直到找到所需的元素。 class Node { constructor(element) { this.el
JavaScript实现单向链表
雨的印记的博客
03-01 403
JavaScript实现单向链表 javascript 数据结构与算法源码 目录JavaScript实现单向链表一、单向链表简介二、封装单向链表类2.0.创建单向链表类2.1.append(element)2.2.toString()2.3.insert(position,element)2.4.get(position)2.5.indexOf(element)2.6.update(position,element)2.7.removeAt(position)2.8.其他方法2.9.完整实现 一、单向链表简
数据结构与算法---链表
weixin_55938630的博客
07-02 206
数据结构与算法--单链表
【数据结构与算法】---链表
weixin_67900732的博客
08-04 4111
今天小编带大家学习数据结构中的链表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值