Java实现双向链表

图解

代码实现

package fun.xinghai.doublelist;

public class DoubleList {

	public static void main(String[] args) {
		System.out.println("测试addLast:");
		DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
		Node node1 = new Node(1, "戈薇");
		Node node2 = new Node(2, "桔梗");
		Node node3 = new Node(3, "珊瑚");
		doubleLinkedList.addLast(node1);
		doubleLinkedList.addLast(node2);
		doubleLinkedList.addLast(node3);
		doubleLinkedList.print();
		System.out.println("===============");
		System.out.println("测试insert:");
		Node node4 = new Node(4, "玲");
		Node node5 = new Node(5, "神乐");
		doubleLinkedList.insert(node4, 0);
		doubleLinkedList.insert(node5, 2);
		doubleLinkedList.print();
		System.out.println("===============");
		System.out.println("测试delect:");
		doubleLinkedList.delect(node4);
		doubleLinkedList.delect(node5);
		doubleLinkedList.print();
		System.out.println("===============");
		System.out.println("测试updata:");
		Node node6 = new Node(3, "神乐");
		doubleLinkedList.updata(node6);
		doubleLinkedList.print();
	}

}

class DoubleLinkedList {
	public Node head = new Node(0, ""); // 双向链表头节点，不存放数据

	//获取头节点的方法
	public Node getHead() {
		return head;
	}
	
	//获取有效节点个数
	public int getSize() {
		int count = 0; //计数器
		//定义一个辅助变量，用来遍历链表
		Node temp = head.next;
		while(true) {
			if(temp == null) { //链表遍历完成，退出
				break;
			}
			count++;
			temp = temp.next;
		}
		return count;
	}
	
	//在链表尾部增加节点
	public void addLast(Node newNode) {
		//定义一个辅助变量，用来遍历链表
		Node temp = head;
		while(true) {
			if(temp.next == null) { //已经找到最后一个节点，退出
				break;
			}
			temp = temp.next; //后移，遍历后一个节点
		}
		temp.next = newNode; //当前最后一个节点的next指向新节点
		newNode.pre = temp; //新节点的pre指向当前最后一个节点
	}
	
	//插入节点，传入待插入节点和待插入位置
	public void insert(Node newNode, int index) {
		int count = -1; //记录当前是第几个节点
		Node temp = head; //定义一个辅助变量，用来找到待插入节点的前一个节点
		if(index < 0 || index > getSize()) {
			System.out.println("插入位置不合理！");
			return;
		}
		while(true) {
			if(count == index - 1) {
				break;
			}
			count++;
			temp = temp.next;
		}
		newNode.next = temp.next;
		newNode.pre = temp;
		if(temp.next != null) {
			temp.next.pre = newNode;
		}
		temp.next = newNode;
	}
	
	
	//删除节点，传入待插入节点
	public void delect(Node delNode) {
		if(head.next == null) {
			System.out.println("链表为空，无法删除！");
			return;
		}
		//定义一个辅助变量，用来寻找待删除节点
		Node temp = head.next;
		boolean flag = false; //标识节点是否找到
		while(true) {
			if(temp.no == delNode.no) { //找到了待删除节点
				flag = true;
				break;
			}
			if(temp == null) { //没有找到待删除节点
				break;
			}
			temp = temp.next;
		}
		if(flag) {
			temp.pre.next = temp.next;
			if(temp.next != null) {
				temp.next.pre = temp.pre;
			}
		}else {
			System.out.println("没有找到待删除的节点！");
		}
	}

	//修改节点，传入需要修改的节点信息
	public void updata(Node newNode) {
		if(head.next == null) {
			System.out.println("链表为空，无法修改！");
			return;
		}
		//定义一个辅助变量，用来寻找待修改节点
		Node temp = head.next;
		boolean flag = false; //标识节点是否找到
		while(true) {
			if(temp.no == newNode.no) { //找到了待修改节点
				flag = true;
				break;
			}
			if(temp.next == null) { //没有找到待修改节点
				break;
			}
			temp = temp.next;
		}
		if(flag) {
			temp.data = newNode.data;
		}else {
			System.out.println("没有找到待修改的节点！");
		}
	}
	
	//打印双向链表
	public void print() {
		if(head.next == null) {
			System.out.println("链表为空！");
			return;
		}
		//定义一个辅助变量，用来遍历链表
		Node temp = head.next;
		while(true) {
			if(temp == null) { //链表遍历完成，退出
				break;
			}
			System.out.println(temp); //输出节点信息
			temp = temp.next; //后移，遍历后一个节点
		}
	}
}

//定义双向链表节点
class Node {
	public int no; // 节点编号
	public String data; // 节点数据
	public Node next; // 指向后一个节点，默认值为null
	public Node pre; // 指向前一个节点，默认值为null

	public Node(int no, String data) {
		this.no = no;
		this.data = data;
	}

	@Override
	public String toString() {
		return "Node [no=" + no + ", data=" + data + "]";
	}
}