算法(第四版)学习笔记之java实现栈和队列(链表实现)

下压堆栈(链表实现):

import java.util.Iterator;

public class LinkedStack<Item> implements Iterable<Item>
{

	public class Node
	{
		Item item;
		Node next;
	}
	private Node frist;
	private int N = 0;

	public boolean isEmpty()
	{
		return N == 0;
	}

	public int size()
	{
		return N;
	}

	public void push(Item item)
	{
		Node oldFrist = frist;
		frist = new Node();
		frist.next = oldFrist;
		frist.item = item;
		N++;
	}

	public Item pop()
	{
		Item item = frist.item;
		frist = frist.next;
		N--;
		return item;
	}

	@Override
	public Iterator<Item> iterator() {
		// TODO Auto-generated method stub
		return new LinkedStackIterator();
	}
	private class LinkedStackIterator implements Iterator<Item>
	{

		private Node current = frist;
		@Override
		public boolean hasNext() {
			// TODO Auto-generated method stub
			return current != null;
		}

		@Override
		public Item next() {
			// TODO Auto-generated method stub
			Item item = current.item;
			current = current.next;
			return item;
		}

		@Override
		public void remove() {
			// TODO Auto-generated method stub

		}

	}

}

先进先出队列(链表实现):

import java.util.Iterator;

public class LinkedQueue<Item> implements Iterable<Item>
{
	public class Node
	{
		Item item;
		Node next;
	}

	private Node frist;
	private Node last;

	private int N = 0;

	public boolean isEmpty()
	{
		return frist == null;
	}
	public int size()
	{
		return N;
	}

	public void enqueue(Item item)
	{
		Node oldLast = last;
		last = new Node();
		last.item = item;
		last.next = null;
		if(isEmpty())
		{
			frist = last;
		}
		else
		{
			oldLast.next = last;
		}
		N++;
	}

	public Item dequeue()
	{
		Item item = frist.item;
		frist = frist.next;
		if(isEmpty())
		{
			last = null;
		}
		N--;
		return item;
	}

	@Override
	public Iterator<Item> iterator() {
		// TODO Auto-generated method stub
		return new LinkedQueueIterator();
	}

	private class LinkedQueueIterator implements Iterator<Item>
	{
		private Node current = frist;

		@Override
		public boolean hasNext() {
			// TODO Auto-generated method stub
			return current != null;
		}

		@Override
		public Item next() {
			// TODO Auto-generated method stub
			Item item = current.item;
			current = current.next;
			return item;
		}

		@Override
		public void remove() {
			// TODO Auto-generated method stub

		}

	}

}

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-11-03 03:25:38

算法(第四版)学习笔记之java实现栈和队列(链表实现)的相关文章

算法(第四版)学习笔记之java实现选择排序

选择排序步骤: 1.找到数组中参与遍历比较的所有元素中的最小元素的下标: 2.将最小元素与数组中参与遍历比较的第一个元素进行交换(如果第一个元素就是最小元素的话,那么也会进行一次交换): 3.若数组中还有需要参与遍历比较的元素,则跳转到步骤1:否则排序结束. 在算法第四版中给出的所有排序均是适用于任意实现了Comparable接口的数据类型,若要将数字作为测试用例,请勿使用基本数据类型,改用Integer等实现了Comparable接口的对象. 选择排序代码如下: /** * * @author

算法(第四版)学习笔记之java实现可以动态调整数组大小的栈

下压(LIFO)栈:可以动态调整数组大小的实现 import java.util.Iterator; public class ResizingArrayStack<Item> implements Iterable<Item> { private int N = 0; private Item[] a = (Item[]) new Object[1]; public boolean isEmpty() { return N == 0; } public int size() {

算法(第四版)学习笔记之java实现快速排序

快速排序是一种分治的排序算法.它将一个数组分成两个子数组,将两部分独立地排序.快速排序和归并排序是互补的,归并排序将两个子数组分别排序,并将有序的子数组归并以将整个数组排序:而快速排序则是当两个子数组有序时整个数组也就自然有序了.在快速排序中,切分的位置取决于数组的内容. 优点: 1.实现简单: 2.适用于各种不同的输入数据且在一般应用中比其他排序算法都要快得多: 3.原地排序: 4.时间复杂度为o(nlgn); 5.内循环比大多数排序算法都要短,比较次数少. 缺点:快速排序算法非常脆弱,在实现

算法(第四版)学习笔记之java实现能够动态调整数组大小的栈

下压(LIFO)栈:能够动态调整数组大小的实现 import java.util.Iterator; public class ResizingArrayStack<Item> implements Iterable<Item> { private int N = 0; private Item[] a = (Item[]) new Object[1]; public boolean isEmpty() { return N == 0; } public int size() {

算法(第四版)学习笔记之java实现堆排序

继上一篇实现基于堆的优先队列后,这次将利用上一次完成的基于堆的能够重复删除最大元素操作的优先队列来实现一种经典而优雅的排序算法,称之为堆排序. 堆排序可分为两个阶段: 1.构建堆:在堆的构建过程中,我们将原始数组重新组织安排进一个堆中: 2.下沉排序:从堆中按递减顺序取出所有元素并得到排序结果 具体的思想在下面的代码中有较为详细的注释: /** * * @author seabear * */ public class HeapSort { /** * 1.构造大根堆:与上一篇基于堆的优先队列相

算法(第四版)学习笔记之java实现归并排序

归并排序思想:将一个数组分成两部分分别排序(使用递归),然后将结果合并起来,即将最后两个有序的数组归并成一个更大的有序数组. 时间复杂度O(n) = NlogN 归并排序最吸引人的性质是它能保证将任意长度为N的数组排序所需时间和NlogN成正比,而缺点便是它所需的额外空间和N成正比. 归并排序又分为自顶向下的排序方式和自底向上的排序方式: 自顶向下的排序方式是利用了分治的思想,将一个大问题分割成若干个等价的子问题进行求解: 自底向上的排序方式是先归并那些微型数组,然后再成对归并得到的子数组. 两

算法(第四版)学习笔记之java实现希尔排序

希尔排序思想:使数组中任意间隔为h的元素都是有序的.希尔排序是插入排序的优化,先对数组局部进行排序,最后再使用插入排序将部分有序的数组排序. 代码如下: /** * * @author seabear * */ public class ShellSort { public static void sort(Comparable[] a) { int N = a.length; int h = 1; while(h < N/2) { h = 4 * h + 1; } while(h >= 1)

算法(第四版)学习笔记之java实现二叉查找树

二叉查找树:是一棵二叉树,其中每个结点都含有一个键以及相关联的一个值且每个结点的键都大于其左子树中的任意结点的键而小于其右子树中的任意结点的键. 二叉查找树的每个方法功能原理都在代码中有详细的解释,下面来看代码: /** * * @author seabear * 二叉查找树 * @param <Key> * @param <Value> */ public class BTS<Key extends Comparable<Key>,Value> { //定

算法第四版学习笔记之快速排序 QuickSort

软件:DrJava 参考书:算法(第四版) 章节:2.3快速排序(以下截图是算法配套视频所讲内容截图) 1:快速排序 2: