Java实现单向链表

Java实现链表的思想可以参考 LinkedList的源码

下面实现几点关于单向链表的一些操作：

public class LinkList<E> {
    private Node<E> first;
    private Node<E> last;
    private int  size;
    
    public LinkList() {
        first = last = null;
        size = 0;    
    }
    
    
    private static class Node<E> {
        private Node<E> next;
        private E data;
        public Node(E data,Node<E> next) {    
            this.data = data;
            this.next = next;        
        }
    }
    
    public void add(E e) {
        Node<E> l = last;
        Node<E> newNode = new Node<E>(e, null);
        last = newNode;
        if(first == null) {
            first = newNode;
        } else {
            l.next = newNode;
        }
        size++;
    }
    

    
    public static void main(String[] args) {
        LinkList<Integer> link = new LinkList<Integer>();
        //1.添加
        link.add(1);
        link.add(2); 
        link.add(3);
        link.add(4);
        
        System.out.println("节点个数：" + link.size);
        
        //2.遍历
        Node<Integer> node1 = link.first;
        for(int i = 0;i<link.size;i++) {
            if(link.first != null) {
                System.out.println(node1.data);
                node1 = node1.next;
            }
        }
        
        //3.查找单链表中的倒数第k个结点
        int k = 2;
        //倒数第k个，就是正数第link.size-k+1，（因为是单向，只能正着数）
        int index = link.size-k+1;
        Node<Integer> node2 = link.first;
        
        if(link.size <= 0) {
            System.out.println("链表为空");
            return;
        }
        if(link.size <= k && link.size > 0) {
            System.out.println(node2.data); 
            return;
        }
        
        for(int i = 1;i<index;i++) {    
            node2 = node2.next;
        }
        
        System.out.println("这个链表中倒数第" + k + "个节点的值为：" + node2.data);
        
        //4.查找单链表中的中间节点（size + 1 / 2，然后遍历吧）
        
        //5.合并两个有序的单链表，合并之后，仍然有序；
        //这里自己的思路是，创建一个新的链表，将这两个有序的链表中的数据，按序放入到 新链表中
        LinkList<Integer> link2 = new LinkList<Integer>();
        LinkList<Integer> link3 = new LinkList<Integer>();
        link2.add(0);
        link2.add(2); 
        link2.add(3); 
        link2.add(2);
        link2.add(7);
        link2.add(7);
        
        Node<Integer> node3 = link.first;
        Node<Integer> node4 = link2.first;
        
        //只有链表1和链表2中还有数据可以放入新链表
        for(;node3 != null || node4 != null;) {
            
            //当链表1和链表2中都有数据可以去比较，
            if(node3 != null && node4 != null) {
                if(node3.data < node4.data) {
                    link3.add(node3.data);
                    node3 = node3.next;
                }
                else if(node3.data > node4.data) {
                    link3.add(node4.data);
                    node4 = node4.next;
                } else if(node3.data == node4.data) {
                    link3.add(node3.data);
                    link3.add(node4.data);
                    node3 = node3.next;
                    node4 = node4.next;
                }
            }
            
            
            //若链表1的数据已经比较完了，链表2的还有数据存在，说明链表2这些剩下的数据都比链表1里面大，直接全部放到新链表后面
            if(node3 == null && node4 != null) {
                link3.add(node4.data);
                node4 = node4.next;
            } else if(node3 != null && node4 == null) {
                link3.add(node3.data);
                node3 = node3.next;
            }    
            
        }
        System.out.print("两个有序的单链表合并后：");
        for(int i = 0;i<link3.size;i++) {
            System.out.print(link3.first.data + " ");
            link3.first = link3.first.next;
        }
        System.out.println("");
        System.out.println("------------------华丽丽的分割线--------------------");
        
        //6.单链表的反转
        Node<Integer> node5 = link.first;

        Node<Integer> pre = null;
        Node<Integer> next = null;
        
        while(node5 != null) {
            next = node5.next;
            node5.next = pre;
            pre = node5;
            node5 = next;
            
        }
        
        while(pre != null) {
            System.out.print(pre.data + " ");
            pre = pre.next;
        }
    }
}

注：上面的代码写得比较糟糕，也有很多可以封装的地方，等有时间再整理

提比较重要的几点：

　　1.关于链表中的泛型，用到泛型的地方，

　　　　a）创建这个LinkList的时候，

　　　　b）创建Node节点的时候，

　　　　c）往Node中添加的数据

　　2.关于单向链表的添加，

　　　　a）添加就是添加在链表的末尾，添加之前，肯定要创建一个 Node节点出来，这个Node节点的下一个节点为null

　　　　b）先保存原来的last节点，将这个newNode作为新的last节点

　　　　c）如果原先列表中不存在节点，则这个newNode就为 first节点

　　　　d）将原来的last节点的next指向这个newNode，就完成添加了 ，最后size++

　　3.关于合并两个有序的单链表，

　　　　a）这里自己的思路是，创建一个新的链表，将这两个有序的链表中的数据，按序放入到 新链表中，当然还有别的思路

　　4.关于单向链表的反转，

　　　　a）首先要有一个pre节点和 next 节点，用于保存当前节点的前一个节点和后一个节点

　　　　b）

　　　　　　用前面定义的next，保存当前节点的下一个节点

　　　　　　当前节点下一节点重新指向当前节点的前一节点（箭头反向） 1->2->3    1<-2  3   这里体现上一句的必要性了，如果没有保存，那么后面就找不到这个 3 了

　　　　　　让pre，当前节点，next，依次向后移动，这样就可以对下一个节点进行反转

　　　　c）还有一种递归的方式，递归和直接遍历的区别就是，直接遍历是从前往后按顺序一个一个反转

　　　　　　递归是从后往前，先反转最后一个节点，再回头反转前面

　　这边给出一个递归的示例：

 public static void main(String[] args) {  
        Node head = new Node(0);  
        Node node1 = new Node(1);  
        Node node2 = new Node(2);  
        Node node3 = new Node(3);  
        head.setNext(node1);  
        node1.setNext(node2);  
        node2.setNext(node3);  
  
        // 打印反转前的链表  
        Node h = head;  
        while (null != h) {  
            System.out.print(h.getData() + " ");  
            h = h.getNext();  
        }  
        // 调用反转方法  
        head = Reverse1(head);  
  
        System.out.println("
**************************");  
        // 打印反转后的结果  
        while (null != head) {  
            System.out.print(head.getData() + " ");  
            head = head.getNext();  
        }  
    }  
  
    /** 
     * 递归，在反转当前节点之前先反转后续节点 
     */  
    public static Node Reverse1(Node head) {  
        // head看作是前一结点，head.getNext()是当前结点，reHead是反转后新链表的头结点  
        if (head == null || head.getNext() == null) {  
            return head;// 若为空链或者当前结点在尾结点，则直接还回  
        }  
        Node reHead = Reverse1(head.getNext());// 先反转后续节点head.getNext()  
        head.getNext().setNext(head);// 将当前结点的指针域指向前一结点  
        head.setNext(null);// 前一结点的指针域令为null;  
        return reHead;// 反转后新链表的头结点  
    }  
}  
  
    class Node {  
        private int Data;// 数据域  
        private Node Next;// 指针域  
  
        public Node(int Data) {  
            // super();  
            this.Data = Data;  
        }  
  
        public int getData() {  
            return Data;  
        }  
  
        public void setData(int Data) {  
            this.Data = Data;  
        }  
  
        public Node getNext() {  
            return Next;  
        }  
  
        public void setNext(Node Next) {  
            this.Next = Next;  
        }