单链表的实现-CSDN博客

本文链接：https://blog.csdn.net/weixin_57681114/article/details/126693533

链表是有序的列表，但是它在内存中是存储如下

特点:

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

单链表介绍

单链表(带头结点) 逻辑结构示意图如下

使用带head头的单向链表实现

代码如下:

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(hero1);
		singleLinkedList.add(hero2);
		singleLinkedList.add(hero3);
		singleLinkedList.add(hero4);
      // 遍历列表
        singleLinkedList.list();
    }
}

// 定义的链表
class SingleLinkedList{
	// 先初始化一个头节点,头节点不动,不存放具体的数据
	private HeroNode head = new HeroNode(0, "", "");
	
	
	// 返回头节点(通过头节点就可以找到这条链表的所有节点)
	public HeroNode getHead() {
		return head;
	}
	
	// 添加节点到链表
	public void add(HeroNode heroNode) {
		//因为head节点不能动，因此我们需要一个辅助遍历 temp
		HeroNode temp = head;
		//遍历链表，找到最后
		while(true) {
			//找到链表的最后
			if(temp.next == null) {//
				break;
			}
			//如果没有找到最后, 将将temp后移
			temp = temp.next;
		}
		//当退出while循环时，temp就指向了链表的最后
		//将最后这个节点的next 指向 新的节点
		temp.next = heroNode;
	}
	
	// 添加节点,按照no这个属性顺序添加
	public void addByOrder(HeroNode heroNode) {
		// 1.准备一个指针
		HeroNode temp = head;
		boolean flag = false;
		while(true) {
			if(temp.next == null) {
				break;
			}
			if(temp.next.no > heroNode.no) {
				break;
			}else if(temp.next.no == heroNode.no){
				flag = true;
				break;
			}
		}
		// 出循环之后,判断当前编号是不是已经存在在我们的链表中
		if(flag) {
			System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.no);
		}else {
			// 将元素插入到链表中,将元素插入到temp的后面
			// 1.将新元素的next指向temp的下一个元素
			heroNode.next = temp.next;
			// 2.将temp的next指向新元素
			temp.next = heroNode;
		}
	}
	
	// 修改节点的信息,根据no编号来修改,即no编号不能修改,修改name和nickName两个数据
	public void update(HeroNode newHeroNode) {
		// 判断是否为空
		if(head.next == null) {
			System.out.println("链表为空~");
			return;
		}
		// 找到需要修改的节点,根据no这个编号
		// 定义一个辅助变量
		HeroNode temp = head.next;
		// 定义一个辅助变量
		boolean flag = false;
		// 遍历链表
		while(true) {
			// 找到最后一个节点
			if(temp == null) {
				break;
			}
			if(temp.no == newHeroNode.no) {
				// 找到这个节点
				flag = true;
				break;
			}
			// 将temp指针下移
			temp = temp.next;
		}
		// 出来这个循环,来判断我们找到的这个节点是不是我们需要找的那个节点
		if(flag) {
			// 将新节点的name和nickName赋值给temp
			temp.name = newHeroNode.name;
			temp.nickname = newHeroNode.nickname;
		}else {
			System.out.printf("没有找到 编号 %d 的节点，不能修改\n", newHeroNode.no);
		}
		
	}
	
	// 删除节点
	// 1.head头节点不能动,我们需要一个辅助节点
	// 2.在比较的时候用no这个属性来进行比较
	public void del(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;
		}
		// 除了循环之后,现在的temp就是我们要删除的节点的上一个节点
		if(flag) {
			temp.next = temp.next.next;
		}else {
			System.out.printf("要删除的 %d 节点不存在\n", no);
		}
	}

	// 遍历链表
	public void list() {
		// 判断链表是否为空
		if(head.next == null) {
			System.out.println("链表为空");
			return;
		}
		HeroNode temp = head.next;
		while(true) {
			if(temp == null) {
				break;
			}
			System.out.println(temp);
			// 将temp后移
			temp = temp.next;
		}
	}
}

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 + "]";
	}
}

1)求单链表中有效节点的个数

public static int getLength(HeroNode head) {
		// 判断链表是否为空
		if(head.next == null) {
			return 0;
		}
		int length = 0;
		// 遍历单链表(从第一个有效的节点开始计数)
		HeroNode cur = head.next;
		while(cur != null) {
			length++;
			cur = cur.next;
		}
		return length;
	}

2)查找单链表中的倒数第k个结点【新浪面试题】

public static HeroNode findLastIndexNode(HeroNode head, int index) {
		// 判断来链表是否为空
		if(head.next == null) {
			return null;
		}
		// 遍历得到链表的长度(节点的个数)
		int size = getLength(head);
		// 检验index
		if(index < 0 || index > size) {
			return null;
		}
		// 定义一个指针,从第一个有效的元素开始
		HeroNode cur = head.next;
		// 遍历单链表需要找的这个倒数的元素就是正着数的总的有效长度-倒着数的长度
		for (int i = 0; i < size - index; i++) {
			cur = cur.next;
		}
		return cur;
	}

3)单链表的反转【腾讯面试题】

public static void reversetList(HeroNode head) {
		// 如果当前链表为空或者只有一个节点,无需反转,直接反转
		if(head.next == null || head.next.next == null) {
			return;
		}
		// 定义一个指针,从第一个有效元素开始遍历
		HeroNode cur = head.next;
		// 定义一个cur节点的下一个节点
		HeroNode next = null;
		// 准备一个新链表
		HeroNode reverseHead = new HeroNode(0, "", "");
		// 遍历原来的链表,没遍历一个节点，就将其取出,将每一个节点放在新链表的最前端
		while(cur != null) {
			// 1.先将cur的下一个节点保存起来
			next = cur.next;
			// 2.将cur的下一个节点指向新的链表的最前端(防止这个旧的链表没有指针引用,被jv回收)
			cur.next = reverseHead.next;
			// 3.cur这个节点放在新链表的最前端
			reverseHead.next = cur;
			// 4.cur后移动
			cur = next;
		}
		// 除了循环之后,将旧链表的头指针的下一个节点设置为新链表的第一个有效元素
		head.next = reverseHead.next;
		
	}

4)从尾到头打印单链表【百度，要求方式1：反向遍历。方式2：Stack栈】

public static void reversePrint(HeroNode head) {
		if(head.next == null) {
			return;//空链表，不能打印
		}
		//创建要给一个栈，将各个节点压入栈
		Stack<HeroNode> stack = new Stack<HeroNode>();
		HeroNode cur = head.next;
		//将链表的所有节点压入栈
		while(cur != null) {
			stack.push(cur);
			cur = cur.next; //cur后移，这样就可以压入下一个节点
		}
		//将栈中的节点进行打印,pop 出栈
		while (stack.size() > 0) {
			System.out.println(stack.pop()); //stack的特点是先进后出
		}
	}

整体的代码与测试:

package com.atguigu.linkedList;

import java.beans.beancontext.BeanContext;
import java.util.Stack;

import javax.xml.transform.Templates;

/*
 * 单链表
 */
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(hero1);
		singleLinkedList.add(hero2);
		singleLinkedList.add(hero3);
		singleLinkedList.add(hero4);
		
		/*
		 * 将节点按照no属性的大小来进行加入
		singleLinkedList.addByOrder(hero1);
		singleLinkedList.addByOrder(hero3);
		singleLinkedList.addByOrder(hero4);
		singleLinkedList.addByOrder(hero2);
		 * 
		 */
		// 测试单链表的反转功能
		System.out.println("原来链表的情况~~");
		singleLinkedList.list();
		
//		System.out.println("反转单链表~~");
//		reversetList(singleLinkedList.getHead());
//		singleLinkedList.list();
		
		System.out.println("测试逆序打印单链表, 没有改变链表的结构~~");
		reversePrint(singleLinkedList.getHead());
		
		
	}
	
	
	/**
	 * 将单链表反转,使用栈的方式
	 * @param head
	 */
	public static void reversePrint(HeroNode head) {
		if(head.next == null) {
			return;//空链表，不能打印
		}
		//创建要给一个栈，将各个节点压入栈
		Stack<HeroNode> stack = new Stack<HeroNode>();
		HeroNode cur = head.next;
		//将链表的所有节点压入栈
		while(cur != null) {
			stack.push(cur);
			cur = cur.next; //cur后移，这样就可以压入下一个节点
		}
		//将栈中的节点进行打印,pop 出栈
		while (stack.size() > 0) {
			System.out.println(stack.pop()); //stack的特点是先进后出
		}
	}
	
	
	/**
	 * 将单链表反转
	 * @param head
	 */
	public static void reversetList(HeroNode head) {
		// 如果当前链表为空或者只有一个节点,无需反转,直接反转
		if(head.next == null || head.next.next == null) {
			return;
		}
		// 定义一个指针,从第一个有效元素开始遍历
		HeroNode cur = head.next;
		// 定义一个cur节点的下一个节点
		HeroNode next = null;
		// 准备一个新链表
		HeroNode reverseHead = new HeroNode(0, "", "");
		// 遍历原来的链表,没遍历一个节点，就将其取出,将每一个节点放在新链表的最前端
		while(cur != null) {
			// 1.先将cur的下一个节点保存起来
			next = cur.next;
			// 2.将cur的下一个节点指向新的链表的最前端(防止这个旧的链表没有指针引用,被jv回收)
			cur.next = reverseHead.next;
			// 3.cur这个节点放在新链表的最前端
			reverseHead.next = cur;
			// 4.cur后移动
			cur = next;
		}
		// 除了循环之后,将旧链表的头指针的下一个节点设置为新链表的第一个有效元素
		head.next = reverseHead.next;
		
	}
	
	/**
	 * 查找单链表中的倒数第k个节点
	 * @param head
	 * @param index   k
	 * @return
	 */
	public static HeroNode findLastIndexNode(HeroNode head, int index) {
		// 判断来链表是否为空
		if(head.next == null) {
			return null;
		}
		// 遍历得到链表的长度(节点的个数)
		int size = getLength(head);
		// 检验index
		if(index < 0 || index > size) {
			return null;
		}
		// 定义一个指针,从第一个有效的元素开始
		HeroNode cur = head.next;
		// 遍历单链表需要找的这个倒数的元素就是正着数的总的有效长度-倒着数的长度
		for (int i = 0; i < size - index; i++) {
			cur = cur.next;
		}
		return cur;
	}
	
	/**
	 * 获取单链表的有效节点的个数
	 * @param head   单链表的头节点
	 * @return
	 */
	public static int getLength(HeroNode head) {
		// 判断链表是否为空
		if(head.next == null) {
			return 0;
		}
		int length = 0;
		// 遍历单链表(从第一个有效的节点开始计数)
		HeroNode cur = head.next;
		while(cur != null) {
			length++;
			cur = cur.next;
		}
		return length;
	}
	
}



// 定义的链表
class SingleLinkedList{
	// 先初始化一个头节点,头节点不动,不存放具体的数据
	private HeroNode head = new HeroNode(0, "", "");
	
	
	// 返回头节点(通过头节点就可以找到这条链表的所有节点)
	public HeroNode getHead() {
		return head;
	}
	
	// 添加节点到链表
	public void add(HeroNode heroNode) {
		//因为head节点不能动，因此我们需要一个辅助遍历 temp
		HeroNode temp = head;
		//遍历链表，找到最后
		while(true) {
			//找到链表的最后
			if(temp.next == null) {//
				break;
			}
			//如果没有找到最后, 将将temp后移
			temp = temp.next;
		}
		//当退出while循环时，temp就指向了链表的最后
		//将最后这个节点的next 指向 新的节点
		temp.next = heroNode;
	}
	
	// 添加节点,按照no这个属性顺序添加
	public void addByOrder(HeroNode heroNode) {
		// 1.准备一个指针
		HeroNode temp = head;
		boolean flag = false;
		while(true) {
			if(temp.next == null) {
				break;
			}
			if(temp.next.no > heroNode.no) {
				break;
			}else if(temp.next.no == heroNode.no){
				flag = true;
				break;
			}
		}
		// 出循环之后,判断当前编号是不是已经存在在我们的链表中
		if(flag) {
			System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.no);
		}else {
			// 将元素插入到链表中,将元素插入到temp的后面
			// 1.将新元素的next指向temp的下一个元素
			heroNode.next = temp.next;
			// 2.将temp的next指向新元素
			temp.next = heroNode;
		}
	}
	
	// 修改节点的信息,根据no编号来修改,即no编号不能修改,修改name和nickName两个数据
	public void update(HeroNode newHeroNode) {
		// 判断是否为空
		if(head.next == null) {
			System.out.println("链表为空~");
			return;
		}
		// 找到需要修改的节点,根据no这个编号
		// 定义一个辅助变量
		HeroNode temp = head.next;
		// 定义一个辅助变量
		boolean flag = false;
		// 遍历链表
		while(true) {
			// 找到最后一个节点
			if(temp == null) {
				break;
			}
			if(temp.no == newHeroNode.no) {
				// 找到这个节点
				flag = true;
				break;
			}
			// 将temp指针下移
			temp = temp.next;
		}
		// 出来这个循环,来判断我们找到的这个节点是不是我们需要找的那个节点
		if(flag) {
			// 将新节点的name和nickName赋值给temp
			temp.name = newHeroNode.name;
			temp.nickname = newHeroNode.nickname;
		}else {
			System.out.printf("没有找到 编号 %d 的节点，不能修改\n", newHeroNode.no);
		}
		
	}
	
	// 删除节点
	// 1.head头节点不能动,我们需要一个辅助节点
	// 2.在比较的时候用no这个属性来进行比较
	public void del(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;
		}
		// 除了循环之后,现在的temp就是我们要删除的节点的上一个节点
		if(flag) {
			temp.next = temp.next.next;
		}else {
			System.out.printf("要删除的 %d 节点不存在\n", no);
		}
	}

	// 遍历链表
	public void list() {
		// 判断链表是否为空
		if(head.next == null) {
			System.out.println("链表为空");
			return;
		}
		HeroNode temp = head.next;
		while(true) {
			if(temp == null) {
				break;
			}
			System.out.println(temp);
			// 将temp后移
			temp = temp.next;
		}
	}
}

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 + "]";
	}
}