java实现数据结构之单向链表

数据结构是编程语言的基础学科之一，这门学科还是蛮重要的，如果掌握数据结构这门学科，以后可以轻松的读懂一些底层的代码。在java语言中集合这块，相信大家都经常听见链表这种数据的结构，开发中我们只是使用这种java封装好的链表这种数据结构，但是相信大多数程序员并不太懂链表的实现。那么下边我们可以使用java面向对象的这种思想简单的额实现以下链表。

链表简介

链表有多个节点组成，每个节点中都有存放的数据和下一个接点的地址，通过这些节点就组成了单项的链表。链表的第一个节点称之为首节点，最后一个节点为尾节点，为节点指向下一个节点地址这个属性为空。

链表的优缺点

和数组相比数组更容易进行查询操作，因为数组每个元素都有索引，但是不方便插入删除操作，进行插入删除操作后。后边的元素的位置都要前移或后移。链表比较方便删除，插入操作，查询比较慢因为查询的话还要从头结点开始遍历找到到这个节点

单项链表的结构图

                       

单项链表的节点数据类

/**
 * 单项链表的节点类
 */
public class ListNode {
    private int data;//节点中存放的数据
    private ListNode next;//指向下一个节点

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public ListNode getNext() {
        return next;
    }

    public void setNext(ListNode next) {
        this.next = next;
    }
}

链表数据类

该数据了类中包含了一些常用方法，该类仅作为参考其实还有可以添加链表的尾节点属性和大小属性。

/**
 * 单项链表结构
 */
class LinkList{
    //头结点
    ListNode head = null;
    //单项链表的大小
    public int size(){
        if (head == null){
            return 0;
        }
        int size = 1;
        ListNode content = head;
        while (content.getNext() != null){
            size ++;
            content = content.getNext();
        }
        return size;
    }
    //通过位置添加节点
    public void addListNode(ListNode node , int option){
        if (head == null){
            head = node;
        }else if(option < 0 || option > this.size()){
            System.out.print("输入的位置不正确");
        }else if(option == 0){
            addListNodeFromHead(node);
        }else if (option == size()){
            addListNodeFormTail(node);
        }else{
            ListNode content = head;
            int count = 0;
            //循环得到传入位置的节点
            while (count < option-2){
                content = content.getNext();
                count++;
            }
            ListNode next = content.getNext();
            //先清空next
            if(node.getNext() != null){
                node.setNext(null);
            }
            node.setNext(next);
            content.setNext(node);

        }
    }
    //从头添加节点
    public void addListNodeFromHead(ListNode node){
        ListNode content = head;
        head = node;
        head.setNext(content);
    }
    //从尾部添加节点
    public void addListNodeFormTail(ListNode node){
        if (head == null){
            head = node;
            return;
        }
        ListNode content = head;
        int count = 0;
        int size = size();
        //循环得到尾节点
        while (count < size-1){
            content = content.getNext();
            count++;
        }
        content.setNext(node);
    }
    //清空单项链表
    public void clear(){
        ListNode itor = head;
        while(itor.getNext() != null){
            head = itor;
            itor = itor.getNext();
            //将各个链接断开
            head.setNext(null);
            head = null;
        }
    }
    //头部删除
    public void delFromHead(){
        ListNode next = head.getNext();
        head.setNext(null);
        head = next;
    }
    //尾部删除
    public  void delFromTail(){
        int size = size();
        int count = 0;
        ListNode content = head;
        while(count < size-2){
            content = content.getNext();
            count++;
        }
        content.setNext(null);
    }
    //某个位置进行删除
    public void delFromIndex(int index){
        if (head == null){
            System.out.println("该链表为空不能进行此操作");
        }else if(index <0 || index >size()){
            System.out.println("不存在该位置");
        }else if(index == 0){
            delFromHead();
        }else if (index == size()){
            delFromTail();
        }else {
            int count = 0;
            ListNode provid = head;
            while(count < index-2){
                provid = provid.getNext();
                count++;
            }
            ListNode del = provid.getNext();
            ListNode delNext = del.getNext();
            del.setNext(null);
            provid.setNext(delNext);
        }
    }
    //修改节点的数据
    public void update(int index , int data){
        //循环遍历到该节点、
        int count = 0;
        ListNode content = head;
        while(count < index-1){
            content = content.getNext();
            count++;
        }
        content.setData(data);
    }
    //根据节点的data删除节点
    public void delBydata(int data){
        ListNode provide = head;
        int count = 0;
        //等于两个节点的时候有点特殊
        if (size() == 2){
            if (head.getData() == data){
                delFromHead();
            }else {
                delFromTail();
            }
        }
        while (count < size()-2){
            provide = provide.getNext();
            ListNode del = provide.getNext();
            ListNode delNext = del.getNext();
            if (del.getData() == data){
                del.setNext(null);
                provide.setNext(delNext);
            }
            count++;
        }
    }
    // 根据位置查找节点数据
    public int getDataByIndex(int index){
        //遍历节点
        ListNode content = head;
        int count = 0;
        while (count < index-1){
            content = content.getNext();
            count++;
        }
        return content.getData();
    }
    // 根据数据判断是否包含该节点
    public boolean isCludeNode(int data){
        //遍历节点
        ListNode content = head;
        int count = 0;
        while (count < size()-1){
            content = content.getNext();
            if (content.getData() == data){
                return true;
            }
            count++;
        }
        return false;
    }
    //新值替换旧值
    public int replaceData(int index , int data){
        //遍历节点
        ListNode content = head;
        int count = 0;
        int old = 0;
        while (count < index-1){
            content = content.getNext();
            old = content.getData();
            content.setData(data);
            count++;
        }
        return old;
    }
    //链表中是否包含此元素
    public boolean iscludeData(int data){
        ListNode content = head;
        while(content .getNext() != null){
            content=content.getNext();
            if (content.getData() == data){
                return true;
            }
        }
        return false;
    }
    //判断链表是否为空
    public boolean isEmpty(){
        if (size() == 0){
            return true;
        }else {
            return false;
        }
    }
    //遍历所有的节点信息
    public void showAllNode(){
        ListNode content = head;
        while(content .getNext() != null){
            content=content.getNext();
            System.out.println(content.getData()+" ");
        }
    }
}

测试类

链表的内容等可以通过debug进行测试更容易理解

class Demo{
    public static void main(String[] args) {
        ListNode node1 = new ListNode();
        node1.setData(1);
        ListNode node2 = new ListNode();
        node2.setData(2);
        ListNode node3 = new ListNode();
        node3.setData(3);
        ListNode node4 = new ListNode();
        node4.setData(4);
        LinkList list = new LinkList();
        //测试链表是否为空
        System.out.println(list.isEmpty());
        //测试从头部添加
        list.addListNodeFromHead(node1);
        list.addListNodeFromHead(node2);
        list.addListNodeFromHead(node3);
        System.out.println(list.size());
        //测试链表是否为空
        System.out.println(list.isEmpty());
        //测试遍历链表的方法
        list.showAllNode();
        //测试链表中是否包含此元素
        Boolean boo = list.iscludeData(2);
        System.out.println(boo);
        //测试清空的方法
        list.clear();
        System.out.println(list.size());
        //测试从尾部添加的方法
        list.addListNodeFormTail(node1);
        list.addListNodeFormTail(node2);
        list.addListNodeFormTail(node3);
        list.addListNodeFormTail(node4);
        System.out.println(list.size());
        ListNode node5 = new ListNode();
        node5.setData(5);
        //option =-1 || 5 || 4
        list.addListNode(node5, 4);
        System.out.println(list.size());
        list.delFromHead();
        System.out.println(list.size());
        list.delFromTail();
        System.out.println(list.size());
        //测试新值换旧值
        list.replaceData(2,100);
        System.out.println(list.size());
        //测试根据数据查询是否包含该节点
        System.out.println(list.iscludeData(100));
        //通过索引查找该节点的数据
        System.out.println(list.getDataByIndex(2));
        //根据位置进行删除
        list.delFromIndex(2);
        //根据数据删除节点
        list.delBydata(4);
        System.out.println(list.size());
        System.out.println(list.size());

    }

}