栈、队列、链表

特性: LIFO

public class StackApp {

	public static void main(String[] args) {
		Stack stack = new Stack(10);
		
		stack.push(10);
		stack.push(20);
		stack.push(40);
		stack.push(80);
		stack.push(100);
		
		while (!stack.isEmpty()){
			System.out.println(stack.pop()+" ");
		}
	}
}

class Stack{
	private int maxSize;
	private long[] stackArray;
	private int top;
	
	public Stack(int size){
		stackArray = new long[size];
		maxSize = size;
		top = -1;
	}
	
	public void push(long value){
		stackArray[++top] = value;
	}
	
	public long pop(){
		return stackArray[top--];
	}
	
	public boolean isEmpty(){
		return top == -1;
	}
	
	public boolean isFull(){
		return top == maxSize-1;
	}
	
}


应用场景:

1. 程序运行时的栈空间,用来顺序存储局部变量和参数,每当函数被调用时,局部变量和方法参数会被“pushed into” stack,当方法returns,these locals and parameters are "popped".

2. Expression evaluation and syntax parsing

参考: http://en.wikipedia.org/wiki/Stack_(abstract_data_type)


队列

特点:FIFO

public class QueueApp {

	public static void main(String[] args) {
		Queue queue = new Queue(3);
		queue.insert(43);
		queue.insert(24);
		
		queue.remove();
		
		queue.insert(36);
		queue.insert(48);
		queue.insert(78);
	
		while(!queue.isEmpty()){
			System.out.println(queue.remove());
		}
	}
}

//循环队列
class Queue {
	private int head;
	private int rear;
	private long[] queueArray;
	private int maxSize;
	private int size;//当前队列size
	
	public Queue(int size){
		queueArray = new long[size];
		maxSize = size;
		head = 0;
		rear = 0;
		this.size = 0;
	}
	
	public void insert(long value){
		if (isFull()){
			System.out.println("Queue is already full");
			return;
		}
		queueArray[rear++] = value;
		if (rear == maxSize){
			rear = 0;
		}
		size++;
	}
	
	public long remove(){
		long temp = queueArray[head++];
		if (head == maxSize){
			head = 0;
		}
		size--;
		return temp;
	}
	
	
	public boolean isFull(){
		return size == maxSize;
	}
	
	public boolean isEmpty(){
		return size == 0;
	}
	
	public int size(){
		return size;
	}
}

参考: http://en.wikipedia.org/wiki/Queue_%28abstract_data_type%29


链表

特点:插入、删除需要O(1),查询需要O(N)

基于Java的双向链表:
public class LinkedListApp {

	public static void main(String[] args) {
		DoubleLinkedList<String> list = new DoubleLinkedList<String>();
		list.add("one");
		list.add("two");
		list.add("three");
		
		list.removeFirst();
		
		list.display();
	}

}


class DoubleLinkedList<E>{
	private int size = 0;
	private Entry<E> header = new Entry<E>(null, null, null);
	
	public DoubleLinkedList(){
		header.next = header.previous = header;
	}
	
	public void add(E element){
		addBefore(element, header);
	}
	
	private void addBefore(E element, Entry<E> entry){
		Entry<E> newEntry = new Entry<E>(element, entry, entry.previous);
		newEntry.next.previous = newEntry;
		newEntry.previous.next = newEntry;	
		size++;
	}
	
	public E removeFirst(){
		return remove(header.next);
	}
	
	public E removeLast(){
		return remove(header.previous);
	}
	
	public E remove(Entry<E> e){
		if (e.next == header) {
			throw new RuntimeException("List is empty");
		}
		
		e.previous.next = e.next ;
		e.next.previous = e.previous;
		
		e.next = e.previous = null;
		e.element = null;
		
		size--;
		
		return e.element;
	}
	
	public void display(){
		Entry<E> e = header.next;
		while (e.element != null){
			System.out.println(e.element);
			e = e.next;
		}
	}
	
	private static class Entry<E> {
		private E element;
		private Entry<E> next;
		private Entry<E> previous;
		
		private Entry(E element, Entry<E> next, Entry<E> previous){
			this.element = element;
			this.next = next;
			this.previous = previous;
		}	
	}	
}


### Python中队列链表的实现 #### 的实现 是一种遵循后进先出(LIFO)原则的数据结构。可以通过列表来简单实现的功能。 ```python class Stack: def __init__(self): self.items = [] def push(self, item): """将元素压入""" self.items.append(item) def pop(self): """弹出顶元素""" if not self.is_empty(): return self.items.pop() def is_empty(self): """判断是否为空""" return len(self.items) == 0 def peek(self): """查看顶元素而不移除它""" if not self.is_empty(): return self.items[-1] def size(self): """返回的大小""" return len(self.items) ``` 上述代码展示了如何通过列表实现一个简单的[^1]。 --- #### 队列的实现 队列是一种遵循先进先出(FIFO)原则的数据结构。同样可以利用列表或者更高效的方式如`collections.deque`来实现队列。 ```python from collections import deque class Queue: def __init__(self): self.queue = deque() def enqueue(self, item): """将元素加入队列尾部""" self.queue.append(item) def dequeue(self): """从队列头部移除并返回元素""" if not self.is_empty(): return self.queue.popleft() def is_empty(self): """判断队列是否为空""" return len(self.queue) == 0 def front(self): """获取队列的第一个元素""" if not self.is_empty(): return self.queue[0] def size(self): """返回队列的大小""" return len(self.queue) ``` 这里使用了`deque`作为底层容器,因为它的两端操作效率更高[^4]。 --- #### 双向链表的实现 双向链表是由节点组成的一种线性数据结构,其中每个节点不仅包含自身的值还包含前后两个指针分别指向其前驱和后继节点。 ```python class Node: def __init__(self, data=None): self.data = data self.prev = None self.next = None class DoublyLinkedList: def __init__(self): self.head = None def append(self, data): """在链表末尾添加新节点""" new_node = Node(data) if not self.head: self.head = new_node else: current = self.head while current.next: current = current.next current.next = new_node new_node.prev = current def insert_after(self, target_data, data_to_insert): """在目标节点后面插入新节点""" current = self.head while current and current.data != target_data: current = current.next if current: new_node = Node(data_to_insert) new_node.next = current.next new_node.prev = current if current.next: current.next.prev = new_node current.next = new_node def delete(self, node): """删除指定节点""" if node.prev: node.prev.next = node.next if node.next: node.next.prev = node.prev if node == self.head: self.head = node.next node.prev = None node.next = None def traverse(self): """遍历链表并打印所有节点的值""" result = [] current = self.head while current: result.append(current.data) current = current.next return result ``` 这段代码定义了一个完整的双向链表类及其核心方法,包括新增、删除以及遍历等功能[^2][^3]。 --- #### 总结 以上实现了三种常见的数据结构——队列和双向链表,在实际应用中可以根据需求选择合适的方式来优化性能或简化逻辑处理过程。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值