单链表的读取，删除，插入，遍历操作

链表是由指针把若干个节点连接成链状结构。其中每个节点由存储数据和指想下一个节点的指针构成。链表具有创建节点、插入节点、删除节点等操作。

创建节点

在链表末尾创建节点

 void add(int x){ //将x加入链表最后
        Node pre, p, q;
        pre = head;
        p = head.next;
        while (p != null){
            pre = pre.next;
            p = p.next;
        }
        q = new Node();
        q.data = x;
        pre.next = q;
    }

插入节点

将数据加入升序链表

void add2(int x){ //将x加入升序链表
        Node pre, p ,q;
        pre = head;
        p = head.next;
        while (p != null){
            if (p.data > x)
                break;
            pre = pre.next;
            p = p.next;
        }
        q = new Node();
        q.data = x;
        q.next = p;
        pre.next = q;
    }

在指定位置插入数据

void inset(int index, int ins){ //插入，在索引index位置，插入ins值
        Node pre, p ,q;
        pre = head;
        p = head.next;
        while (index-- >1 && p != null ){
            pre = pre.next;
            p = p.next;
        }
        if (p == null){
            System.out.println("输入索引大于链表长度");
        }else {
            q = new Node();
            q.data = ins;
            q.next = p;
            pre.next = q;
        }
    }

删除节点

void delete(int x){ //删除链表中的某个值(只能删除第一次出现)
        Node pre, p;
        pre = head;
        p = head.next;
        while (p != null){
            if (p.data == x ){
                if (p.next != null) {
                    pre.next = p.next;
                    break;
                }
                else {
                    pre.next = null;
                    break;
                }
            }
            pre = pre.next;
            p = p.next;
        }
    }
    void delete2(int x){ //删除链表中的某个值(所有)
        Node pre, p;
        pre = head;
        p = head.next;
        while (p != null){
            if (p.data == x ){
                if (p.next != null) {
                    pre.next = p.next;
                    p = p.next;
                    continue;
                }
                else {
                    pre.next = null;
                    break;
                }
            }
            pre = pre.next;
            p = p.next;
        }
    }
    
 void deleteValue(int index){ //删除，删除第index链表上的数
        Node pre, p ;
        pre = head;
        p = head.next;
        while (index -- > 1 && p != null){
            pre = pre.next;
            p = p.next;
        }
        if (p == null)
            System.out.println("Error index");
        else
            pre.next = p.next;
    }

遍历链表

void showInfo(){ //打印链表中所有的数
        Node pre, p;
        pre = head;
        p = head.next;
        while (p != null){
          System.out.print(p.data+" ");
          pre = pre.next;
          p = p.next;
        }
        System.out.println(" ");
    }

测试代码

public class SingleNode {
    class Node{
        int data;
        Node next;
    }

    Node head; //链表的表头指针
    //初始化
    void init(){
        head = new Node();
        head.next = null;
    }

    void add(int x){ //将x加入链表最后
        Node pre, p, q;
        pre = head;
        p = head.next;
        while (p != null){
            pre = pre.next;
            p = p.next;
        }
        q = new Node();
        q.data = x;
        pre.next = q;
    }


    void add2(int x){ //将x加入升序链表
        Node pre, p ,q;
        pre = head;
        p = head.next;
        while (p != null){
            if (p.data > x)
                break;
            pre = pre.next;
            p = p.next;
        }
        q = new Node();
        q.data = x;
        q.next = p;
        pre.next = q;
    }

    boolean find(int x){ //查找链表中是否有数值x
        boolean found = false;
        Node pre, p;
        pre = head;
        p = head.next;
        while (p != null){
            if (p.data == x)
                found = true;
            pre = pre.next;
            p = p.next;
        }
        return  found;
    }

    void delete(int x){ //删除链表中的某个值(只能删除第一次出现)
        Node pre, p;
        pre = head;
        p = head.next;
        while (p != null){
            if (p.data == x ){
                if (p.next != null) {
                    pre.next = p.next;
                    break;
                }
                else {
                    pre.next = null;
                    break;
                }
            }
            pre = pre.next;
            p = p.next;
        }
    }
    void delete2(int x){ //删除链表中的某个值(所有)
        Node pre, p;
        pre = head;
        p = head.next;
        while (p != null){
            if (p.data == x ){
                if (p.next != null) {
                    pre.next = p.next;
                    p = p.next;
                    continue;
                }
                else {
                    pre.next = null;
                    break;
                }
            }
            pre = pre.next;
            p = p.next;
        }
    }

    /* 大话数据结构中的插入、删除、读取*/
    int getValue(int index){ //获取第I个元素的数据
        Node pre,p;
        pre = head;
        p = head.next;

        while (index-- >1 && p != null){
            pre = pre.next;
            p = p.next;
        }
        if (p == null)
            return -1;
        else
            return p.data;
    }

    void inset(int index, int ins){ //插入，在索引index位置，插入ins值
        Node pre, p ,q;
        pre = head;
        p = head.next;
        while (index-- >1 && p != null ){
            pre = pre.next;
            p = p.next;
        }
        if (p == null){
            System.out.println("输入索引大于链表长度");
        }else {
            q = new Node();
            q.data = ins;
            q.next = p;
            pre.next = q;
        }
    }

    void deleteValue(int index){ //删除，删除第index链表上的数
        Node pre, p ;
        pre = head;
        p = head.next;
        while (index -- > 1 && p != null){
            pre = pre.next;
            p = p.next;
        }
        if (p == null)
            System.out.println("Error index");
        else
            pre.next = p.next;
    }

     void showInfo(){ //打印链表中所有的数
        Node pre, p;
        pre = head;
        p = head.next;
        while (p != null){
          System.out.print(p.data+" ");
          pre = pre.next;
          p = p.next;
        }
        System.out.println(" ");
    }

    public static void main(String[] args) {
        SingleNode L = new SingleNode();
        L.init();//初始化链表
        for (int i=0;i < 10; i++){
            L.add(i);
        }
        for (int i=10;i >= 0; i--){
            L.add(i);
        }
        L.showInfo();
        System.out.println("链表中包含1？"+L.find(1));
        System.out.println("链表中包含12？"+L.find(12));
        System.out.println("删除链表中的1");
        L.add(1);
        L.add(1);
        L.delete(1);
        L.showInfo();
        System.out.println(L.getValue(22)+" "+L.getValue(23));
        L.inset(1,100);
        L.inset(22,200);
        L.showInfo();
        L.deleteValue(22);
        L.showInfo();
        L.deleteValue(23);
        L.showInfo();
        L.deleteValue(1);
        L.showInfo();
    }
}