【数据结构】栈的链表实现

原创 2015年07月10日 11:27:11
import java.util.EmptyStackException;

public class LinkedStack<E> implements Cloneable
{
	private Node<E> top;
	
	public LinkedStack()
	{
		top = null;
	}
	
	public LinkedStack<E> clone()
	{
		LinkedStack<E> answer;
		try
		{
			answer = (LinkedStack<E>) super.clone();
		} catch (CloneNotSupportedException e)
		{
			throw new RuntimeException("this class does not implement Clonnable.");
		}
		return answer;
	}
	
	public boolean isEmpty()
	{
		return (top == null);
	}
	
	public E peek()
	{
		if (top == null)
		{
			throw new EmptyStackException();
		}
		
		return top.getData();
	}
	
	public E pop()
	{
		E answer;
		
		if (top == null)
		{
			throw new EmptyStackException();
		}
		
		answer = top.getData();
		
		top = top.getLink();
		
		return answer;
	}

	public void push(E item)
	{
		top = new Node<E>(item, top);
	}
	
	public int size()
	{
		return Node.listLength(top);
	}
}


public class Node<E>
{
	private E data;
	private Node<E> link;
	
	public Node(E initialData, Node<E> initialLink)
	{
		data = initialData;
		link = initialLink;
	}
	
	// 修改方法,在这个结点之后添加一个新节点
	public void addNodeAfter(E element)
	{
		Node<E> newNode = new Node<E>(element, link);
		link = newNode;
	}
	
	// 用于从这个结点获取数据
	public E getData()
	{
		return data;
	}
	
	// 存取方法,用于获取指向这个结点之后的节点的引用
	public Node<E> getLink()
	{
		return link;
	}
	
	// 复制一个链表
	public static <E> Node<E> listCopy(Node<E> source)
	{
		Node<E> copyHead;
		Node<E> copyTail;
		
		if (source == null)
		{
			return null;
		}
		
		copyHead = new Node<E>(source.data, null);
		copyTail = copyHead;
		
		while (source.link != null)
		{
			source = source.link;
			copyTail.addNodeAfter(source.data);
			copyTail = copyTail.link;
		}
		return copyHead;
	}
	
	// 复制一个链表,返回这个副本的头结点和尾节点的引用
	public static <E> Node<E>[] listCopyWithTail(Node<E> source)
	{
		Node<E> copyHead;
		Node<E> copyTail;
		
		Node<E>[] answer = (Node<E>[]) new Object[2];
		
		if (source == null)
		{
			return null;
		}
		
		copyHead = new Node<E>(source.data, null);
		copyTail = copyHead;
		
		while (source.link != null)
		{
			source = source.link;
			copyTail.addNodeAfter(source.data);
			copyTail = copyTail.link;
		}
		
		answer[0] = copyHead;
		answer[1] = copyTail;
		return answer;
	}
	
	// 计算链表结点的数量
	public static <E> int listLength(Node<E> head)
	{
		int answer = 0;
		Node<E> cursor = head;
		
		while (cursor != null)
		{
			answer++;
			cursor = cursor.link;
		}
		return answer;
	}
	
	// 复制一个链表的一部分,提供指向新副本的头结点和尾节点的引用
	public static <E> Node<E>[] listPart(Node<E> start, Node<E> end)
	{
		Node<E> copyStart;
		Node<E> copyEnd;
		Node<E> cursor;
		Node<E>[] answer = (Node<E>[]) new Object[2]; 
		
		copyStart = new Node<E>(start.data, null);
		copyEnd = copyStart;
		cursor = start;
		
		while (cursor != null)
		{
			cursor = cursor.link;
			if (cursor != null)
			{
				throw new IllegalArgumentException("END node was not found on the list");
			}
			copyEnd.addNodeAfter(cursor.data);
			copyEnd = copyEnd.link;
		}
		
		answer[0] = copyStart;
		answer[1] = copyEnd;
		
		return answer;
	}
	
	// 在一个链表中查找指定位置的一个节点
	public static <E> Node<E> ListPosition(Node<E> head, int position)
	{ 
		if (position == 0)
		{
			throw new IllegalArgumentException("position is zero.");
		}
		
		Node<E> cursor = head;
		int i;
		for (i = 1; i < position && cursor != null; i++)
		{
			cursor = cursor.link;
		}
		
		return cursor;
	}
	
	// 在链表中搜索特定的数据
	public static <E> Node<E> listSearch(Node<E> head, E target)
	{
		Node<E> cursor;
		
		if (target == null)
		{
			for (cursor = head; cursor != null; cursor = cursor.link)
			{
				if (target == null)
					return cursor;
			}
		} else {
			for (cursor = head; cursor != null; cursor = cursor.link)
			{
				if (cursor.data.equals(target))
				{
					return cursor;
				}
			}
		}
		
		return null;
	}
	
	// 修改方法,用于删除这个结点之后的新节点
	public void removeNodeAfter()
	{
		link = link.link;
	}
	
	// 修改方法,用于设置这个结点的数据
	public void setData (E newdata)
	{
		data = newdata;
	}
	
	// 修改方法,用于设置指向这个结点之后那个结点的引用
	public void setLink(Node<E> newLink)
	{
		link = newLink;
	}
}


数据结构 栈 链表实现 c++ 模板

  • 2010年12月21日 19:47
  • 1KB
  • 下载

数据结构(五)——双链表、链式栈、链式队列 及实现

一、双链表 在单链表的基础上再增加一个指向它前驱的指针,就构成了双链表。 所以双链表有三个变量:数据信息info、前驱指针llink、后继指针rlink。   二、双链表操作和实现...

数据结构之栈的链表实现

栈的链表实现

几种简单的数据结构的C++实现,树,图,链表,环形队列,栈等---环形队列篇

//简单实现,模板类 #include using namespace std; template class Queue { public:     Queue();     ~Queue();...

数据结构示例之用链表实现栈

以下是“使用链表实现栈”的简单示例: 1. 用c语言实现的版本 #include #include struct s_node { int data; struct s_node *next...

数据结构学习——栈的链表实现(程序化)

关于栈的基本概念以及和Catalan数的关系,可以参见我的其他文章 参考资料《数据结构与算法分析——C语言描述》 #include #include /*栈的链表实现*/ typedef...

数据结构的基础-单向链表所构造的栈 c++实现

第一次写博客,也同时在学算法,在这里我将把最近学习的算法写出,尽量生动,以此代表学习的轨迹,也希望能帮助到大家,谢谢! 也希望有专家指出我的错误,以及可优化的地方,感激不尽! 下面,我将刚写的 单...
  • sxy0322
  • sxy0322
  • 2015年06月17日 02:19
  • 358

《数据结构与算法分析》—栈的链表和数组实现(C语言)

/*表头作为栈顶*/ #include #include struct Node { ElementType Element; PtrToNode Next; }; int IsE...

【C++数据结构学习笔记---栈】用链表实现栈

【C++数据结构学习笔记---栈】用链表实现栈 在算法中要用到多个栈操作时,最好用链表作为栈的存储结构。 一个简单的实现例子,初始化26个英文字母。 #include using names...
  • Encal
  • Encal
  • 2013年03月18日 09:25
  • 711

单向链表实现数据结构中的栈

单向链表实现数据结构中的栈/** * 摘要: * (一)实现的是数据结构中的栈 * (二)程序使用的语言是JAVA语言 * (三)实现栈的基本操作有: * 1、插入 ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【数据结构】栈的链表实现
举报原因:
原因补充:

(最多只允许输入30个字)