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

原创 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语言的指针,...
  • u013766436
  • u013766436
  • 2016年05月04日 17:03
  • 1938

c++基本数据结构的类的用法--栈,队列,链表

1.stack类 转自:http://www.169it.com/article/2839007600903800247.html c++ stl栈stack介绍 C++ Stack(堆栈) 是一...
  • xtnc1028
  • xtnc1028
  • 2015年05月28日 16:41
  • 970

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

以下是“使用链表实现栈”的简单示例: 1. 用c语言实现的版本 #include #include struct s_node { int data; struct s_node *next...
  • chinawangfei
  • chinawangfei
  • 2016年10月29日 10:44
  • 905

C语言 实现 链表栈

LinkStack.h 头文件声明如下: #include typedef int DataType; //自定义数据类型,假定为整型 struct Node; ...
  • lutinghuan
  • lutinghuan
  • 2012年04月18日 20:12
  • 11257

用Python实现基本数据结构——栈与队列

转自:http://sjlovechina.blog.163.com/blog/static/123368598201111169211721/ 最近学习《算法导论》,看了栈与队列,觉得用C实现没意...
  • shanliangliuxing
  • shanliangliuxing
  • 2013年10月14日 18:49
  • 1293

数组、链表、堆栈、队列和树

数据结构:是指相互之间存在一种或多种特定关系的数据元素的集合。听起来是不是很抽象,简单理解:数据结构就是描述对象间逻辑关系的学科。比如:队列就是一种先进先出的逻辑结构,栈是一种先进后出的逻辑结构,家谱...
  • wei78008023
  • wei78008023
  • 2016年02月25日 10:04
  • 2962

链表的理解与实现[数据结构]

一、链表的定义n个节点离散分配,节点之间通过指针相连。除了首节点和尾节点之外,每个节点都只有一个前驱结点和一个后继节点。 如下图: 大家有没有发现,链表的结构很像一种交通工具,什么呢? 火车...
  • u011509781
  • u011509781
  • 2016年01月27日 14:02
  • 1971

基于链表的栈实现(c++)

#ifndef _STACK#define _STACK#include //节点类template class Node{ public: T data; Node * next; };//栈...
  • ericming200409
  • ericming200409
  • 2010年04月26日 20:13
  • 1621

栈的链表实现(C语言)

源码文件地址 :http://download.csdn.net/detail/mcu_tian/9530628 由前面:http://blog.csdn.net/mcu_tian/article/d...
  • mcu_tian
  • mcu_tian
  • 2016年05月25日 11:46
  • 1954

C语言实现栈(基于链表)

栈的底层数据结构可以是数组,也可以是链表,用链表实现栈,理论上是无限大的 下面是链栈的实现代码 #include #include typedef int datatype; //Link St...
  • weixin_36040034
  • weixin_36040034
  • 2016年11月26日 23:00
  • 2048
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【数据结构】栈的链表实现
举报原因:
原因补充:

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