java中的双向链表

为了使得链表可以找到他的前驱,我们基于单链表设定了双向链表,在next的基础上

加了prio前驱用来指向节点前驱,让我们来了解一下。

初始化

class Entry{
		int data;
		Entry next;
		Entry prio;
		
		public Entry(){
			this.data =-1;
			this.next =null;
			this.prio = null;
		}
		public Entry(int val){
			this.data =val;
			this.next =null;
			this.prio = null;
		}
	}

同样我们需要构造方法

(1)头插

public void insertHead(int val){
		Entry cur = new Entry(val);
		if(head.next!=null){
			cur.next = head.next;
			head.next = cur;
			cur.prio = head ;
			
		}else{
			cur.next.prio = cur;
		}
	}

(2)尾插

public void insertTail(int val){
		Entry cur = new Entry(val);
		Entry entry = this.head;
		while(entry.next!=null){
			entry = entry.next;
		}
		entry.next = cur;
		cur.prio = entry;
	}

(3)删除特定的元素

public void deleteEntry(int val){
		Entry cur = this.head.next;
		while(cur!= null){
			if(cur.data == val){
				cur.prio.next = cur.next;
				if(cur.next!=null){
					cur.next.prio = cur.prio;
				}
			}else{
				cur = cur.next;
			}
		}
		
	}

(4)输出链表

public void show(){
		Entry cur = this.head.next;
		while(cur != null){
			System.out.println("Entry: "+cur.data);
			cur = cur.next;
		}
	}


以上是我总结的简单的方法

(新手入门,如有问题请多多指教)

Java,可以通过自定义类来实现双向链表的实现。 首先,我们需要定义一个双向链表节点类,它包含了前驱节点、后继节点和节点值: ```java public class Node<T> { public Node<T> prev; public Node<T> next; public T value; public Node(Node<T> prev, Node<T> next, T value) { this.prev = prev; this.next = next; this.value = value; } } ``` 然后,我们可以定义一个双向链表类,它包含了头节点和尾节点,以及一些基本的操作方法: ```java public class DoublyLinkedList<T> { private Node<T> head; private Node<T> tail; private int size; public DoublyLinkedList() { head = null; tail = null; size = 0; } public boolean isEmpty() { return size == 0; } public int size() { return size; } public void addFirst(T value) { Node<T> newNode = new Node<>(null, head, value); if (head == null) { tail = newNode; } else { head.prev = newNode; } head = newNode; size++; } public void addLast(T value) { Node<T> newNode = new Node<>(tail, null, value); if (tail == null) { head = newNode; } else { tail.next = newNode; } tail = newNode; size++; } public T removeFirst() { if (head == null) { throw new NoSuchElementException(); } T value = head.value; head = head.next; if (head == null) { tail = null; } else { head.prev = null; } size--; return value; } public T removeLast() { if (tail == null) { throw new NoSuchElementException(); } T value = tail.value; tail = tail.prev; if (tail == null) { head = null; } else { tail.next = null; } size--; return value; } public void insert(int index, T value) { if (index < 0 || index > size) { throw new IndexOutOfBoundsException(); } if (index == 0) { addFirst(value); } else if (index == size) { addLast(value); } else { Node<T> node = getNode(index); Node<T> newNode = new Node<>(node.prev, node, value); node.prev.next = newNode; node.prev = newNode; size++; } } public T remove(int index) { if (index < 0 || index >= size) { throw new IndexOutOfBoundsException(); } if (index == 0) { return removeFirst(); } else if (index == size - 1) { return removeLast(); } else { Node<T> node = getNode(index); node.prev.next = node.next; node.next.prev = node.prev; size--; return node.value; } } public T get(int index) { if (index < 0 || index >= size) { throw new IndexOutOfBoundsException(); } return getNode(index).value; } private Node<T> getNode(int index) { Node<T> node = null; if (index < size / 2) { node = head; for (int i = 0; i < index; i++) { node = node.next; } } else { node = tail; for (int i = size - 1; i > index; i--) { node = node.prev; } } return node; } } ``` 这样,我们就实现了一个双向链表类,可以用来存储任意类型的数据。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值