Java 数据结构:单向链表

链表: 末尾添加元素, 插入元素, 获得指定位置的元素, 删除指定位置元素

数组和链表的优劣

1.数组的物理空间连续, 碎片化空间使用不彻底
  链表物理空间不连续, 空间使用彻底
2.链表只能从head开始访问, 访问效率低
  数组可以随机访问任意元素, 访问效率高
3.链表插入/移除元素, 只需要操作1~2个元素, 效率高
  数组插入/移除元素, 涉及到大量元素的移动, 效率低

链表实现

代码实现

package datastructure;
/**
 * 单链表
 * */
public class SingleNode<T> {
    //定义一个头部,不存储数据
    private Node head = new Node(null);
    //内部类,创建Node对象(数据+指针)
    public class Node {
        //泛型数据
        private T data;
        //next是指向的下一个Node对象
        private Node next;
        //初始化Node
        public Node(T a) {
            this.data = a;
        }
    }

    //在链表末尾加结点的方法
    public void add(T a) {
        //从头结点的开始
        Node node = head;
        //next不为空,说明下一个还有结点,此节点不是末尾
        while (node.next != null) {
            node = node.next;
        }
        //循环结束,临时node已经变为最后一个结点,使其指向一个新结点
        node.next = new Node(a);
    }

    //重写toString方法
    public String toString(){
        Node node = head;
        StringBuilder sb = new StringBuilder();
        while (node.next != null) {
            node = node.next;
            sb.append(node.data);
        }
        return sb.toString();
    }

    /**删除结点*/
    public void remove(T a){
        Node node = head;
        while (node.next.data != a){
            node = node.next;
        }
        node.next = node.next.next;
    }
    //重载remove方法
    public void remove(int index){
        Node node = getIndexPreNode(index);
        node.next = node.next.next;
    }

    /**插入结点,在b后面插入a*/
    public void insert(T a,T b){
        Node node = head;
        do{
            node = node.next;
        }while(!node.data.equals(b));
        Node insert = new Node(a);
        insert.next = node.next;
        node.next = insert;
    }
    //重载insert方法,删除指定下标的node
    public void insert(int index,T data){
        Node node = getIndexPreNode(index);
        Node in = new Node(data);
        in.next = node.next;
        node.next = in;
    }

    //获取(指定下标)需要操作结点的上一个node
    public Node getIndexPreNode(int index){
        Node node = head;
        for(int i = 0; i < index; i++){
            node = node.next;
        }
        return node;
    }

    //获得指定下标的node
    public Object getNode(int index){
        return getIndexPreNode(index).next.data;
    }

    //反转链表
    public void reverse(){
        Node node = head.next;
        while(node.next != null){
            //将链表第一个结点设为node,不断地将它后面的结点插入到头结点之后
           Node temp = node.next.next;
           node.next.next = head.next;
           head.next = node.next;
           node.next = temp;
        }
    }



}

测试

package datastructure;



public class SingleLink {
    public static void main(String[] args) {
        SingleNode<String> node = new SingleNode();
        node.add("我");
        node.add("是");
        node.add("傻");
        node.add("比");
        node.add("你");
        node.add("帅");
        //输出:我是傻比你帅
        System.out.println(node);
        node.remove("傻");
        node.remove("是");
        //删除 傻,是,输出:我比你帅
        System.out.println(node);
        node.insert("多了","帅");
        //插入 多了在帅元素之后 输出:我比你帅多了
        System.out.println(node);
        node.insert(5,"傻比");
        //在下标5处插入"傻比" 输出:我比你帅多了傻比
        System.out.println(node);
        //获得下标为3的元素:帅
        System.out.println(node.getNode(3));
        node.remove(4);
        //移除下标为4的元素,输出:我比你帅傻比
        System.out.println(node);
        //链表反转
        node.reverse();
        //输出:傻比帅你比我
        System.out.println(node);
    }
}