数据结构线性结构：栈、单向、双向链表

最新推荐文章于 2022-05-08 12:57:55 发布
最新推荐文章于 2022-05-08 12:57:55 发布
阅读量156 收藏
点赞数
分类专栏： java java学习记录 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44733777/article/details/116522007
版权

线性结构

一、栈结构
1.栈的定义
在这里插入图片描述

2.实现栈结构

import java.util.Arrays;
import java.util.EmptyStackException;

/**

  • 自定义栈容器
  • @author Lhk

*/
public class MyStack {

private Object[] arr;//存放元素的物理结构

private int stackLength =4;//数组的默认长度

private int size;//记录栈容器的元素个数

private int index=-1;//操作数组下标位置的指针






/**
 * 判断栈容器是否为空
 * @return
 */
public boolean empty(){
	//栈为空返回true，否则返回false
	return this.size==0;
}

/**
 * 获取栈顶元素
 */
@SuppressWarnings("unchecked")
public E pop(){
	//如果栈为空，则抛出异常
	if(this.index==-1){
		throw new EmptyStackException();
	}
	//记录元素个数
	this.size--;
	//否则返回栈顶元素
	return (E)this.arr[index--];
}

/**
 * 向栈容器中添加元素
 * @param e
 * @return
 */
public E push(E e){
	//1.初始化数组
	capacity();
	//2.向数组中添加元素
	this.arr[++index]=e;
	//3.记录元素个素
	this.size++;
	return null;
}

/**
 * 完成数组初始化和数组扩容（以1.5倍容量进行扩容）
 * @param args
 */
private void capacity(){
	//数组初始化
	if(this.arr==null){
		this.arr=new Object[this.stackLength];
	}
	
	//数组扩容
	if(this.size-(this.stackLength-1)>=0){
		this.stackLength=this.stackLength+(this.stackLength>>1);
		this.arr=Arrays.copyOf(this.arr, this.stackLength);
	}
}


public static void main(String[] args) {
	MyStack<String> s=new MyStack<>();
	s.push("a");
	s.push("b");
	s.push("c");
	s.push("d");
	s.push("e");
	s.push("f");
	System.out.println(s.size);
	for(int i=0;i<6;i++){
		System.out.println(s.pop());
	}
	System.out.println(s.empty());
}

}

二、链表结构
1.链表结构的定义

  • 什么是链表
    链表结构是由许多节点构成的，每个节点都包含两部分:
    数据部分:保存该节点的实际数据。
    地址部分:保存的是上一个或下一个节点的地址。
  • 链表分类
    单向链表
    双向链表
    双向循环链表
  • 链表的特点
    在这里插入图片描述

2.单向链表结构

  • 单向链表定义
    单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过从头部开始顺序读取。
    在这里插入图片描述
    自定义一个简单的单向链表结构
    i.创建MyList接口
package CustomStructure;
/**
 * 基于链表结构存取元素的方法API定义
 * @param <E>
 */
public interface MyList<E> {

	void add(E element);
	E get(int index);
	int size();
	E remove(int index);
}

ii.创建单向链表类

/**
 * 基于单向链表实现元素存储的容器
 * @author Lhk
 * @param <E>
 *
 */
public class My_Singly_LinkedList<E> implements MyList<E> {

	/**
	 * 向容器中添加元素
	 */
	@Override
	public void add(E element) {
		// TODO Auto-generated method stub
		
	}
	
	/**
	 * 根据元素位置获取元素
	 */
	@Override
	public E get(int index) {
		// TODO Auto-generated method stub
		return null;
	}
	
	/**
	 * 获取元素个素
	 */
	@Override
	public int size() {
		// TODO Auto-generated method stub
		return 0;
	}

	/**
	 * 根据元素位置删除元素
	 */
	@Override
	public E remove(int index) {
		// TODO Auto-generated method stub
		return null;
	}

	public static void main(String[] args) {
		
	}
}

iii.创建结点类

/**
	 * 定义单向链表的结点对象（内部类）
	 */
	class Node<E>{
		private E item;//存储元素
		private Node next;//存储下一个结点对象的地址
		public Node(E item, Node next) {
			super();
			this.item = item;
			this.next = next;
		}
		
	}

iv.实现各个方法

	/**
	 * 向容器中添加元素
	 */
	@Override
	public void add(E element) {
		//创建结点
		Node<E> node=new Node<>(element, null);
		//找到尾结点
		Node tail=getTail();
		//结点挂接
		if(tail==null){
			this.head=node;
		}else{
			tail.next=node;
		}
		//记录元素个数
		this.size++;
	}
	/**
	 * 找尾结点
	 * @return
	 */
	public Node getTail(){
		//先判断头结点是否为空
		if(this.head==null){
			return null;
		}
		//找尾结点
		Node node;
		node=this.head;
		while(true){
		if(node.next==null)break;
		   	node=node.next;//移动指针，指向下一个结点
		}
		return node;
	}

/**
	 * 根据元素位置获取元素
	 */
	@Override
	public E get(int index) {
		//校验index的合法性（0<index<size）
		this.checkIndex(index);
		//根据位置获取指定结点
		Node<E> node=this.getNode(index);
		//将该结点中的元素放回
		return node.item;
	}
	
	/**
	 * 对Index进行校验
	 */
	private void checkIndex(int index){
		if(!(index>=0 && index<this.size)){
			throw new IndexOutOfBoundsException("Index: "+index+"Size: "+size);
		}
	}
	
	/**
	 * 根据位置获取指定结点
	 */
	@SuppressWarnings("unchecked")
	private Node<E> getNode(int index){
		Node<E> node =this.head;
		for(int i=0;i<index;i++){
			node=node.next;
		}
		return node;
		
	}


	/**
	 * 获取元素个素
	 */
	@Override
	public int size() {
		return this.size;
	}

/**
	 * 根据元素位置删除元素
	 */
	@SuppressWarnings("unchecked")
	@Override
	public E remove(int index) {
		//校验index的合法性（0<index<size）
		checkIndex(index);
		//根据位置找到结点对象
		Node<E>  node=this.getNode(index);
		//获取该结点对象的元素
		E item=node.item;
		//将该结点对象从单向链表中移除
			//判断当前删除的结点是否为头结点
		if(this.head==node){
			this.head=node.next;
		}else{
			//从头找到index位置的前一个结点
			Node<E> temp=this.head;
			for(int i=0;i<index-1;i++){
				temp=temp.next;
			}
			temp.next=node.next;
		}
		node.next=null;
		//记录元素个数
		this.size--;
		//将该元素返回
		return item;
	}


	public static void main(String[] args) {
		My_Singly_LinkedList<String> msl=new My_Singly_LinkedList<>();
		msl.add("TheMutents");
		msl.add("qq");
		msl.add("is");
		msl.add("212792772");
		System.out.println(msl.size());
		System.out.println(msl.remove(2));
		for(int i=0;i<msl.size();i++){
			System.out.println(msl.get(i));
		}
	}

完整代码：

/**
 * 基于单向链表实现元素存储的容器
 * @author TheMutents
 * @param <E>
 *
 */
public class My_Singly_LinkedList<E> implements MyList<E> {

	/**
	 * 定义单向链表的结点对象（内部类）
	 */
	@SuppressWarnings("hiding")
	class Node<E>{
		private E item;//存储元素
		@SuppressWarnings("rawtypes")
		private Node next;//存储下一个结点对象的地址
		@SuppressWarnings("rawtypes")
		public Node(E item, Node next) {
			super();
			this.item = item;
			this.next = next;
		}
		
	}
	
	@SuppressWarnings("rawtypes")
	private Node head;//存放链表的头结点
	private int size;//记录元素个数
	
	/**
	 * 向容器中添加元素
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Override
	public void add(E element) {
		//创建结点
		Node<E> node=new Node<>(element, null);
		//找到尾结点
		Node tail=getTail();
		//结点挂接
		if(tail==null){
			this.head=node;
		}else{
			tail.next=node;
		}
		//记录元素个数
		this.size++;
	}
	/**
	 * 找尾结点
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	private Node getTail(){
		//先判断头结点是否为空
		if(this.head==null){
			return null;
		}
		//找尾结点
		Node node=this.head;
		while(true){
		if(node.next==null)break;
		   	node=node.next;//移动指针，指向下一个结点
		}
		return node;
	}
	
	/**
	 * 根据元素位置获取元素
	 */
	@Override
	public E get(int index) {
		//校验index的合法性（0<index<size）
		this.checkIndex(index);
		//根据位置获取指定结点
		Node<E> node=this.getNode(index);
		//将该结点中的元素放回
		return node.item;
	}
	
	/**
	 * 对Index进行校验
	 */
	private void checkIndex(int index){
		if(!(index>=0 && index<this.size)){
			throw new IndexOutOfBoundsException("Index: "+index+"Size: "+size);
		}
	}
	
	/**
	 * 根据位置获取指定结点
	 */
	@SuppressWarnings("unchecked")
	private Node<E> getNode(int index){
		Node<E> node =this.head;
		for(int i=0;i<index;i++){
			node=node.next;
		}
		return node;
		
	}
	
	
	/**
	 * 获取元素个素
	 */
	@Override
	public int size() {
		return this.size;
	}

	/**
	 * 根据元素位置删除元素
	 */
	@SuppressWarnings("unchecked")
	@Override
	public E remove(int index) {
		//校验index的合法性（0<index<size）
		checkIndex(index);
		//根据位置找到结点对象
		Node<E>  node=this.getNode(index);
		//获取该结点对象的元素
		E item=node.item;
		//将该结点对象从单向链表中移除
			//判断当前删除的结点是否为头结点
		if(this.head==node){
			this.head=node.next;
		}else{
			//从头找到index位置的前一个结点
			Node<E> temp=this.head;
			for(int i=0;i<index-1;i++){
				temp=temp.next;
			}
			temp.next=node.next;
		}
		node.next=null;
		//记录元素个数
		this.size--;
		//将该元素返回
		return item;
	}

	public static void main(String[] args) {
		My_Singly_LinkedList<String> msl=new My_Singly_LinkedList<>();
		msl.add("TheMutents");
		msl.add("qq");
		msl.add("is");
		msl.add("212792772");
		System.out.println(msl.size());
		System.out.println(msl.remove(2));
		for(int i=0;i<msl.size();i++){
			System.out.println(msl.get(i));
		}
	}
}

3.双向链表结构

  • 双向链表的定义
    在这里插入图片描述
  • 实现自定义双向链表
    i.创建双向链表类
/**
 * 基于双向链表存储结构存储元素的容器
 * @author Lhk
 *
 * @param <E>
 */
public class My_Doublly_LinkedList<E> implements MyList<E> {

	/**
	 * 向容器中添加元素
	 */
	@Override
	public void add(E element) {
		// TODO Auto-generated method stub
		
	}

	/**
	 * 根据指定位置获取元素
	 */
	@Override
	public E get(int index) {
		// TODO Auto-generated method stub
		return null;
	}

	/**
	 * 获取容器中元素个数
	 */
	@Override
	public int size() {
		// TODO Auto-generated method stub
		return 0;
	}

	/**
	 * 根据指定位置删除元素
	 */
	@Override
	public E remove(int index) {
		// TODO Auto-generated method stub
		return null;
	}

	public static void main(String[] args) {
		
	}
}

ii.创建结点类

class Node<E>{
		private E item;//存储元素
		private Node prve;//记录上一个结点对象
		private Node next;//记录下一个结点对象
		
		public Node(E item, Node prve, Node next) {
			super();
			this.item = item;
			this.prve = prve;
			this.next = next;
		}
		
		
	}

iii.实现各个方法

/**
	 * 向容器中添加元素
	 */
	@Override
	public void add(E element) {
		this.linkedLast(element);
		
	}
	
	/**
	 * 将结点对象添加到双向链表的尾部
	 */
	private void linkedLast(E element){
		//获取尾结点
		Node tail=this.tail;
		//创建一个新结点
		Node<E> node=new Node<>( tail,element, null);
		//将新结点定义成尾结点,如果尾结点为空，则把新结点定义成头结点和尾结点
		this.tail=node;
		if(tail==null){
			this.head=node;
		}else{
			tail.next=node;
		}
		//更新元素个数
		this.size++;
	}


	/**
	 * 根据指定位置获取元素
	 */
	@Override
	public E get(int index) {
		// 对index进行校验
		checkIndex(index);
		//根据位置获取指定结点对象
		Node<E> node=getNode(index);
		//返回指定结点元素
		return node.item;
	}

	/**
	 * 检验index的合法性
	 */
	private void checkIndex(int index){
		if(!(index>=0&&index<this.size)){
			throw new IndexOutOfBoundsException("index: "+index+"size: "+this.size);
		}
	}
	
	/**
	 * 根据位置获取指定结点对象
	 */
	private Node getNode(int index){
		//判断当前位置距离头结点和尾结点那个更近
		if(index<(this.size>>1)){
			Node node=this.head;
			for(int i=0;i<index;i++){
				node=node.next;
			}
			return node;
			}else{
				Node node=this.tail;
				for(int i=this.size-1;i>index;i--){
					node=node.prve;
				}
				return node;
			}
			
	}

/**
	 * 根据指定位置删除元素
	 */
	@Override
	public E remove(int index) {
		//校验index的合法性
		checkIndex(index);
		//获取指定位置结点
		Node<E> node=this.getNode(index);
		//获取当前结点元素值
		E item=node.item;
		//判断当前结点是否为头结点
		if(node.prve==null){
			this.head=node.next;
		}else{
			//完成当前结点的直接前驱与直接后继的挂接
			node.prve.next=node.next;
		}
		//判断当前结点是否为尾结点
		if(node.next==null){
			this.tail=node.prve;
		}else{
			//完成当前结点的直接后继与直接前驱的挂接
			node.next.prve=node.prve;
		}
		//当前结点断掉与它直接后继的连接
		node.next=null;
		//当前结点断掉与它直接前驱的连接
		node.prve=null;
		//元素值置位null，加快回收
		node.item=null;
		//记录元素个数
		this.size--;
		//返回要删除结点的元素值
		return item;
		
	}

/**
	 * 获取容器中元素个数
	 */
	@Override
	public int size() {
		return this.size;
	}


public static void main(String[] args) {
		MyList<String> mlist=new My_Doublly_LinkedList<>();
		mlist.add("a");
		mlist.add("b");
		mlist.add("c");
		mlist.add("d");
		System.out.println(mlist.size());
		for(int i=0;i<mlist.size();i++){
			System.out.println(mlist.get(i));
		}
		System.out.println("删除元素："+mlist.remove(0));
		for(int i=0;i<mlist.size();i++){
			System.out.println(mlist.get(i));
		}
		
	}

	/**
	 * 将结点对象添加到双向链表的头部
	 */
	public void addFirst(E element) {
		this.linkedFirst(element);
		
	}
	
	/**
	 * 将结点对象添加到双向链表的头部
	 */
	private void linkedFirst(E element){
		//获取到头结点对象
		Node head=this.head;
		//实例化一个新的结点对象
		Node<E> node=new Node<>(null, element, head);
		//将新结点定义为头结点
		this.head=node;
		//判断该链表当前是否有结点，如果没有，则新结点既是头结点有事尾结点
		if(head==null){
			this.tail=node;
		}else{
			head.prve=node;
		}
		//记录元素个数
		this.size++;
	}

/**
	 * 双向链表的尾部添加元素(非接口方法)
	 */
	public void addLast(E element) {
		this.linkedLast(element);
		
	}

完整代码：

package CustomStructure;
/**
 * 基于双向链表存储结构存储元素的容器
 * @author TheMutents
 *
 * @param <E>
 */
public class My_Doublly_LinkedList<E> implements MyList<E> {
	/**
	 * 定义双向链表结点对象
	 * @author Lhk
	 *
	 * @param <E>
	 */
	@SuppressWarnings("hiding")
	class Node<E>{
		private E item;//存储元素
		private Node prve;//记录上一个结点对象
		private Node next;//记录下一个结点对象
		
		public Node( Node prve,E item, Node next) {
			super();
			this.item = item;
			this.prve = prve;
			this.next = next;
		}
	} 
	
	private Node head;//记录头结点
	private Node tail;//记录尾结点
	private int size;

	/**
	 * 向容器中添加元素
	 */
	@Override
	public void add(E element) {
		this.linkedLast(element);
		
	}
	
	/**
	 * 双向链表的头部添加元素（非接口方法）
	 */
	public void addFirst(E element) {
		this.linkedFirst(element);
		
	}
	
	/**
	 * 双向链表的尾部添加元素(非接口方法)
	 */
	public void addLast(E element) {
		this.linkedLast(element);
		
	}
	
	/**
	 * 将结点对象添加到双向链表的头部
	 */
	private void linkedFirst(E element){
		//获取到头结点对象
		Node head=this.head;
		//实例化一个新的结点对象
		Node<E> node=new Node<>(null, element, head);
		//将新结点定义为头结点
		this.head=node;
		//判断该链表当前是否有结点，如果没有，则新结点既是头结点有事尾结点
		if(head==null){
			this.tail=node;
		}else{
			head.prve=node;
		}
		//记录元素个数
		this.size++;
	}
	
	
	/**
	 * 将结点对象添加到双向链表的尾部
	 */
	private void linkedLast(E element){
		//获取尾结点
		Node tail=this.tail;
		//创建一个新结点
		Node<E> node=new Node<>( tail,element, null);
		//将新结点定义成尾结点,如果尾结点为空，则把新结点定义成头结点和尾结点
		this.tail=node;
		if(tail==null){
			this.head=node;
		}else{
			tail.next=node;
		}
		//更新元素个数
		this.size++;
	}

	/**
	 * 根据指定位置获取元素
	 */
	@Override
	public E get(int index) {
		// 对index进行校验
		checkIndex(index);
		//根据位置获取指定结点对象
		Node<E> node=getNode(index);
		//返回指定结点元素
		return node.item;
	}

	/**
	 * 检验index的合法性
	 */
	private void checkIndex(int index){
		if(!(index>=0&&index<this.size)){
			throw new IndexOutOfBoundsException("index: "+index+"size: "+this.size);
		}
	}
	
	/**
	 * 根据位置获取指定结点对象
	 */
	private Node getNode(int index){
		//判断当前位置距离头结点和尾结点那个更近
		if(index<(this.size>>1)){
			Node node=this.head;
			for(int i=0;i<index;i++){
				node=node.next;
			}
			return node;
			}else{
				Node node=this.tail;
				for(int i=this.size-1;i>index;i--){
					node=node.prve;
				}
				return node;
			}
			
	}
	
	/**
	 * 获取容器中元素个数
	 */
	@Override
	public int size() {
		return this.size;
	}

	/**
	 * 根据指定位置删除元素
	 */
	@Override
	public E remove(int index) {
		//校验index的合法性
		checkIndex(index);
		//获取指定位置结点
		Node<E> node=this.getNode(index);
		//获取当前结点元素值
		E item=node.item;
		//判断当前结点是否为头结点
		if(node.prve==null){
			this.head=node.next;
		}else{
			//完成当前结点的直接前驱与直接后继的挂接
			node.prve.next=node.next;
		}
		//判断当前结点是否为尾结点
		if(node.next==null){
			this.tail=node.prve;
		}else{
			//完成当前结点的直接后继与直接前驱的挂接
			node.next.prve=node.prve;
		}
		//当前结点断掉与它直接后继的连接
		node.next=null;
		//当前结点断掉与它直接前驱的连接
		node.prve=null;
		//元素值置位null，加快回收
		node.item=null;
		//记录元素个数
		this.size--;
		//返回要删除结点的元素值
		return item;
		
	}

	public static void main(String[] args) {
		MyList<String> mlist=new My_Doublly_LinkedList<>();
		mlist.add("a");
		mlist.add("b");
		mlist.add("c");
		mlist.add("d");
		System.out.println(mlist.size());
		for(int i=0;i<mlist.size();i++){
			System.out.println(mlist.get(i));
		}
		System.out.println("删除元素："+mlist.remove(0));
		for(int i=0;i<mlist.size();i++){
			System.out.println(mlist.get(i));
		}
		
		System.out.println("------测试非接口方法------");
		My_Doublly_LinkedList<String> mdlist=new My_Doublly_LinkedList<>();
		mdlist.add("B");
		mdlist.addFirst("A");
		mdlist.addLast("C");
		mdlist.addFirst("A");
		for(int i=0;i<mlist.size();i++){
			System.out.println(mdlist.get(i));
		}
		
	}
}
The Mutents
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Java数据结构与算法】双向链表
12-21
本文主要讨论的是双向链表，这是一种重要的线性数据结构，它弥补了单向链表的一些缺点。 双向链表是一种链式存储结构，每个节点包含两个指针，一个指向前一个节点（pre指针），另一个指向后一个节点（next指针）。...
数据结构学习（五）双向链表和栈的初学
PayYingJAY的博客
08-07 529
一、双向链表 1.1简介 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 1.2特点 每次在插入或删除某个节点时, 需要处理四个节点的引用, 而不是两个. 实现起来要困难一些。 相对于单向链表, 必然占用内存空间更大一些。 既可以从头遍历到尾, 又可以从尾遍历到头。 简图如下： 从上中可以看到，双向链表中各节点包含以下 3 部分信息：.
数据结构与算法——单向循环列表、栈和队列（附代码）
m0_49963403的博客
11-13 935
数据结构——单向循环列表，栈和队列的介绍，以及python实现
三种栈（单项栈，双向栈，链栈）的创建，与进栈出栈等操作
baobeiduoduo的博客
05-17 1201
一，单结构栈的基本操作 1:定义结构体： typedef int Position; typedef char NL; typedef struct SNode* PtrToSNode; struct SNode{//单结构栈 NL *Data; Position Top;//顶指针 int Maxsize;//栈的最大存储 }; ...
【LeetCode】85.Maximal Rectangle【单向栈&双向扫描】
zhaoqinmuxue的博客
03-21 295
在一个0和1组成的矩阵中寻找面积最大的矩形，初看和上一题思路没什么区别，但其实在实现上可以有另一种思路。原题如下： Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing only 1's and return its area. Example: Input: [ ...
数据结构之栈(用单向链表实现)
weixin_45050132的博客
05-08 878
数据结构之栈(用单向链表实现)
JavaScript数据结构之双向链表定义与使用方法示例
10-19
在JavaScript中，数据结构是构建高效算法的基础，而双向链表是一种重要的线性数据结构。本文将深入探讨双向链表的定义、工作原理以及如何在JavaScript中实现和使用它。 双向链表，顾名思义，是每个节点不仅包含指向...
JS常用的数据结构和算法,链表、栈、队列、排序和查找:octocat
最新发布
04-03
链表分为单向链表和双向链表。在JavaScript中，可以使用对象来表示节点，包含数据属性和指向下一个节点的next属性。 **栈** 栈是一种后进先出（LIFO）的数据结构，类似于现实中的堆叠物品。添加和移除元素都在栈顶...
数据结构单向链表和双向链表
09-05
单向链表是一种线性数据结构，其中每个元素（称为节点）包含两部分：数据和指向下一个节点的引用。与数组不同，链表的元素不需要在内存中连续存放，这使得链表在插入和删除操作上具有一定的灵活性。下面是一些关于...
pp.zip_数据结构链表实验
09-21
链表有多种类型，包括单向链表、双向链表和循环链表，每种都有其独特的特性和应用。 在这个实验中，学生可能会接触到以下几个关键知识点： 1. **链表定义**：理解链表的基本概念，包括头节点、尾节点、节点数据和...
算法练习（一）-- 剑指Ⅱ038-每日温度
nooooooooooooo的博客
12-12 258
算法练习（一）-- 剑指Ⅱ038-每日温度 问题：请根据每日 气温 列表 temperatures ，重新生成一个列表，要求其对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/iIQa4I 题目分析 题目所考数据类型：单向栈 因为我们是从后往前来判断温度上升所隔天数的，所以利用栈后进先出的性质我们可以很好地解决它 因为我们需要找到右边第
算法导论 顺序双向栈——两个栈共享同一存储空间
梦幻DUO的游戏开发之路
09-15 4324
双向栈——两个栈共享同一存储空间1. 什么是双向栈？ 算法导论原题： 10.1-2 Explain how to implement two stacks in one array A[1..n] in such a way that neither stack overflows unless the total number of elements in both stacks
数据结构之栈（人、出、遍历，数组实现）
wangshuo2020的博客
01-20 190
package com.ws.栈.栈; //栈的思路分析： //1.使用数组 //2.定义top，栈顶，初始化-1 //3.入栈：top++ stack[top]=data //4.出栈：int value=stack[top] top-- return value import java.util.Scanner; public class ArrayStackTest { public static void main(String[] args) { Syst...
单向链表实现栈
qq_46487100的博客
10-07 618
单向链表实现栈 首先我们要知道"栈"为何物 , 他是一种储存数据的方法 , 有点类似子弹夹 , 拥有先进后出的特点 . 同时进栈与出栈都只能在一端进行. 1,创建MyStack接口用来定义方法 public interface MyStack { boolean isEmpty(); //判断是否为空 boolean pash(Object x); //入栈 Object pop(); //出栈 Object getTop(); //获得栈顶元素 } 2,创建链表
单链表和栈
亚马逊丛林
11-06 500
一个简单的栈的实现：栈的插入和删除就是链表中第一个元素的删除和插入操作。#include #include typedef struct node {     int data;     node *next; } Lnode; Lnode *Creatlist(); void Printlist(Lnode *head); int IsEmpty(Lnode *L); Lnode *Find(int x,Lnode *L); void Insert(int x,Lnode *P);
[数据结构]栈的实现,双向链表与单向链表
砷碲 - Shendi
07-30 3418
I'm Shendi 下面是使用链表实现的栈(数组的太简单了) 单链表的 /** * 栈. * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a> * @version 1.0 */ public class 栈<E> { private static class Node&l
单链表的基本操作（3）：单链表实现栈
灰太狼
07-29 2328
我们知道，栈是一种“后进先出”的数据结构，对栈的插入和删除操作都是在栈头位置进行的，这与在单链表的表头插入和删除元素的原理类似，因此可以用单向链表实现栈。   单链表实现栈的Java代码： package parking; import java.util.Stack; class Node { Object data; Node next; public Node(Objec...
人员信息管理系统—双向链表实现（C++）
weixin_51324176的博客
05-12 1821
1.1项目需求分析 1)创建一个双向链表，该链表由Node和List类组成，Node类用于创建结点，List类负责整个链表的管理工作,需要定义指定的成员函数，用于实现对人员信息的增删改查。 2) 从List类派生出Set类，定义成员运算符重载函数，重载“+”和“-”，实现两个链表的并差操作，再在Set类中定义求交集的成员函数，实现两个链表的交操作。 3）从List类派生出Stack和Queue，并使其具有自身的操作特性，练习派生类的概念。 1.2总体设计 1)定义结点Node类，用于创建结点，该结点由前驱指
单向循环链表和栈
weixin_49383182的博客
09-07 485
一.单向循环链表的操作 1.单向链表的反转
线性链表详解：数据结构中的单链表与操作
3. 双向链表：每个结点有两个指针域，分别指向其前驱和后继结点，提供了双向遍历的可能性。 线性链表的操作主要包括查找、插入和删除。在顺序存储和链式存储这两种结构上，这些操作的实现和效率有所不同。顺序存储...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

The Mutents

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值