单向链表
package com.ywx.link; /** * 单向链表 * @author vashon * */ public class LinkTest { public static void main(String[] args) { Link l=new Link(); l.addNode("A"); l.addNode("B"); l.addNode("C"); l.addNode("D"); l.addNode("E"); System.out.println("==========增加之后的内容=========="); l.printNode(); System.out.println(" 包含D:"+l.contains("D")); System.out.println("==========删除之前的内容=========="); l.deleteNode("A"); System.out.println("==========删除之后的内容=========="); l.printNode(); } } class Link{//链表的完成类 class Node{//保存每个节点 private String data;//节点内容 private Node next;//下一个节点 public Node(String data){ this.data=data; } public void add(Node newNode) {//将节点加入到合适的位置 if(this.next==null){ this.next=newNode; }else{ this.next.add(newNode); } } public void print() {//输出节点的内容 System.out.print(this.data+" "); if(this.next!=null){ this.next.print();//递归调用输出 } } public boolean search(String data){//内部搜索的方法 if(data.equals(this.data)){ return true; }else{ if(this.next!=null){//向下继续判断 return this.next.search(data); }else{ return false; } } } public void delete(Node previous, String data) { if(data.equals(this.data)){//找到了匹配的节点 previous.next=this.next;//空出当前的节点 }else{ if(this.next!=null){ this.next.delete(this, data);//继续查找 } } } } private Node root;//链表中的根节点 public void addNode(String data){//增加节点 Node newNode=new Node(data); if(root==null){ root=newNode; }else{ root.add(newNode); } } public void printNode(){//链表的输出 if(root!=null){ root.print(); } } public boolean contains(String name){//判断元素是否存在 return this.root.search(name); } public void deleteNode(String data){//链表删除节点 if(this.contains(data)){ if(this.root.data.equals(data)){//如果是根节点 this.root=this.root.next;//修改根节点 }else{ this.root.next.delete(root,data);//把下一个节点的前节点和要删除的节点内容一起传入 } } } }
另：
一、JAVA单向链表的操作（增加节点、查找节点、删除节点）
class Link { // 链表类 class Node { // 保存每一个节点，此处为了方便直接定义成内部类 private String data; // 节点的内容 private Node next; // 保存下一个节点 public Node(String data) { // 通过构造方法设置节点内容 this.data = data; } public void add(Node node) { // 增加节点 if (this.next == null) { // 如果下一个节点为空，则把新节点加入到next的位置上 this.next = node; } else { // 如果下一个节点不为空，则继续找next this.next.add(node); } } public void print() { // 打印节点 if (this.next != null) { System.out.print(this.data + "-->"); this.next.print(); } else { System.out.print(this.data + " "); } } public boolean search(String data) { // 内部搜索节点的方法 if (this.data.equals(data)) { return true; } if (this.next != null) { return this.next.search(data); } else { return false; } } public void delete(Node previous, String data) { // 内部删除节点的方法 if (this.data.equals(data)) { previous.next = this.next; } else { if (this.next != null) { this.next.delete(this, data); } } } } private Node root; // 定义头节点 public void addNode(String data) { // 根据内容添加节点 Node newNode = new Node(data); // 要插入的节点 if (this.root == null) { // 没有头节点，则要插入的节点为头节点 this.root = newNode; } else { // 如果有头节点，则调用节点类的方法自动增加 this.root.add(newNode); } } public void print() { // 展示列表的方法 if (root != null) { // 当链表存在节点的时候进行展示 this.root.print(); } } public boolean searchNode(String data) { // 在链表中寻找指定内容的节点 return root.search(data); // 调用内部搜索节点的方法 } public void deleteNode(String data) { // 在链表中删除指定内容的节点 if (root.data.equals(data)) { // 如果是头节点 if (root.next != null) { root = root.next; } else { root = null; } } else { root.next.delete(this.root, data); } } }
测试：
public class TestMain { public static void main(String[] args) { Link l = new Link(); l.addNode("A"); l.addNode("B"); l.addNode("C"); l.addNode("D"); System.out.println("原链表："); l.print(); String searchNode = "B"; System.out.println("查找节点:" + searchNode); String result = l.searchNode(searchNode)?"找到!":"没找到!"; System.out.println("查找结果：" + result); System.out.println("删除节点：" + searchNode); l.deleteNode(searchNode); System.out.println("删除节点后的链表："); l.print(); } }
测试结果如下：
原链表： A-->B-->C-->D 查找节点:B 查找结果：找到! 删除节点：B 删除节点后的链表： A-->C-->D
二、双向链表的简单实现
public class DoubleLink<T> { /** * Node<AnyType>类定义了双向链表中节点的结构，它是一个私有类， 而其属性和构造函数都是公有的，这样，其父类可以直接访问其属性 * 而外部类根本不知道Node类的存在。 * * @author ZHB * * @param <T> * 类型 * @param Data * 是节点中的数据 * @param pre * 指向前一个Node节点 * @param next * 指向后一个Node节点 */ private class Node<T> { public Node<T> pre; public Node<T> next; public T data; public Node(T data, Node<T> pre, Node<T> next) { this.data = data; this.pre = pre; this.next = next; } public Node() { this.data = null; this.pre = null; this.next = null; } } // 下面是DoubleLinkedList类的数据成员和方法 private int theSize; private Node<T> Header; private Node<T> Tail; /* * 构造函数 我们构造了一个带有头、尾节点的双向链表 头节点的Next指向尾节点 为节点的pre指向头节点 链表长度起始为0。 */ public DoubleLink() { theSize = 0; Header = new Node<T>(null, null, null); Tail = new Node<T>(null, Header, null); Header.next = Tail; } public void add(T item) { Node<T> aNode = new Node<T>(item, null, null); Tail.pre.next = aNode; aNode.pre = Tail.pre; aNode.next = Tail; Tail.pre = aNode; theSize++; } public boolean isEmpty() { return (this.theSize == 0); } public int size() { return this.theSize; } public T getInt(int index) { if (index > this.theSize - 1 || index < 0) throw new IndexOutOfBoundsException(); Node<T> current = Header.next; for (int i = 0; i < index; i++) { current = current.next; } return current.data; } public void print() { Node<T> current = Header.next; while (current.next != null) { System.out.println(current.data.toString()); current = current.next; } } public static void main(String[] args) { DoubleLink<String> dLink = new DoubleLink<String>(); dLink.add("zhb"); dLink.add("zzb"); dLink.add("zmy"); dLink.add("zzj"); System.out.println("size : " + dLink.size()); System.out.println("isEmpty? : " + dLink.isEmpty()); System.out.println("3 : " + dLink.getInt(2)); dLink.print(); } }