Java实现单链表及相关操作

单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的。

每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，

• 元素就是存储数据的存储单元，

• 指针就是连接每个结点的地址数据。

单链表结构图：

先建一个结点类

/**
 * @auther: lawt
 * @date: 2018/11/4 08
 * @Description: 结点信息
 */
public class Node {
    /**
     * 为了方便，这两个变量都使用public，而不用private就不需要编写get、set方法了。
     * 存放数据的变量，简单点，直接为int型
     */
    public int data;
    /**
     * 存放结点的变量,默认为null
     */
    public Node next;

    /**
     * 构造方法，在构造时就能够给data赋值
     */
    public Node(int data) {
        this.data = data;
    }
}

 

相关操作

/**
 * 插入头结点
 */
public static void insertHead(Node head, Node newHead) {
    Node old = head;
    head = newHead;
    head.next = old;
}

/**
 * 插入尾节点
 */
public static void insertTail(Node tail, Node newTail) {
    Node old = tail;
    tail = newTail;
    tail.next = null;
    old.next = tail;
}

/**
 * 遍历
 *
 * @param head 链表
 */
public static void query(Node head) {
    while (head != null) {
        System.out.print(head.data + " ");
        head = head.next;
    }
    System.out.println();
}

/**
 * 查找某个结点
 *
 * @param head 头结点
 * @param data 要找的node的data
 * @return 链表下标
 */
public static int find(Node head, int data) {
    int index = -1;//初始值为-1
    int count = 0;//可以知道循环次数
    while (head != null) {//当头结点部位null
        if (head.data == data) {//如果该节点的值==找的
            index = count;
        }
        count++;//没有找到，循环次数+1
        head = head.next;//没有找到继续遍历
    }
    return index;//返回链表下标
}

/**
 * 插入
 *
 * @param p 插入到p的后
 * @param s 需要插入的node
 */
public static void insert(Node p, Node s) {
    Node next = p.next;//记录下p结点
    p.next = s;//p的next指向s结点
    s.next = next;//把p结点的next指向s的next结点
}

/**
 * 删除结点q
 *
 * @param head 链表
 * @param q    删除的结点
 */
public static void delete(Node head, Node q) {
    //q不为空，q的下一个结点也不为空
    if (q != null && q.next != null) {
        //思路：把q的next的next指向q的next，
        //这样之前q的next就被删除了
        Node p = q.next;
        q.data = p.data;
        q.next = p.next;
        p = null;
    }
    //删除最后一个节点
    if (q.next == null) {
        while (head != null) {
            //遍历前面的链表，当该节点的next就是q的时候
            //然后把q设置成null
            if (head.next != null && head.next == q) {
                head.next = null;
                break;
            }
            head = head.next;
        }

    }
}

/**
 * 翻转链表
 * 时间复杂度O(N)
 * 空间复杂度O(1)
 */
public static Node reversal(Node head) {
    Node pre = null;
    Node next = null;
    while (head != null) {
        next = head.next;
        head.next = pre;
        pre = head;
        head = next;
    }
    return pre;
}

/**
 * 当偶数个则取前面那个
 *
 * @return  链表中的中间节点
 */
public static Node getMid(Node head) {
    if (head == null) {
        return head;
    }
    Node fast = head;
    Node slow = head;
    while (fast.next != null && fast.next.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    return slow;
}

测试代码

public static void main(String[] args) {

    Node node1 = new Node(1);
    Node node2 = new Node(2);
    Node node3 = new Node(3);
    Node node4 = new Node(4);

    node1.next = node2;
    node2.next = node3;
    node3.next = node4;
    node4.next = null;

    query(node1);
    Node newHead = new Node(6);
    insertHead(node1, newHead);
    Node node7 = new Node(7);
    insertTail(node4, node7);
    query(newHead);
    System.out.println(find(newHead, 3));
    Node node8 = new Node(8);
    insert(node3, node8);
    query(newHead);
    delete(newHead, node3);
    query(newHead);

    Node head= new Node(1);
    Node n2 = new Node(2);
    Node n3 = new Node(3);
    head.next = n2;
    n2.next = n3;
    n3.next = null;
    System.out.println(getMid(head).data);
    System.out.println();
    Node node = reversal(head);
    while (node != null) {
        System.out.print(node.data + " ");
        node = node.next;
    }
}

结果