单链表的基本操作

java实现单链表

Node实体类类标识

public class Node {
    //内部类（节点）
    int data;
    Node next;

    //构造函数（创建新节点）
    public Node(int data) {
        this.data = data;
        this.next = null;
    }

    //可以创建带头结点的单链表节用无参构造
    public Node() {
    }
}

单链表基本操作

public class SingleLinkedList {
    //头结点（初始化带头结点）
    private Node head = new Node();
    //单链表长度
    private int length ;

    /**
     * 尾插法建立单链表
     *
     * @param data
     */
    public void listTailInsert(int data) {
        Node node = new Node(data);
        //判断有没有头结点
        if (head == null) {
            //把新建的结点赋值给头结点
            //但是头结点不是不带数据的吗
            //如果head定义为空的话就代表不带头结点，赋值后变成了 首元结点
            head = node;
            return;
        }
        //头指针
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = node;
        length++;
    }

    //打印单链表
    public void display() {
        //指针指向头节点
        Node node = head;
        while (node != null) {
            System.out.print(node.data + "->");
            node = node.next;
        }
        System.out.println();
    }


    /**
     * 按序号查找结点值
     *
     * @param index 索引（1-ssl.length）
     * @return 索引对应的结点
     */
    public Node getValue(int index) {
        int j = 1;
        Node node = head.next;
        if (index == 0) {
            return head;
        }
        if (index < 1) {
            return null;
        }
        while (j < index) {
            node = node.next;
            j++;
        }
        return node;
    }


    /**
     * 删除一个节点
     *
     * @param index 指定删除哪一个结点
     */
    public void delete(int index) {
        int j = 1;
        Node node = head;
        //待删除节点不存在
        if (index < 1) {
            return;
        }
        while (j < index) {
            node = node.next;
            j++;
        }
        node.next = node.next.next;
        length--;
    }

    /**
     * 计算单链表长度
     *
     * @return 单链表长度
     */
    public int length() {
        return length;
    }

    //链表结点排序,并返回排序后的头结点:
    //选择排序算法,即每次都选出未排序结点中最小的结点，与第一个未排序结点交换
    public Node sort() {
        Node curNode = head;
        while (curNode != null) {
            Node nextNode = curNode.next;
            while (nextNode != null) {
                if (curNode.data > nextNode.data) {
                    int temp = curNode.data;
                    curNode.data = nextNode.data;
                    nextNode.data = temp;
                }
                nextNode = nextNode.next;
            }
            curNode = curNode.next;
        }
        return head;
    }

    //头插法
    // 反转链表，在反转指针钱一定要保存下个结点的指针
    public void reverse(){
        //声明一个指针指向头结点
        Node node = head;
        //声明指针p，在node和p之间插入后续结点
        Node p = node.next;
        //先将单链表初始化，好插入第一个结点
        node.next = null;
        while (p!=null){
            //指针指向第二个结点
            Node q = p.next;
            //p是插入的结点，其next域保存头结点之后的结点
            p.next = node.next;
            //头结点的next域保存p
            node.next = p;
            //q就是保存要插入的结点
            p =q;
        }
    }

    //在指定的位置插入结点
    public void insert(int index,int x){
        int j=1;
        Node node = head;
        if (index<1||index>this.length()){
            return;
        }
        while (j<index){
            node = node.next;
            j++;
        }
        Node newNode = new Node(x);
        newNode.next = node.next;
        node.next = newNode;
        length++;
    }

}

测试类

import java.util.Deque;
import java.util.LinkedList;
import java.util.List;

//SLL单链表
public class TestSLL {
    public static void main(String[] args) {
        //新建空单链表
        SingleLinkedList sll = new SingleLinkedList();
        sll.listTailInsert(1);
        sll.listTailInsert(2);
        sll.listTailInsert(5);
        sll.listTailInsert(2);
        sll.display();
        System.out.println(sll.length());
        sll.insert(3,4);
        sll.display();
        System.out.println(sll.length());
//        System.out.println(sll.length());;
//        System.out.println(sll.getValue(1).data);
//
//        sll.reverse();
//        sll.display();

    }
}