数据结构 之 链表基础知识点 及配套面试题

最新推荐文章于 2022-09-30 20:08:42 发布
最新推荐文章于 2022-09-30 20:08:42 发布
阅读量520 收藏
点赞数 1
分类专栏： # Java数据结构 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csnz123123/article/details/118893357
版权

在这里插入图片描述

一：单链表

单链表的结点结构 数据域+指针域

结点

  • 对每个数据元素 Ai，除了存储其本身的信息之外
  • 还需存储一个指示其直接后继存放位置的指针。
public class Node<T> {
	public T data;			// 数据域
	public Node<T> next;	// 指针域
	
	// 一个参数的构造方法
	public Node(Node<T> next) {
		super();
		this.next = next;
	}
	// 两个参数的构造方法
	public Node(T data, Node<T> next) {
		super();
		this.data = data;
		this.next = next;
	}
	/**
	 * @return the data
	 */
	public T getData() {
		return data;
	}
	/**
	 * @return the next
	 */
	public Node<T> getNext() {
		return next;
	}
}

单链表

  • 线性表的链式存储结构是用一组任意的存储单元来存放线性表的数据元素
  • 这组存储单元可以是连续的，也可以是不连续的

注意点：

  • 单链表的插入与删除 ,只需修改插入位置之前的结点 和当前插入结点的指针指向
  • 插入与删除，即使插入/删除的数据在最后，也要遍历一遍
//单链表存储结构  头指针+单链表长度
public class LinkList<T> {
	private Node<T> head; 	// 头指针 指向 头结点
	private int length;		// 链表长度
	
	// 空构造器 链表初始化
	public LinkList() {//创建一个空的头结点(存在)
		head = new Node<T>(null); //this.next = null
		length = 0; 
	}
	//获取头指针
	public Node<T> getHead(){
		return this.head;
	}
	
	// 在指定位置添加 结点
	public boolean add(T obj , int pos) {
		//判断pos值是否合法
		if(pos < 1 || pos > length +1) {
			System.out.println("添加操作的pos值不合法");
			return false;
		}
		Node<T> p = head;
		Node<T> q = p.next;
		int count = 1;
		while(count < pos) {
			p = p.next;	
			q = q.next;
			count ++;
		}
		p.next = new Node<T>(obj,q);
		length ++;
		return true;
	}
	
	// 移除 指定位置的结点
	public boolean remove(int pos) {
		//判断链表是否为空
		if(isEmpty()) {
			System.out.println("链表为空，无法 移除元素");
			return false;
		}
		//判断pos值是否合法
		if(pos < 1 || pos > length) {
			System.out.println("移除的pos值不合法");
			return false;
		}
		Node<T> p = head;
		Node<T> q = p.next;
		int count = 1;
		while(count < pos) {
			p = p.next;	
			q = q.next;
			count ++;
		}
		p.next = q.next;
		length --;
		return true;
	}
	
	// 获取 指定位置结点的数据
	public T value(int pos) {
		//判断链表是否为空
		if(isEmpty()) {
			System.out.println("链表为空，无法获取指定位置结点的数据");
			return null;
		}
		//判断pos值是否合法
		if(pos < 1 || pos > length) {
			System.out.println("获取指定位置结点的pos值不合法");
			return null;
		}
		Node<T> p = head;
		int count = 1;
		while(count < pos) {
			p = p.next;	
			count ++;
		}
		return p.next.getData();
	}
	
	//单链表的查找
	public int find(T obj) {
		//判断链表是否为空
		if(isEmpty()) {
			System.out.println("链表为空，无法查找数据");
			return -1;
		}
		int count = 1;
		Node<T> p = head.next;
		while(p != null) {
			if(p.getData().equals(obj)) {
				return count;
			}
			p = p.next;
			count++;
		}
		return -1;
	}
	
	//更新单链表第pos个结点的值
	public boolean modify(T obj,int pos) {
		//判断链表是否为空
		if(isEmpty()) {
			System.out.println("链表为空，无法更新单链表结点的值");
			return false;
		}
		//判断pos值是否合法
		if(pos < 1 || pos > length) {
			System.out.println("更新单链表结点的pos值不合法");
			return false;
		}
		Node<T> p = head.next;
		int count = 1;
		while(count < pos) {
			 p  = p.next;
			 count ++;
		}
		p.data = obj;
		return true;
	}
	
	//判断链表是否为空
	public boolean isEmpty() {
		return length == 0 ? true : false;
	}
	
	//求数据元素个数
	public int getSize() {
		return this.length;
	}
	
	// 清空链表
	public void clear() {
		length = 0;
		this.head.next = null;
	}
	
	// 循环遍历链表元素
	public void nextOrder() {
		//判断链表是否为空
		if(isEmpty()) {
			System.out.println("链表为空，无法获循环遍历链表元素");
			return;
		}
		Node<T> p = head.next;
		System.out.println("链表元素正在打印...");
		while(p != null) {
			System.out.print(p.getData()+"\t");
			p = p.next;
		}
		System.out.println("\n链表元素打印完毕...");
	}
}

单链表测试Demo

package 链表.单链表;

public class LinkListTest {

	public static void main(String[] args) {
		LinkList<Integer> link = new LinkList<>();
		// 添加
		link.add(11, 1);
		link.add(21, 2);
		link.add(31, 3);
		link.add(41, 4);
		link.add(51, 5);
		link.add(61, 6);
//		 移除
		link.remove(3);
//		 获取 指定位置结点的数据
		System.out.println(link.value(4));
//		搜素元素
		System.out.println("元素下标为："+link.find(31));
//		更新单链表第pos个结点的值
		link.modify(66, 3);
		//遍历元素
		link.nextOrder();

	}

}

二：双向链表

双向链表 的结点结构 前指针域 + 数据域 + 后指针域

结点

public class Node<T> {
	T data;				// 数据域
	Node<T> next;		// 后指针
	Node<T> previous;	// 前指针
	
	
	//带 1个参数的构造器 初始化 head
	public Node(Node<T> next) {
		super();
		this.next = next;
		this.previous = null;
	}
	//带三个参数的构造器
	public Node(T data, Node<T> next, Node<T> previous) {
		super();
		this.data = data;
		this.next = next;
		this.previous = previous;
	}
	/**
	 * @return the data
	 */
	public T getData() {
		return data;
	}
	/**
	 * @return the next
	 */
	public Node<T> getNext() {
		return next;
	}
	/**
	 * @return the previous
	 */
	public Node<T> getPrevious() {
		return previous;
	}
}

双向链表

public class DoubleLinkList<T> {
	private Node<T> head;	//头指针
	private int length;		//链表长度
	
	//空构造器 初始化双向链表
	public DoubleLinkList() {
		super();
		this.head = new Node<T>(null);
		this.length = 0;
	}
	
	//在指定位置添加元素
	public boolean add(T data , int pos) {
		//判断pos值是否合法
		if(pos < 1 || pos > length +1) {
			System.out.println("当前要插入的pos值不合法");
			return false;
		}
		int count = 1;
		Node<T> p = head;
		Node<T> q = p.next;
		while(count < pos) {
			p = p.next;
			q = q.next;
			count++;
		}
		if(q != null) {
			p.next = q.previous = new Node<T>(data,q,p);
		}else {
			p.next = new Node<T>(data,q,p);
		}
		length++;
		return true;
	}
	//删除指定位置的元素
	public boolean remove(int pos) {
		//判空
		if(isEmpty()) {
			System.out.println("当前双向链表为空,无法遍历");
			return false;
		}
		//判断pos值合法性
		if(pos < 1 || pos > length) {
			System.out.println("当前要移除的pos值不合法");
			return false;
		}
		int count = 1;
		Node<T> p = head;
		Node<T> q = head.next;
		while(count < pos) {
			p = p.next;
			q = q.next;
			count ++;
		}
		//此时 q就是要删除的元素
		if(q.next != null) { // 如果q不是尾部
			p.next = q.next;
			q.next.previous = p;
		}else {				 //	q是尾部
			p.next = q.next;
		}
		length--;
		return true;
	}
	//修改指定位置的元素
	public boolean modify(T data, int pos) {
		//判空
		if(isEmpty()) {
			System.out.println("当前双向链表为空，无法修改元素");
			return false;
		}
		//判断pos值
		if(pos < 1 || pos > length) {
			System.out.println("当前要修改的pos值不合法");
			return false;
		}
		int count = 1;
		Node<T> q = head.next;
		while(count < pos) {
			q = q.next;
			count ++;
		}
		//当前q就是要修改的那个结点
		q.data = data;
		return true;
	}
	//查找指定元素的位置
	public int findPos(T data) {
		//判空
		if(isEmpty()) {
			System.out.println("当前双向链表为空，无法查找元素");
			return -1;
		}
		int count = 1;
		Node<T> p = head.next;
		while( p != null) {
			if(p.getData().equals(data)) {
				return count;
			}
			count ++;
			p = p.next;
		}
		return -1;
	}
	//查找指定位置的元素
	public T findData(int pos) {
		//判空
		if(isEmpty()) {
			System.out.println("当前双向链表为空，无法查找指定位置的元素");
			return null;
		}
		//判断pos值
		if(pos < 1 || pos > length) {
			System.out.println("当前指定的pos值不合法");
			return null;
		}
		int count =1;
		Node<T>  p = head.next;
		while( count < pos ) {
			p = p.next;
			count++;
		}
		//已经找到目标位置元素 p
		return p.getData();
		
	}
	//判空
	public boolean isEmpty() {
		return length == 0? true:false;
	}
	//获取双向链表长度
	public int getSize() {
		return this.length;
	}
	//循环遍历链表
	public void nextOrder() {
		//判空
		if(isEmpty()) {
			System.out.println("当前双向链表为空,无法遍历");
			return ;
		}
		System.out.println("\n双向链表开始遍历...");
		Node<T> p = head.next;
		while(p!=null) {
			System.out.print(p.getData()+"\t");
			p = p.next;
		}
		System.out.println("\n双向链表遍历结束...");
	}
	//清空双向链表
	public void clear() {
		length = 0;
		head.next = null;
	}
}

双向链表测试Demo

public class DoubleLinkLIstTest {

	public static void main(String[] args) {
		DoubleLinkList<Integer> link = new DoubleLinkList<>();
		//添加
		link.add(111, 1);
		link.add(222, 2);
		link.add(333, 3);
		
//		删除
		link.remove(3);
//		修改
		link.modify(444, 3);
//		查找指定元素的位置
		System.out.println(link.findPos(222));
//		查找指定位置的元素
		System.out.println(link.findData(3));
//		获取双向链表长度
		System.out.println("双向链表的长度为："+link.getSize());
//		清空
		link.clear();
//		遍历输出
		link.nextOrder();
	}

}

三：单向循环链表

循环链表是另一种形式的链表，它的特点是表中最后一个结点的指针域不再为空，而是指向表头结点，整个链表形成一个环。
和单向链表的区别是 最后一个元素不再指向null 而是指向 head
在这里插入图片描述
在这里插入图片描述

单向循环结点

public class SingleLoopNode<T> {
	T data;						//数据域
	SingleLoopNode<T> next; 	//指针域
	
	//单参数构造器
	public SingleLoopNode(SingleLoopNode<T> next) {
		super();
		this.next = next;
	}
	// 双参数构造器
	public SingleLoopNode(T data, SingleLoopNode<T> next) {
		super();
		this.data = data;
		this.next = next;
	}
	/**
	 * @return the data
	 */
	public T getData() {
		return data;
	}
}

单向循环链表

public class SingleLoopLinkList<T> {
	private SingleLoopNode<T> head;	//头指针
	private int length;				//单向循环链表长度

	//初始化链表 head不再指向null 而是他自己
	public SingleLoopLinkList() {	
		super();
		this.head = new SingleLoopNode<T>(head);
		length = 0;
	}
	//在指定位置添加元素
		public boolean add(T data , int pos) {
			//判断pos值是否合法
			if(pos < 1 || pos > length +1) {
				System.out.println("当前要插入的pos值不合法");
				return false;
			}
			int count = 1;
			SingleLoopNode<T> p = head;
			SingleLoopNode<T> q = p.next;
			while(count < pos) {
				p = p.next;
				q = q.next;
				count++;
			}
			if(q == null) {
				p.next = new SingleLoopNode<T>(data,head);
			}else {
				p.next = new SingleLoopNode<T>(data,q);
			}
			length++;
			return true;
		}
		//删除指定位置的元素
		public boolean remove(int pos) {
			//判空
			if(isEmpty()) {
				System.out.println("当前单向循环链表为空,无法遍历");
				return false;
			}
			//判断pos值合法性
			if(pos < 1 || pos > length) {
				System.out.println("当前要移除的pos值不合法");
				return false;
			}
			int count = 1;
			SingleLoopNode<T> p = head;
			SingleLoopNode<T> q = head.next;
			while(count < pos) {
				p = p.next;
				q = q.next;
				count ++;
			}
			//此时 q就是要删除的元素		
			p.next = q.next;
			length--;
			return true;
		}
		//修改指定位置的元素
		public boolean modify(T data, int pos) {
			//判空
			if(isEmpty()) {
				System.out.println("当前单向循环链表为空，无法修改元素");
				return false;
			}
			//判断pos值
			if(pos < 1 || pos > length) {
				System.out.println("当前要修改的pos值不合法");
				return false;
			}
			int count = 1;
			SingleLoopNode<T> q = head.next;
			while(count < pos) {
				q = q.next;
				count ++;
			}
			//当前q就是要修改的那个结点
			q.data = data;
			return true;
		}
		//查找指定元素的位置
		public int findPos(T data) {
			//判空
			if(isEmpty()) {
				System.out.println("当前单向循环链表为空，无法查找元素");
				return -1;
			}
			int count = 1;
			SingleLoopNode<T> p = head.next;
			while( p != head) {
				if(p.getData().equals(data)) {
					return count;
				}
				count ++;
				p = p.next;
			}
			return -1;
		}
		//查找指定位置的元素
		public T findData(int pos) {
			//判空
			if(isEmpty()) {
				System.out.println("当前单向循环链表为空，无法查找指定位置的元素");
				return null;
			}
			//判断pos值
			if(pos < 1 || pos > length) {
				System.out.println("当前指定的pos值不合法");
				return null;
			}
			int count =1;
			SingleLoopNode<T>  p = head.next;
			while( count < pos ) {
				p = p.next;
				count++;
			}
			//已经找到目标位置元素 p
			return p.getData();
			
		}
		//判空
		public boolean isEmpty() {
			return length == 0? true:false;
		}
		//获取单向循环链表长度
		public int getSize() {
			return this.length;
		}
		//循环遍历链表
		public void nextOrder() {
			//判空
			if(isEmpty()) {
				System.out.println("当前单向循环链表为空,无法遍历");
				return ;
			}
			System.out.println("\n单向循环链表开始遍历...");
			SingleLoopNode<T> p = head.next;
			while(p!=head) {
				System.out.print(p.getData()+"\t");
				p = p.next;
			}
			System.out.println("\n单向循环链表遍历结束...");
		}
		//清空单向循环链表
		public void clear() {
			length = 0;
			head.next = null;
		}
	
}

单向循环链表 测试Demo

public class SingleLoopLinkList<T> {
	private SingleLoopNode<T> head;	//头指针
	private int length;				//单向循环链表长度

	//初始化链表 head不再指向null 而是他自己
	public SingleLoopLinkList() {	
		super();
		this.head = new SingleLoopNode<T>(head);
		length = 0;
	}
	//在指定位置添加元素
		public boolean add(T data , int pos) {
			//判断pos值是否合法
			if(pos < 1 || pos > length +1) {
				System.out.println("当前要插入的pos值不合法");
				return false;
			}
			int count = 1;
			SingleLoopNode<T> p = head;
			SingleLoopNode<T> q = p.next;
			while(count < pos) {
				p = p.next;
				q = q.next;
				count++;
			}
			if(q == null) {
				p.next = new SingleLoopNode<T>(data,head);
			}else {
				p.next = new SingleLoopNode<T>(data,q);
			}
			length++;
			return true;
		}
		//删除指定位置的元素
		public boolean remove(int pos) {
			//判空
			if(isEmpty()) {
				System.out.println("当前单向循环链表为空,无法遍历");
				return false;
			}
			//判断pos值合法性
			if(pos < 1 || pos > length) {
				System.out.println("当前要移除的pos值不合法");
				return false;
			}
			int count = 1;
			SingleLoopNode<T> p = head;
			SingleLoopNode<T> q = head.next;
			while(count < pos) {
				p = p.next;
				q = q.next;
				count ++;
			}
			//此时 q就是要删除的元素		
			p.next = q.next;
			length--;
			return true;
		}
		//修改指定位置的元素
		public boolean modify(T data, int pos) {
			//判空
			if(isEmpty()) {
				System.out.println("当前单向循环链表为空，无法修改元素");
				return false;
			}
			//判断pos值
			if(pos < 1 || pos > length) {
				System.out.println("当前要修改的pos值不合法");
				return false;
			}
			int count = 1;
			SingleLoopNode<T> q = head.next;
			while(count < pos) {
				q = q.next;
				count ++;
			}
			//当前q就是要修改的那个结点
			q.data = data;
			return true;
		}
		//查找指定元素的位置
		public int findPos(T data) {
			//判空
			if(isEmpty()) {
				System.out.println("当前单向循环链表为空，无法查找元素");
				return -1;
			}
			int count = 1;
			SingleLoopNode<T> p = head.next;
			while( p != head) {
				if(p.getData().equals(data)) {
					return count;
				}
				count ++;
				p = p.next;
			}
			return -1;
		}
		//查找指定位置的元素
		public T findData(int pos) {
			//判空
			if(isEmpty()) {
				System.out.println("当前单向循环链表为空，无法查找指定位置的元素");
				return null;
			}
			//判断pos值
			if(pos < 1 || pos > length) {
				System.out.println("当前指定的pos值不合法");
				return null;
			}
			int count =1;
			SingleLoopNode<T>  p = head.next;
			while( count < pos ) {
				p = p.next;
				count++;
			}
			//已经找到目标位置元素 p
			return p.getData();
			
		}
		//判空
		public boolean isEmpty() {
			return length == 0? true:false;
		}
		//获取单向循环链表长度
		public int getSize() {
			return this.length;
		}
		//循环遍历链表
		public void nextOrder() {
			//判空
			if(isEmpty()) {
				System.out.println("当前单向循环链表为空,无法遍历");
				return ;
			}
			System.out.println("\n单向循环链表开始遍历...");
			SingleLoopNode<T> p = head.next;
			while(p!=head) {
				System.out.print(p.getData()+"\t");
				p = p.next;
			}
			System.out.println("\n单向循环链表遍历结束...");
		}
		//清空单向循环链表
		public void clear() {
			length = 0;
			head.next = null;
		}
}

四：双向循环链表

在双向链表中，若变量p引用某个结点，则显然有：p.next.prior == p.prior.next = =p

在这里插入图片描述
在这里插入图片描述

双向循环结点

public class DoubleLoopNode<T> {
	T data;						// 数据域
	DoubleLoopNode<T> next;		// 后指针
	DoubleLoopNode<T> previous;	// 前指针
	
	
	//初始化head 重要步骤 先将head的前后指针通通指向自己
	public DoubleLoopNode() {
		super();
		this.data = null;
		this.next = this;
		this.previous = this;
	}
	//带三个参数的构造器
	public DoubleLoopNode(T data, DoubleLoopNode<T> next, DoubleLoopNode<T> previous) {
		super();
		this.data = data;
		this.next = next;
		this.previous = previous;
	}
	/**
	 * @return the data
	 */
	public T getData() {
		return data;
	}
	/**
	 * @return the next
	 */
	public DoubleLoopNode<T> getNext() {
		return next;
	}
	/**
	 * @return the previous
	 */
	public DoubleLoopNode<T> getPrevious() {
		return previous;
	}
}

双向循环链表

public class DoubleLoopLinkList<T> {
	private DoubleLoopNode<T> head;	//头指针
	private int length;		//链表长度
	
	//空构造器 初始化双向循环链表 head 的前后指针指向自己
	public DoubleLoopLinkList() {
		super();
		this.head = new DoubleLoopNode<T>();
		this.length = 0;
	}
	
	//在指定位置添加元素
	public boolean add(T data , int pos) {
		//判断pos值是否合法
		if(pos < 1 || pos > length +1) {
			System.out.println("当前要插入的pos值不合法");
			return false;
		}
		int count = 1;
		DoubleLoopNode<T> p = head;
		DoubleLoopNode<T> q = p.next;
		while(count < pos) {
			p = p.next;
			q = q.next;
			count++;
		}
		if(q != head) {
			p.next = q.previous = new DoubleLoopNode<T>(data,q,p);
		}else {
			p.next = head.previous = new DoubleLoopNode<T>(data,head,p);
		}
		length++;
		return true;
	}
	//删除指定位置的元素
	public boolean remove(int pos) {
		//判空
		if(isEmpty()) {
			System.out.println("当前双向循环链表为空,无法遍历");
			return false;
		}
		//判断pos值合法性
		if(pos < 1 || pos > length) {
			System.out.println("当前要移除的pos值不合法");
			return false;
		}
		int count = 1;
		DoubleLoopNode<T> p = head;
		DoubleLoopNode<T> q = head.next;
		while(count < pos) {
			p = p.next;
			q = q.next;
			count ++;
		}
		//此时 q就是要删除的元素
		if(q.next != head) { // 如果q不是尾部
			p.next = q.next;
			q.next.previous = p;
		}else {				 //	q是尾部
			p.next = head;
			head.previous = p;
		}
		length--;
		return true;
	}
	//修改指定位置的元素
	public boolean modify(T data, int pos) {
		//判空
		if(isEmpty()) {
			System.out.println("当前双向循环链表为空，无法修改元素");
			return false;
		}
		//判断pos值
		if(pos < 1 || pos > length) {
			System.out.println("当前要修改的pos值不合法");
			return false;
		}
		int count = 1;
		DoubleLoopNode<T> q = head.next;
		while(count < pos) {
			q = q.next;
			count ++;
		}
		//当前q就是要修改的那个结点
		q.data = data;
		return true;
	}
	//查找指定元素的位置
	public int findPos(T data) {
		//判空
		if(isEmpty()) {
			System.out.println("当前双向循环链表为空，无法查找元素");
			return -1;
		}
		int count = 1;
		DoubleLoopNode<T> p = head.next;
		while( p != head) {
			if(p.getData().equals(data)) {
				return count;
			}
			count ++;
			p = p.next;
		}
		return -1;
	}
	//查找指定位置的元素
	public T findData(int pos) {
		//判空
		if(isEmpty()) {
			System.out.println("当前双向循环链表为空，无法查找指定位置的元素");
			return null;
		}
		//判断pos值
		if(pos < 1 || pos > length) {
			System.out.println("当前指定的pos值不合法");
			return null;
		}
		int count =1;
		DoubleLoopNode<T>  p = head.next;
		while( count < pos ) {
			p = p.next;
			count++;
		}
		//已经找到目标位置元素 p
		return p.getData();
		
	}
	//判空
	public boolean isEmpty() {
		return length == 0? true:false;
	}
	//获取双向循环链表长度
	public int getSize() {
		return this.length;
	}
	//循环遍历链表
	public void nextOrder() {
		//判空
		if(isEmpty()) {
			System.out.println("当前双向循环链表为空,无法遍历");
			return ;
		}
		System.out.println("\n双向循环链表开始遍历...");
		DoubleLoopNode<T> p = head.next;
		while(p!=head) {
			System.out.print(p.getData()+"\t");
			p = p.next;
		}
		System.out.println("\n双向循环链表遍历结束...");
	}
	//清空双向循环链表
	public void clear() {
		length = 0;
		head.next = head;
		head.previous = head;
	}
}

双向循环链表测试Demo

public class DoubleLinkListTest {
	public static void main(String[] args) {
		DoubleLoopLinkList<Integer> link = new DoubleLoopLinkList<>();
		//添加
		link.add(111, 1);
		link.add(222, 2);
		link.add(333, 3);
		
//		删除
		link.remove(3);
//		修改
		link.modify(444, 3);
//		查找指定元素的位置
		System.out.println(link.findPos(22));
//		查找指定位置的元素
		System.out.println(link.findData(4));
//		获取双向链表长度
		System.out.println("双向链表的长度为："+link.getSize());
//		清空
		link.clear();
//		遍历输出
		link.nextOrder();
	}
}

题目：

在这里插入图片描述

反转单向链表

//反转单向链表
	public void reverseLinkList(LinkList<T> list){
		//判断链表是否为空
		if(list.getSize() == 0) {
			return;
		}
		Node<T> head = list.getHead();
		Node<T> firstNode = head.next;//第一个结点保持不变
		while(firstNode.next != null) {
			list.add(firstNode.next.getData(), 1);
			firstNode.next = firstNode.next.next;
		}
		// 遍历输出
		nextOrder();
	}

在这里插入图片描述

反转双向链表

//反转双向链表
	public void reverseLinkList(DoubleLinkList<T> list) {
		//判空
		if(list.getSize() == 0) {
			return;
		}
		Node<T> head = list.head;
		Node<T> end = head;
		while( end.next != null) {
			end = end.next;
		}
		while(end != null && end != head) {
			System.out.print(end.getData()+"\t");
			end = end.previous;
		}
	}

在这里插入图片描述

在这里插入图片描述

public class printCommonLinkList {
	public static void  printCommon(LinkList<Integer> list1 , LinkList<Integer> list2) {
		Node<Integer> p = list1.getHead().next;
		Node<Integer> q = list2.getHead().next;
		
		while( p!=null && q!=null) {
			if(p.getData().compareTo(q.getData())<0) {
				p = p.next;
			}else if(p.getData().compareTo(q.getData())>0){
				q = q.next;
			}else if(p.getData().compareTo(q.getData())==0){
				System.out.print(q.getData()+"\t");
				p = p.next;
				q = q.next;
			}
		}
	}
	public static void main(String[] args) {
		LinkList<Integer> list1 = new LinkList<Integer>();
		LinkList<Integer> list2 = new LinkList<Integer>();
		list1.add(1, 1);
		list1.add(2, 2);
		list1.add(3, 3);
		list1.add(4, 4);
		list1.add(5, 5);
		
		list2.add(2, 1);
		list2.add(4, 2);
		list2.add(5, 3);
		
		printCommon(list1,list2);
	}
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

//利用栈 空间O(N)
	public static boolean checkByStack(LinkList<Integer> link) {
		//判断链表是否为空 或 长度为1
		if(link.getSize() < 2) {
			return true;
		}
		Stack<Node<Integer>> stack = new Stack<>();
		Node<Integer> p = link.getHead().next;
		Node<Integer> q = link.getHead().next;
		while(p!=null) {
			stack.add(p);
			p = p.next;
		}
		while(!stack.isEmpty()) {
			if(!stack.pop().getData().equals(q.getData())) {
				return false;
			}
			q = q.next;
		}
		return true;
	}
	//利用栈 空间O(N/2)
	public static boolean checkByStackPlus(LinkList<Integer> link) {
		//判断链表是否为空 或 长度为1
		if(link.getSize() < 2) {
			return true;
		}
		//快慢指针优化 只存一半的内容进栈
		Node<Integer> fast = link.getHead().next;	// 一次走两步
		Node<Integer> slow = link.getHead().next;	// 一次走一步
		Node<Integer> q = link.getHead().next;	
		while(fast.next!=null) {
			fast = fast.next;
			if(fast.next != null) {
				fast = fast.next;
				slow = slow.next;
			}
		}
		Stack<Node<Integer>> stack = new Stack<>();
		while(slow.next != null) {
			stack.add(slow.next);
			slow = slow.next;
		}
		while(!stack.isEmpty()) {
			if(!stack.pop().getData().equals(q.getData())) {
				return false;
			}
			q = q.next;
		}
		return true;
		
	}
CSNZのBlog
关注
专栏目录
Java常见数据结构面试题（带答案）
08-29
"Java常见数据结构面试题（带答案）" 以下是对Java常见数据结构面试题的...本篇文章主要介绍了Java常见数据结构面试题，涵盖了栈、队列、链表、线性表、树、算法、数据结构等知识点，希望对广大的程序爱好者有所帮助。
2021数据结构与算法面试题
08-14
数据结构与算法是计算机科学的基础，对于...以上知识点是数据结构与算法面试题中常见的部分，每个主题下都可能有深入的理论讲解和实践题目，对于准备面试的开发者来说，全面掌握这些内容将大大提升在面试中的竞争力。
数据结构 链表 知识点整理
人总是要有梦想的QAQ的博客
04-25 299
静态链表 数据结构包含游标，代表了下一个节点的位置 typedef struct { int data;//数据域 int cur;//游标 }component; 使用稀疏矩阵可以使用三元组存储（xIndex, yIndex, value） 十字链 由于广义表中既可存储原子（不可再分的数据元素），也可以存储子表 ...
【数据结构】 链表知识点整理
weixin_30633507的博客
04-11 142
首先是链表的定义： typedef struct NODE{ 　　struct NODE *next; 　　int data;}Node,*Linklist; 其中 Linklist为指向Node的指针； 接下来是几个常用的函数： 一.链表的初始化： int Linklist_init(Linklist *L){ *L = (Linklist)mallo...
数据结构--知识点4--链表
ANingL的博客
09-01 427
文章目录一、链表的概念1、为什么需要链表2、链表的定义二、单向链表1、单链表的定义2、python中的变量赋值3、单链表在python中的实现1）节点的操作2）单链表的操作3）测试代码是否符合操作 一、链表的概念 1、为什么需要链表 顺序表的构建需要预先指导数据大小来申请连续的存储空间，在进行扩充时还需要进行数据的搬迁，所以使用起来不是很方便 链表结构可以充分利用计算机的内存空间，实现灵活的内存动态管理 链表和顺序表都是线性表 2、链表的定义 链表是一种常见的基础数据结构，是一种线性表，但是不像顺序表一
【数据结构】 链表知识点及实现
weixin_59215611的博客
08-19 409
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 1.链式结构在逻辑上是连续的，物理上不一定连续 2.现实结点一般从堆上申请 3.申请的空间一般按照一定的策略来分配
链表面试题_链表_面试题_cow3cm_数据结构_
09-30
链表是一种基础且重要的数据结构，在计算机科学特别是数据结构领域占据着核心地位。它由一系列节点（也称为元素或记录）组成，每个节点包含数据以及指向下一个节点的引用（在单链表中）或者同时包含向前和向后引用...
22道数据结构算法面试题.zip_22道数据结构算法面试题_算法面试题
09-20
数据结构与算法是计算机科学的基础，对于程序员...以上就是对压缩包中可能包含的22道数据结构算法面试题的一些核心知识点解析。熟练掌握这些内容，不仅可以帮助你在面试中脱颖而出，也能提升你在实际编程工作中的能力。
面试-Java一些常见面试题+题解之数据结构-DataStructure.zip
最新发布
03-03
本资料包"面试-Java一些常见面试题+题解之数据结构-DataStructure.zip"聚焦于Java中的数据结构，旨在帮助求职者更好地准备面试。下面我们将详细探讨其中可能涉及到的一些关键知识点。 1. **数组**： - 数组是最...
《数据结构》——链表相关知识点笔记
JerryHoly13的博客
07-29 457
链表相关知识点笔记 链表：n个节点离散分配，彼此通过指针相连，每个节点只有一个前驱结点和一个后继节点，首节点无前驱，尾节点无后继。 首节点：第一个有效节点 尾节点：最后一个有效节点 头节点：没有存放有效数据；也没有存放数据个数；主要目的是方便链表的操作；节点类型和其他节点的类型一样 头指针：指向头节点的指针变量 尾指针：指向尾节点的指针变量 #include <stdio.h> #include<malloc.h> #include <stdlib.h> typed
【数据结构——链表】链表00——链表知识点总结
蝉之洞
08-01 1204
1.从尾到头输出链表 2.在O(1)时间删除链表节点
数据结构与算法篇初阶3：线性表—链表相关知识点讲解
King_lm_Guard的博客
07-07 891
数据结构与算法初阶篇：链表相关知识
链表基础知识总结
闲适_
02-28 1万+
什么是链表 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点都包括两部分：一是数据域，用来存储元素数值数据，另一个是存储直接后继结点地址的指针域，该指针一般称为next，用来指向下一个结点的位置。由于下一个结点也是链表类型，所以next的指针也要定义为链表类型。 链表中的一些基本定义和特点 头指针：是指向链表中第一个结点的指针 首元结点：是指链表中存储的第一个数据元素的结
[数据结构] 链表(图文超详解讲解)
积跬步以至千里
09-30 3211
根据本文对链表的介绍后大家能对链表有更深的理解相信大家在过后时间能够保持求学的态度,我们一起加油!offer拿到手软!对博主感兴趣可以关注博主,我会继续更新博客,努力完善我的文章内容不会辜负大家的期待!
链表基础知识详解（非常详细简单易懂）
热门推荐
qq_61672347的博客
07-10 17万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
【数据结构】链表超全整理~
vpurple_的博客
08-06 1552
链表超全整理~欢迎来到媛仔的数据结构进阶之路！！
数据结构知识点汇总
Bebr的博客
07-18 13万+
1、用链表表示线性表的优点是（便于插入和删除操作） 2、单链表中，增加头结点的目的是（方便运算的实现） 3、栈和队列的共同特点是（只允许在端点处插入和删除元素） 4、栈通常采用的两种存储结构是（线性存储结构和链表存储结构） 5、队列具有（先进先出）的特征，栈具有（后进先出）的特征。 6、链表（插入和删除不需要移动元素，但是无法随机访问任一元素） 7、循环链表的主要优点是（从表中任一结点...
数据结构--链表概念及常见链表结构
qq_35297945的博客
12-17 1万+
1 链表的概念 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表的结构由以下8种: 1、不带头单向循环结构 2、不带头单向非循环结构 3、不带头双向循环结构 4、不带头双向非循环结构 5、带头单向循环结构 6、带头单向非循环结构 7、带头双向循环结构 8、带头双向非循环结构 存储结构如下： 不带头单向循环结构 不带头单向非循环结构 不带头双向循环结构 不带头双向非循环结构 带头单向循环结构 带头单向非循环结构
链表与数据结构面试题集锦：反转、查找、合并等
本资源主要涵盖了与链表、栈、二叉树相关的经典面试题，帮助求职者准备这些关键知识点。 1. **单链表操作** - **单链表反转**：链表反转是一种常见的操作，可以通过迭代或递归方式实现。迭代方法中，我们需要三个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值