Java实现单链表，单链表反转，查找单链表中倒数第k个结点，逆序打印单链表，合并两个有序的单链表

1、Java实现单链表

package com.算法练习.链表;

public class SingleLinkedList<E> {
    //创建一个头结点方便进行操作
    private Node head=new Node();
    //用于记录链表中的结点个数
    int size;
    //给指定位置添加元素
    public boolean add(int index,E element){
        //检查index
        CheckIndex(index);
        Node p=head;
        //创建一个结点
        Node<E> newnode = new Node<>(null,element);
        //首先需要遍历找出第index个结点
        for (int i = 0; i < index; i++) {
            p=p.next;
        }
        newnode.next=p.next;
        p.next=newnode;
        size++;
        return true;
    }
    //添加元素（尾插法）
    public boolean add(E element){
        return add(size,element);
    }
    //获取指定位置的元素
    public E get(int index){
        CheckIndex(index);
        Node p=head;
        for (int i = 0; i <=index; i++) {
            p=p.next;
        }
        return (E) p.data;
    }
    //修改指定位置的元素
    public void update(int index,E element){
        CheckIndex(index);
        Node p=head;
        for (int i = -1; i < index; i++) {
            p=p.next;
        }
        p.data=element;
    }
    //删除指定位置的元素
    public void remove(int index){
        CheckIndex(index);
        Node p=head;
        //注意，我们需要找到待删除结点的前一个结点
        for (int i = -1; i < index-1; i++) {
            p=p.next;
        }
        p.next=p.next.next;
        size--;
    }
    //toString方法
    public String toString(Node head) {
        StringBuilder builder = new StringBuilder();
        builder.append("[");
        Node p = head.next;
        while (p != null) {
            if (p.next == null) {
                builder.append(p.data);
            } else {
                builder.append(p.data + "->");
            }
            p = p.next;
        }
        builder.append("]");
        return builder.toString();
    }
}
class Node<E>{
    Node next;//下个节点的地址
    E data;//数据
    public Node() {
    }
    public Node(Node next, E data) {
        this.next = next;
        this.data = data;
    }
}

2、单链表反转

//反转单链表 头插法实现
    public void reverseList(Node head){
        //要创建一个新的头结点
        Node newHead = new Node();
        Node node=null;//保存结点的变量
        Node p = head;
        //遍历原链表
        while(p!=null){
            //先要将当前结点的下一个节点保存下来
             node = p.next;
            //当前结点的下一个节点要指向新的头结点的下一个结点
            p.next=newHead.next;
            //新头结点要指向当前元素
            newHead.next=p;
            //指指针向后移动
            p=node;
        }
        //将head.next又指向newHead.next;
        head.next=newHead.next;
    }

3、查找单链表中倒数第k个结点

 //查找单链表中倒数第k个结点
    public E SearchK(int k){
        CheckIndex(k);
        Node p=head;
        int count=0;
        E element = null;
        while(p!=null){
            if(count==(size-k)){
                element= (E) p.data;
                break;
            }
            count++;
            p=p.next;
        }
        return element;
    }

4、逆序打印单链表

 //逆序打印单链表利用栈来实现
    public void Reverse(){
        Node p=head.next;
        if(p==null){
            return;
        }
        Stack<E> stack = new Stack<>();
        //入栈
        while(p!=null){
            stack.push((E) p.data);
            p=p.next;
        }
        //出栈
        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }
    }

5、合并两个有序的单链表，合并之后依然有序

（1）迭代法

 //合并两个有序单链表，合并后的链表依然有序
    public Node SortLinked(Node head1, Node head2) {
        //创建一个新的结点头存储合并后的链表
        Node<Integer> integerNode = new Node<>();
        Node p3=integerNode;
        Node p1 = head1.next;
        Node p2 = head2.next;
        while (p1 != null && p2 != null) {
            Integer data1 = (Integer) p1.data;
            Integer data2 = (Integer) p2.data;
            if (data1 >= data2) {
                p3.next=p2;
                p2 = p2.next;
            } else {
               p3.next=p1;
               p1 = p1.next;
            }
            p3=p3.next;
        }
        if(p1!=null){
            p3.next=p1;
        }
        if(p2!=null){
            p3.next=p2;
        }
        return integerNode;
    }