Diseño de interfaz de pila
1. Propiedades:
lista de lista privada; —— Utilice una tabla lineal basada en la interfaz de lista para implementar la pila de diseño de clases
2. Métodos de interfaz:
int size (); —— Ver el número de elementos de la pila actual
boolean isEmpty (); —— Determinar si la pila está vacía
public void push (elemento E); —— Empujar la pila, agregar elementos
public E pop (); —— Pop la pila , Eliminar el elemento de cola
public E top (); —— agregar para obtener el elemento superior de la pila
void clear (); —— borrar el elemento de la pila
Una vez completado el diseño, se implementa la codificación del método específico, porque la pila se implementa mediante el uso de la matriz dinámica DynamicArray y la lista vinculada LinkedList , Se llaman todos los métodos encapsulados, por lo que no entraré en detalles aquí
La
pila de clase pública de implementación de codificación extiende DynamicArray {
// Uso de matriz dinámica para realizar la pila
Lista privada lista = new DynamicArray <> ();
// Use la lista vinculada para implementar la pila
// lista de lista privada = new DynamicArray <> ();
/ **
* Ver el número de elementos de la pila
* @return
* /
public int size () { return list.size (); }
/ **
* Determinar si la pila está vacía
* @return
* /
public boolean isEmpty () { return list.isEmpty (); }
/ **
* Insertar en la pila, agregar elementos
* @param element
* /
public void push (E element) { list.add (element); }
/ **
* Abre la pila, elimina el elemento de cola
* /
public E pop () { return list.remove (list.size () - 1); }
/ **
* Obtiene el elemento superior de la pila
* @return
* /
public E top () { return list.get (list.size () - 1); }
/ **
* Borrar elementos de la pila
* /
public void clear () { list.clear (); } } Aplicación de la pila de resumen
1. Doble pila para darse cuenta del avance y retroceso del navegador.
2. Funciones de deshacer y rehacer de software
Concepto de cola
¿Qué es una cola?
Cola: La diferencia con la pila anterior es que la pila solo puede operar en elementos en el extremo superior de la pila, mientras que la cola puede operar en ambos extremos La cola también es una tabla lineal especial.
Enqueue: solo puede agregar elementos de la parte posterior de la cola, generalmente llamado enQueue
Dequeue: los elementos solo se pueden eliminar del frente de la cola, generalmente llamado deQueue
La estructura de la cola
En comparación con las matrices, las listas vinculadas y las pilas, las colas también son estructuras de datos lineales que almacenan el mismo tipo de datos. La única diferencia es que las colas son menos restrictivas que las pilas, pero más grandes que las matrices y las listas vinculadas. Por ejemplo, las colas solo pueden estar en la cola. Agregue datos al final de la cola y elimine elementos al comienzo de la línea. Según esta función, está disponible el llamado "principio primero en entrar, primero en salir, primero en entrar, primero en salir, FIFO". Los otros dos lados están cerrados en el diseño estructural, por lo que la cola excepto El elemento principal y otros elementos de la cola son desconocidos. Por supuesto, el elemento final también es visible, pero generalmente solo agregamos elementos al final de la cola, por lo que este método no se abrirá y no se puede acceder a la cola de forma aleatoria. .
Estructura gráfica de la cola:
Inserte la descripción de la imagen aquí
Diseño de la
cola La cola y el arreglo, la lista vinculada y la pila son estructuras de tabla lineal, por lo que no necesitamos hacer algunas operaciones repetitivas. Es posible usar el arreglo dinámico previamente escrito DynamicArray y la lista vinculada LinkedList. Lo mismo se puede hacer usando pilas. La cola está implementada, pero aquí estamos usando la lista doblemente enlazada Both_LinkedList.
Como se menciona en el artículo "Lista escrita a mano (implementación de Java)", el nodo principal y el nodo final de una lista doblemente enlazada tienen el primer y el último punteros. Esto es muy conveniente para los elementos operativos al principio y al final de la cola. Por supuesto, se utiliza También son posibles matrices dinámicas o listas vinculadas individualmente, pero eliminar elementos de la matriz en la parte superior de la línea hará que los nodos de elementos subsiguientes se muevan hacia adelante, y al agregar elementos al final de la lista vinculada individualmente, la cabeza del puntero debe atravesar el nodo de cola. Ambos aumentarán la complejidad, por lo que es mejor elegir una lista doblemente enlazada
Lo mismo, pero la Cola que escribimos no hereda directamente estas clases, todavía se implementa de manera combinada y dibuja la relación del diagrama de clases
Inserte la descripción de la imagen aquí
Diseño de interfaz de cola
1. Propiedades:
lista de lista privada; —— Utilice una tabla lineal basada en la interfaz de lista para implementar la cola de diseño de clases
2. Método de interfaz:
int size (); —— Ver el número de elementos de la cola actual
boolean isEmpty (); —— Determinar si la cola está vacía
public void enQueue (elemento E); ——
Poner en cola , agregar elementos public E deQueue (); —— Dequeue , Eliminar el elemento de cabecera
public E front (); —— agregar para obtener el elemento de cabecera de la
cola void clear (); —— borrar el elemento de la cola
Una vez completado el diseño, se implementa la codificación del método específico, porque es la cola implementada por la lista doblemente enlazada Both_LinkedList, llame Son todos métodos encapsulados, no entraré en detalles aquí
Implementación de codificación
Cola de implementación de lista doblemente enlazada:
Cola de clase pública {
// Usando el método de encapsulación de lista de doble
enlace para realizar la cola Lista privada lista = new Both_LinkedList <> ();
/ **
* Obtener el número de elementos de la cola
* @return
* /
public int size () { return list.size (); }
/ **
* Determinar si la cola actual está vacía
* @return
* /
public boolean isEmpty () { return list.isEmpty (); }
/ **
* Únete a la cola, agrega elementos desde el final de la cola
* @param element
* /
public void enQueue (E element) { list.add (element); }
/ **
* Retirar de la cola , eliminar elementos del encabezado de la cola
* @return
* /
public E deQueue () { return list.remove (0); }
/ **
* Obtener el elemento de la cabeza del equipo
* @return
* /
public E front () { return list.get (0); }
/ **
* Limpiar los elementos de la cola
* /
public void clear () { list.clear (); } } Cola de implementación de doble pila:
public class QueueByStack {
//定义两个栈，inStack用于队尾入队，outStack用于队头出队
private Stack<E> inStack,outStack;
//使用构造函数初始化
public QueueByStack() {
this.inStack = new Stack<>();
this.outStack = new Stack<>();
}
/**
* 获取队列元素数量
* @return
*/
public int size() {
return inStack.size() + outStack.size();
}
/**
* 判断当前队列是否为空
* @return
*/
public boolean isEmpty() {
return inStack.isEmpty() && outStack.isEmpty();
}
/**
* 入队，从队尾添加元素
* @param element
*/
public void enQueue(E element) {
inStack.push(element);
}
/**
* 出队，从队头添加元素
* @return
*/
public E deQueue() {
checkOutStack();
return outStack.pop();
}
/**
* 获取队头元素
* @return
*/
public E front() {
checkOutStack();
return outStack.top();
}
/**
* 清空栈元素
*/
public void clear() {
inStack.clear();
outStack.clear();
}
/**
* 检查outStack是否为空，如果不为空，等着出队
* 如果为空，且inStack不为空，将inStack中的
* 元素出栈，入栈到outStack，然后准备出队
*/
private void checkOutStack() {
if (outStack.isEmpty()) {
while (!inStack.isEmpty()) {
outStack.push(inStack.pop());
}
}
}
} Concepto de
cola de dos extremos Cola de dos extremos: una cola que se puede agregar y eliminar al principio y al final
Diagrama de estructura:
Inserte la descripción de la imagen aquí
Diseño
No hay diferencia en la relación de implementación entre Deque y Queue, también se basa en la lista doblemente enlazada Both_LinkedList e implementada usando el modo combinado.
Diseño de interfaz de cola bidireccional
1. Propiedades:
lista de lista privada; —— Utilice una tabla lineal basada en la interfaz de lista para implementar la cola de diseño de clases
2. Método de interfaz:
int size (); —— Ver el número de elementos de la cola actuales
boolean isEmpty (); —— Determinar si la cola está vacía
public void enQueueRear (elemento E); —— Enqueue, ingresar a la cola desde el final
public E deQueueRear (); -
Dequeue , desde el final de la cola public void enQueueFront (elemento E); - Enqueue, desde el encabezado de la cola
public E enQueueFront (); - - Dequeue, desde el encabezado de la cola
public E front (); - - Agregar para obtener el elemento principal
public E trasero (); - Agregar para obtener el elemento de cola
void clear (); - Borrar el elemento de cola
Code
public class Deque {
//利用双向链表封装好的方法实现队列
private List<E> list = new Both_LinkedList<>();
/**
* 获取队列元素数量
* @return
*/
public int size() {
return list.size();
}
/**
* 判断当前队列是否为空
* @return
*/
public boolean isEmpty() {
return list.isEmpty();
}
/**
* 入队，从队尾入队
* @param element
*/
public void enQueueRear(E element) {
list.add(element);
}
/**
* 出队，从队尾出队
* @return
*/
public E deQueueRear() {
return list.remove(list.size() - 1);
}
/**
* 入队，从队头入队
* @param element
*/
public void enQueueFront(E element) {
list.add(0, element);
}
/**
* 出队，从对头出队
* @return
*/
public E deQueueFront() {
return list.remove(0);
}
/**
* 获取队头元素
* @return
*/
public E front() {
return list.get(0);
}
/**
* 获取队尾元素
* @return
*/
public E rear() {
return list.get(list.size() - 1);
}
/**
* 清空队列元素
*/
public void clear() {
list.clear();
}
}
Cola
circular
Concepto de cola circular :
Cola circular: la cola después de la implementación y optimización usando una matriz
Estructura gráfica:
Inserte la descripción de la imagen aquí
diseño:
La cola circular también se llama cola circular. Se implementa en función de la matriz de Java. La posición a la que apunta el puntero frontal es la cabeza de la cola. En términos de diseño, después de eliminar un elemento, no será como una matriz. Mueva el elemento hacia adelante y sobrescríbalo, pero establezca el valor vacío. Mover hacia atrás, eliminar el elemento con este mecanismo, la posición después de la eliminación, cuando la posición detrás del puntero frontal está llena, el nuevo elemento puede llenar el espacio vacío que acaba de eliminar, desempeñando el papel de un círculo
Diseño de interfaz de bucle
1. Propiedades:
private int front; —— Puntero de cabecera de la cola de circulación
tamaño privado int; —— Número de elementos de la cola
private E [] elements; —— Use el arreglo de estructura de secuencia para almacenar
el int final estático privado DEFAULT_CAPACITY = 10; —— Valor de inicialización predeterminado del arreglo
2, Método de interfaz:
int size (); —— Ver el número de elementos de la cola actual
boolean isEmpty (); —— Determinar si la cola está vacía
public void enQueue (elemento E); —— Enqueue, ingresar a la cola desde el final de la cola
public E deQueue (); - - Quitar de la cola, eliminar el elemento principal
public E front (); - Agregar para obtener el elemento principal de la
cola void clear (); - Limpiar el elemento de la cola
private void asegurarCapacidad (int capacidad) - Asegurar que haya una capacidad de capacidad, si no es suficiente, expandir la capacidad
private int index (int index); —— función de mapeo de índice, devuelve el subíndice
1 de matriz real , operación de eliminación de cola
Inserte la descripción de la imagen aquí
2. Únete al equipo
3. Reingreso
Inserte la descripción de la imagen aquí
4, nota:
(1) Únete al equipo
Inserte la descripción de la imagen aquí
(2) Únete al equipo
Inserte la descripción de la imagen aquí
(3) Salida
Inserte la descripción de la imagen aquí
(4) Expansión
Inserte la descripción de la imagen aquí
codificación:
CircleQueue de clase pública {
//数组的默认初始化值
private static final int DEFAULT_CAPACITY = 10;
//循环队列队头指针
private int front;
//队列元素数量
private int size;
//使用顺序结构数组存储
private E[] elements;
/**
* 构造函数初始化数组
*/
public CircleQueue() {
elements = (E[]) new Object[DEFAULT_CAPACITY];
}
/**
* 获取队列元素的数量
* @return
*/
public int size(){
return size;
}
/**
* 判断队列是否为空
* @return
*/
public boolean isEmpty(){
return size == 0;
}
/**
* 入队，从队尾添加元素
* @param element
*/
public void enQueue(E element) {
ensureCapacity(size + 1);
//elements[(front + size) % elements.length] = element;
//调用封装函数
elements[index(size)] = element;
size++;
}
/**
* 出队，从队头移除元素
* @return
*/
public E deQueue() {
E element = elements[front];
elements[front] = null;
//front = (front + 1) % elements.length;
//调用封装函数
front = index(1);
size--;
return element;
}
/**
* 获取队头元素
* @return
*/
public E front(){
return elements[front];
}
/**
* 清空队列元素
*/
public void clear() {
for (int i = 0; i < size; i++) {
//elements[(i + front) % elements.length] = null;
//调用封装函数
elements[index(i)] = null;
}
front = 0;
size = 0;
}
/**
* 保证要有capacity的容量,不足则扩容
* @param capacity
*/
private void ensureCapacity(int capacity) {
int oldCapacity = elements.length;
if (oldCapacity >= capacity) return;
// 新容量为旧容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
E[] newElements = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
//newElements[i] = elements[(i + front) % elements.length];
//调用封装函数
newElements[i] = elements[index(i)];
}
elements = newElements;
// 重置front
front = 0;
}
/**
* 索引映射函数，返回真实数组下标
* @param index
* @return
*/
private int index(int index){
return (front + index) % elements.length;
}
@Override
public String toString() {
StringBuilder string = new StringBuilder();
string.append("capcacity=").append(elements.length)
.append(" size=").append(size)
.append(" front=").append(front)
.append(", [");
for (int i = 0; i < elements.length; i++) {
if (i != 0) {
string.append(", ");
}
string.append(elements[i]);
}
string.append("]");
return string.toString();
}
} Concepto
circular deque
:
Cola circular de dos extremos: una cola circular que se puede agregar y eliminar en ambos extremos
Estructura gráfica:
Inserte la descripción de la imagen aquí
De hecho, en estructura, es la misma que la cola circular. No es necesario establecer un último puntero para apuntar al final de la cola, porque usamos la estructura de almacenamiento secuencial de una matriz. De hecho, last = (fuente + tamaño-1)% matriz .length, es solo que hemos ampliado su función en el método
Diseño de interfaz de bucle
1. Propiedades:
private int front; —— Puntero de cabecera de la cola de circulación
tamaño privado int; —— Número de elementos de la cola
private E [] elements; —— Use el arreglo de estructura de secuencia para almacenar
el int final estático privado DEFAULT_CAPACITY = 10; —— Valor de inicialización predeterminado del arreglo
2, Método de interfaz:
int size (); —— Ver el número de elementos de la cola actuales
boolean isEmpty (); —— Determinar si la cola está vacía
public void enQueueRear (elemento E); —— Enqueue, ingrese a la cola desde el final
public E deQueueRear (); - -
Dequeue , desde el final de la cola public void enQueueFront (elemento E); - Enqueue, desde el encabezado de la cola
public E enQueueFront (); - - Dequeue, desde el encabezado de la cola
public E front (); - - Agregar para obtener el elemento principal de la cola
public E posterior (); —— Agregar para obtener el elemento final de la
cola void clear (); —— Borrar el elemento de la cola
private void asegurarCapacity (int capacidad) —— Asegurarse de que haya una capacidad de capacidad, si no es suficiente, expandir el
int privado index (int index); - la función de mapeo de índice devuelve una verdadera
codificación de subíndice de matriz
Como se mencionó anteriormente, la estructura es la misma que la cola circular, por lo que la mayoría de los métodos son los mismos, pero su función se mejora y se ajusta parte de la lógica del método.
Cambios de método:
(1) Agregue public void enQueueFront (elemento E); —— Enqueue, ingrese a la cola desde el encabezado
/ **
-
Únete al equipo
-
@param element
* /
public void enQueueFront (elemento E) {// front apunta a la posición anterior del nodo actual
front = index (-1);
// Suponiendo que el índice virtual, la posición apuntada por front es 0, al agregar elementos al encabezado de la línea, agregue elementos a -1
[frente] = elemento;
tamaño ++ ;
}
(2) Agregar public E deQueueRear (); —— dequeue, dequeue desde el final de la cola
/ **
- Dejar el equipo
- @return
* /
public E deQueueRear () { // Encuentra el índice real del elemento de cola int last = index (size-1); E element = elements [last]; elements [last] = null; size–; return element; } (3) Agregar público E trasero (); —— Agregar para obtener elementos de cola
/ **
- Obtener el elemento de cola
- @return
* /
public E rear () { return elementos [index (tamaño-1)]; } (4) Cambiar el índice int privado (índice int); —— función de mapeo de índice, devuelve el índice de matriz real
/ **
-
Función de mapeo de índice, devuelve el subíndice de matriz real
-
índice @param
-
@return
* /
índice int privado (índice int) { índice + = frente;// Pero cuando el índice real es 0, agregue un elemento al encabezado de la línea y pase -1, que es menor que 0
if (index <0) { index + = elements.length; } return index% elements.length; } Longhua Avenue, No. 1 http : //www.kinghill.cn/LongHuaDaDao1Hao/index.html