链表 -- 单向链表（线性表）

数据结构：通俗的讲，将现实生活中的逻辑结构转换成计算机物理存储。

时间复杂性：程序运行的快慢，越快越好。

空间复杂性：程序占用的硬盘，内存资源的大小，越小越好，但是前提是稳定性。

数据结构就是为了以上的几个课题而研究，程序运行的越快，占用的资源越小，程序稳定。

 

1，链表的基本操作

建表，增加节点，删除节点，按照序号查找，定位

2，链表的基本概念

      数组 vs 链表

数组（内存中连续的存储空间）

在无序的数组中，搜索效率低下

在有序的数组中，插入效率低下

在任何数组中，删除的效率低下

数组的大小固定

 

链表（内存中分散的位置）

链表可以是一种有序或者无序的列表

链表的内容通常存储在内存中分散的位置

链表是由节点构成，每一个节点的结构都相同

节点分为数据域和链域，数据域是存放节点的内容，链域是存放下一个节点的指针

 

3,创建链表

首先，创建节点类，节点包含当前的数据，以及下一个节点的指针，如下代码所示：

 

public class Node {

    String name;// 当前数据是这种简单的属性，也可以是复杂的对象
    
    Node next;
    
    public Node(){
        
    }
    
    public Node(String name){
        this.name = name;
        this.next = null;//一个新的节点，下个节点视为null
    }
}

其次，创建链表类，代码如下

public class Link{

    int size;

    Node first;

    public Link() {
        this.size = 0;
    }

    public boolean isEmpty() {
        return first == null;
    }

    public void addNode(String name) {
        if (first == null) {
            first = new Node(name);
            size++;
        } else {
            Node newNode = new Node(name);
            Node temp = first;
            while (temp.next != null) {
                temp = temp.next;
            }
            temp.next = newNode;
            size++;
        }
    }

    public void removeNode(String name) {
        if (first == null) {
            return;
        }

        if (first.name.equals(name)) {
            first = first.next;
            size--;
            return;
        }
        Node temp = first;
        while (!temp.next.name.equals(name)) {
            temp = temp.next;
        }
        temp.next.next = temp.next;
        size--;
    }

    public void insertNode(String data, String name) {
        // 插入到指定位置
        Node temp = first;
        while (!temp.name.equals(data)) {
            temp = temp.next;
        }
        Node newNode = new Node(name);
        newNode.next = temp.next;
        temp.next = newNode;
        size++;

    }

    public void display() {
        Node temp = first;
        while (temp != null) {
            System.out.println(temp.name);
            temp = temp.next;
        }
    }

    public void insertFirst(String name) {
        // 插入到链表的第一个位置
        Node newNode = new Node(name);
        newNode.next = first;
        first = newNode;
        size++;
    }
}

测试类，以及打印结果如下：

 

public class Test {
    
    public static void main(String[] args) {
        Link link = new Link();
        System.out.println(link.isEmpty()); 
        link.addNode("团队主管");
        System.out.println(link.size);
        link.addNode("部门助理");
        System.out.println(link.size);
        link.addNode("部门经理");
        System.out.println(link.size);
        link.addNode("人事经理");
        System.out.println(link.size);
        link.addNode("总经理");
        System.out.println(link.size);
        link.addNode("总裁");
        System.out.println(link.size);
        link.display();
        System.out.println("======我是分界线=========");
        
        System.out.println(link.isEmpty()); 
        
        System.out.println("======我是分界线=========");
        
        link.insertFirst("小组长");
        link.display();
        System.out.println("======我是分界线=========");
        
        link.removeNode("小组长");
        link.display();
        System.out.println("======我是分界线=========");
        
        link.addNode("董事长");
        link.display();
        
        System.out.println("======我是分界线=========");
        link.insertNode("部门经理", "人事助理");
        link.display();
    }
}

打印结果：

true
1
2
3
4
5
6
团队主管
部门助理
部门经理
人事经理
总经理
总裁
======我是分界线=========
false
======我是分界线=========
小组长
团队主管
部门助理
部门经理
人事经理
总经理
总裁
======我是分界线=========
团队主管
部门助理
部门经理
人事经理
总经理
总裁
======我是分界线=========
团队主管
部门助理
部门经理
人事经理
总经理
总裁
董事长
======我是分界线=========
团队主管
部门助理
部门经理
人事助理
人事经理
总经理
总裁
董事长

    链表类包含的了一些方法，是否为空，增加，删除，插入到指定位置之后，插入到第一个等。