数据结构Java实现----链表

一.单向链表（递归）

MyLinkList类

package List;

// 单向链表
public class MyLinkList {
    private Node root; // 根结点
    private int size; // 结点个数
    private int index; // 脚标
    private Object[] reData; // 保存数据的数组

    // 构造方法
    public MyLinkList() {
        this.root = new Node("head");
        System.out.println("创建了带头指针的链表");
    }

    public MyLinkList(Object data) {
        if (data == null)
            System.out.println("参数错误");
        this.root = new Node(data);
        this.size++;
        System.out.println("创建成功" + data);
    }

    // 是否是空表
    public boolean isEmpty() {
        return this.size == 0;
    }

    // 返回长度
    public int size() {
        return this.size;
    }
    
    // 清空链表
    public void clear(){
        this.root = null;
        this.size = 0;
    }

    // 判断两个链表是否相等
    public boolean equals(Object obj){
        // 常规判断
        if(obj == null)
            return false;
        if(obj == this)
            return true;
        
        // 是MyLinkList类
        if(obj instanceof MyLinkList){
            MyLinkList linkList = (MyLinkList)obj;
            
            // 根结点相同
            if(!this.root.data.equals(linkList.root.data)){
                System.out.println("根节点不相同");
                return false;
            }
            // 长度相同
            if(this.size != linkList.size) {
                System.out.println("长度不同");
                return false;
            }
            
            // 各个结点相同
            if(this.size==1){ // 只含有根结点
                return true;
            }
            return this.root.next.equals(linkList.root.next);
        }
        
        // 不是MyLinkList类
        return false;
            
    }

    // 添加单个数据
    public boolean addData(Object data) {
        if (data == null) {
            System.out.println("参数错误");
            return false;
        }

        // 把data封装成带指针域的结点
        Node node = new Node(data);

        if (this.root.next == null)
            this.root.next = node;
        else
            this.root.next.addNode(node);
        System.out.println("添加成功" + data);
        this.size++;
        return true;
    }

    // 添加多个数据
    public boolean addDatas(Object[] datas) {
        if (datas == null) {
            System.out.println("参数错误");
            return false;
        }

        // 循环添加结点
        for (int index = 0; index < datas.length; ++index) {
            Node data = new Node(datas[index]);// 封装结点
            this.root.addNode(data);
            this.size++;
        }
        return true;
    }

    // 查找数据是否存在
    public boolean contains(Object data) {
        if (data == null || this.isEmpty())
            return false;
        return this.root.containsNode(data);
    }

    // 查找指定位置下的数据
    public Object get(int index) {
        // 参数错误
        if (this.isEmpty() || index < 0 || index > this.size)
            return null;

        if (this.root.data.equals("head")) { // 带头指针
            if (index == 1) // 返回第一个有效数据
                return this.root.next.data;
            else {
                this.index = 0;
                return this.root.next.getNode(index);
            }
        } else { // 不带头指针
            if (index == 1) // 返回第一个有效数据
                return this.root.data;
            else {
                this.index = 1;
                return this.root.next.getNode(index);
            }

        }
    }

    // 删除数据
    public boolean deleteData(Object data) {
        if (data == null || this.isEmpty()) {
            return false;
        }
        // 是根结点
        if (this.root.data.equals(data)) {
            this.root = this.root.next;
            this.size--;
            return true;
        }

        // 不是根节点
        else
            return this.root.deleteNode(data);
    }

    // 打印所有数据
    public void print() {
        if (this.isEmpty())
            System.out.print("空表--------");
        else
            this.root.printNode();
        System.out.println("");
    }

    // 返回数组数据
    public Object[] toArray() {
        if (this.isEmpty())
            return null;

        // 数组保存
        this.index = 0; // 数组下标
        if (this.root.data.equals("head")) // 链表带头指针
            reData = new Object[++this.size];
        else
            reData = new Object[this.size];
        this.root.toArray();
        return reData;
    }

    // 结点类（内部）
    class Node {
        Object data; // 数据域
        Node next; // 指针域

        // 构造方法
        public Node(Object data) {
            this.data = data;
        }

        // 添加结点
        public void addNode(Node node) {
            if (this.next == null)
                this.next = node;
            else
                this.next.addNode(node);
        }

        // 打印结点数据
        public void printNode() {
            System.out.print(this.data + " ");
            if (this.next != null)
                this.next.printNode();
        }

        // 删除结点
        public boolean deleteNode(Object data) {
            if (this.next == null) {
                System.out.println("删除失败" + data);
                return false;
            }
            if (this.next.data.equals(data)) {
                System.out.println("删除成功" + this.next.data);
                MyLinkList.this.size--;
                this.next = this.next.next;
                return true;
            }
            return this.next.deleteNode(data);
        }

        // 返回数组
        public void toArray() {
            MyLinkList.this.reData[MyLinkList.this.index++] = this.data;
            if (this.next != null)
                this.next.toArray();
        }

        // 查找指定结点
        public Object getNode(int index) {
            if (++MyLinkList.this.index == index)
                return this.data;
            return this.next.getNode(index);
        }

        // 查找结点
        public boolean containsNode(Object data) {
            if (this.data == data)
                return true;
            if (this.next != null)
                return this.next.containsNode(data);
            return false;
        }
        
        // 重写equals()
        public boolean equals(Node node){
            // 数据域是否相同
            if(!this.data.equals(node.data)) {
                System.out.println("数据域不同this:"+this.data+" linkList:"+node.data);
                return false;
            }
            // 还有下个结点
            if(this.next!=null)
                return this.next.equals(node.next);
            // 没有下个结点且到目前为止所有结点数据域相同
            return true;
            
        }
    }
}

TestMyLinkList类

package List;

// 单向链表测试
public class TestMyLinkList {

    public static void main(String[] args) {
        // 创建一个链表
        MyLinkList linkList = new MyLinkList(5);

        // 初始化一个链表
        for (int index = 1; index < 10; ++index) {
            int num = (int) (Math.random() * 11);
            linkList.addData(num);
        }

        // 打印链表的所有数据
        linkList.print();

        // 删除结点
        linkList.deleteData(5);
        linkList.print();
        linkList.deleteData(10);
        linkList.print();

        System.out.println("第2个结点数据:" + linkList.get(2));
        // 数组化
        Object[] data = new Object[linkList.size()];
        data = linkList.toArray();
        for (Object index : data)
            System.out.print(index + " ");
        System.out.println("");
        System.out.println("-------------------");
        // 创建一个链表
        MyLinkList linkList2 = new MyLinkList();

        // 待添加数据的数组
        Object[] datas = { 5, "123", 26 };
        linkList2.addDatas(datas);
        System.out.println("包含'5'吗" + linkList2.contains(5));
        linkList2.print();
        System.out.println("----------------------------");
        // 创建一个链表
        MyLinkList linkList1 = new MyLinkList();
        linkList1.addDatas(datas);
        linkList1.print();
        System.out.println("是否相等"+linkList2.equals(linkList1));
    }

}

打印

添加成功5
添加成功1
添加成功6
添加成功6
添加成功6
添加成功1
添加成功5
添加成功2
添加成功10
5 5 1 6 6 6 1 5 2 10 
5 1 6 6 6 1 5 2 10 
删除成功10
5 1 6 6 6 1 5 2 
第2个结点数据:1
5 1 6 6 6 1 5 2 
-------------------
包含'5'吗true
head 5 123 26 
----------------------------
head 5 123 26 
是否相等true

总结：1.避免空指针异常(NullPointException):先判断引用是否为null，后使用。

参考:https://www.cnblogs.com/dolphin0520/p/3811445.html

2018-7-19

二、双向链表(循环、头插法)

DoubleLink类

package List;

// 双向链表（循坏、头插法）
public class DoubleLink {
    private Node root; // 表头
    private int size; // 长度

    // 结点类
    private class Node {
        Object data; // 数据域
        Node prev; // 前趋
        Node next; // 后继

        // 构造方法
        public Node(Object data, Node prev, Node next) {
            this.data = data;
            this.prev = prev;
            this.next = next;
        }

        public Node(Object data) {
            this.data = data;
        }
    }

    // 构造方法
    public DoubleLink() {
        this.root = new Node(null, null, null);
        this.root.prev = this.root.next = this.root;
        this.size = 0;
    }

    // 是否是空表
    public boolean isEmpty() {
        return this.size == 0;
    }

    // 返回长度
    public int size() {
        return this.size;
    }

    // 添加数据
    public boolean addData(Object data) {
        // 空引用
        if (data == null)
            return false;

        this.size++; // 增加长度
        Node node = new Node(data); // 封装结点
        // 添加结点

        if (this.isEmpty()) {
            this.root.next = node;
            this.root.prev = node;

            node.next = this.root;
            node.prev = this.root;
            return true;
        }

        // 头插法
        node.next = this.root.next; // 将新结点的后继指向头结点的后继
        node.prev = this.root; // 将新结点的前驱指向头结点
        this.root.next.prev = node; // 头结点的后继结点的前驱指向新结点
        this.root.next = node; // 头结点的后继节点指向新结点
        return true;
    }

    // 查找第index结点
    private Node getNode(int index) {
        Node oldNode = this.root;
        int foot = 0; // 脚标
        if (index <= this.size / 2) { // 正查找
            System.out.print("正查");
            while (true) {
                if (foot++ == index)
                    break;
                oldNode = oldNode.next;
            }
        } else {
            int LIndex = this.size + 1 - index;
            System.out.print("反查");
            while (true) {
                if (foot++ == LIndex)
                    break;
                oldNode = oldNode.prev;
            }
        }
        System.out.print(oldNode.data);
        return oldNode;
    }

    // 查找结点
    private Node getNode(Object data) {
        Node oldNode = this.root.next;
        while (true) {
            if (oldNode.data.equals(data))
                return oldNode;
            if (oldNode.next.data == null)
                return null;
            oldNode = oldNode.next;
        }

    }

    // 删除结点
    private void removeNode(Node node) {
        node.next.prev = node.prev; // 结点的后继结点的前驱指向结点的前驱
        node.prev.next = node.next; // 结点的前驱结点的后继指向结点的后继
        node = null;
    }

    // 前插法
    private boolean addNode(Node oldNode, Node newNode) {
        oldNode.prev.next = newNode;
        newNode.prev = oldNode.prev;
        oldNode.prev = newNode;
        newNode.next = oldNode;
        return true;
    }

    // 在index结点前插入新结点
    public boolean addData(Object data, int index) {
        if (data == null)
            return false;
        if (index <= 0 || index > this.size)
            return false;

        Node newNode = new Node(data); // 封装结点

        // 查找结点
        Node oldNode = getNode(index);
        this.size++; // 增加长度
        // 更改指针域
        return addNode(oldNode, newNode);
    }

    // 得到第index个结点的数据
    public Object get(int index) {
        if (this.isEmpty())
            return null;
        if (index <= 0 || index > this.size)
            return null;

        // 查找结点
        return getNode(index).data;
    }

    // 查找数据是否存在
    public boolean contains(Object data) {
        if (data == null)
            return false;
        if (this.isEmpty())
            return false;

        // 查找结点
        if (getNode(data) == null)
            return false;
        else
            return true;
    }

    // 删除指定数据
    public boolean remove(Object data) {
        if (data == null)
            return false;
        if (this.isEmpty())
            return false;

        // 查找结点
        Node node = getNode(data);
        if (node == null)
            return false;

        // 删除结点
        removeNode(node);
        this.size--; // 长度减一
        return true;
    }

    // 删除第index个结点
    public boolean removeIndex(int index) {
        if (this.isEmpty())
            return false;
        if (index <= 0 || index > this.size)
            return false;

        // 查找结点
        Node node = getNode(index);
        // 删除结点
        removeNode(node);
        this.size--; // 长度减一
        return true;
    }

    // equals()
    public boolean equals(Object obj) {
        if (obj == null)
            return false;

        // 是DoubleLink类
        if (obj instanceof DoubleLink) {
            // 对象下转型为DoubleLink类
            DoubleLink link = (DoubleLink) obj;

            // 比较长度
            if (this.size != link.size)
                return false;

            Node thisNode = this.root.next;
            Node linkNode = link.root.next;
            // 比较每个结点的后继的数据域是否相同
            while (true) {
                if (thisNode.data == null) // 只有头结点数据域为空
                    break;

                if (!thisNode.data.equals(linkNode.data)) // 结点数据域不相同
                    return false;

                thisNode = thisNode.next;
                linkNode = linkNode.next;
            }
        }
        return true;
    }

    // 获得所有数据
    public Object[] toArray() {
        if (isEmpty())
            return null;

        Object[] datas = new Object[this.size];
        int index = 0; // 数组脚标
        Node node = this.root.prev; // 当前结点
        while (true) {
            if (node.data == null) // 只有头结点数据域为空
                break;
            datas[index++] = node.data;
            node = node.prev;
        }

        return datas;
    }

    // 打印信息
    public void print() {
        if (isEmpty())
            System.out.println("空表");

        else {
            Node node = this.root.next;
            while (true) {
                if (node.data == null)
                    break;
                System.out.print(node.data + " ");
                node = node.next;
            }
            System.out.println();
        }
    }

}

TestDoubleLink类

package List;

// 双向链表测试类
public class TestDoubleLink {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        // 初始化一个双向链表
        DoubleLink link1 = new DoubleLink();
        link1.print();
        
        // 添加数据
        System.out.println("头插法添加10 5 12 null");
        System.out.print("添加结果:"+link1.addData(10)+" ");
        System.out.print(link1.addData(5)+" ");
        System.out.print(link1.addData(12)+" ");
        System.out.println(link1.addData(null));
        link1.print();
        
        // 在指定位置前插入数据
        System.out.println("
在第2为前插入一个40，在第4位前插入一个50");
        System.out.println("插入结果："+link1.addData(40, 2)+"  "+link1.addData(50,4));
        link1.print();
        
        // 检查是否指定数据
        System.out.println("
检查是否含有数据:50 30");
        System.out.println("检查结果:"+link1.contains(50)+"  "+link1.contains(30));
        link1.print();
        
        // 删除指定数据
        System.out.println("
删除指定数据:50 0");
        System.out.println("删除结果:"+link1.remove(50)+" "+link1.remove(0));
        link1.print();
        
        // 删除指定位置上的数据
        System.out.println("
删除指定位置上的数据:第3位 第10位");
        System.out.println("删除结果:"+link1.removeIndex(3)+" "+link1.removeIndex(10));
        link1.print();
        
        
        // 比较两个链表是否相同
        DoubleLink link2 = new DoubleLink();
        DoubleLink link3 = new DoubleLink();
        link2.addData(10);
        link2.addData(40);
        link2.addData(12);
        link3.addData(12);
        link3.addData(40);
        link3.addData(10);
        System.out.println("
比较两个链表是否相同");
        System.out.print("link1:");
        link1.print();
        System.out.print("link2:");
        link2.print();
        System.out.print("link3:");
        link3.print();
        System.out.println("link1和link2： "+link1.equals(link2)+"
link1和link3："+link1.equals(link3)+"
link1和null："+link1.equals(null));

    }

}

打印

空表
头插法添加10 5 12 null
添加结果:true true true false
12 5 10 

在第2为前插入一个40，在第4位前插入一个50
反查反查插入结果：true  true
12 40 5 50 10 

检查是否含有数据:50 30
检查结果:true  false
12 40 5 50 10 

删除指定数据:50 0
删除结果:true false
12 40 5 10 

删除指定位置上的数据:第3位 第10位
反查删除结果:true false
12 40 10 

比较两个链表是否相同
link1:12 40 10 
link2:12 40 10 
link3:10 40 12 
link1和link2： true
link1和link3：false
link1和null：false

总结:1.避免查找错误：先执行查找函数，再改变链表长度。

参考:https://www.cnblogs.com/skywang12345/p/3561803.html

2018-7-20