Java 单链表

结点类

/**
 * 结点类
 */
public class SingleLinkedListNode {
    public int id;
    public String name;
    SingleLinkedListNode next;


    public SingleLinkedListNode(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "SingleLikedListNode{" +
                "id=" + id +
                ", name='" + name + '\''  +
                '}';
    }
}

链表操作

package com.company.DataStructure.LinkList.Single;

import java.util.Stack;

/**
 * 单链表
 */
public class SingleLinkedList {

    private SingleLinkedListNode head = new SingleLinkedListNode(0,"");// 头结点

    public SingleLinkedListNode getHead() {
        return head;
    }

    public void setHead(SingleLinkedListNode head) {
        this.head = head;
    }

    /**
     * 添加结点
     * 将结点添加到最后
     * @param newNode
     */
    public void addNode(SingleLinkedListNode newNode){
        SingleLinkedListNode temp = head;
        // 遍历单链表
        while (true){
            if (temp.next == null){
                break;
            }
            temp = temp.next;
        }
        temp.next = newNode;
    }

    /**
     *按顺序插入新节点
     * @param newNode
     */
    public void insertNode(SingleLinkedListNode newNode){
        SingleLinkedListNode temp =head;
        boolean flag = false;
        while (true){
            if (temp.next == null){
                break;
            }
            if (temp.next.id > newNode.id){ // 待插入位置
                break;
            }else if (temp.next.id == newNode.id){ // 插入节点id已存在
                flag = true;
                break;
            }
            temp =  temp.next;
        }
        if (flag){
            System.out.println("待插入的节点id已存在"+newNode.id);
        }else {
            newNode.next = temp.next;
            temp.next = newNode;
        }
    }

    /**
     * 按id修改单链表
     * @param newNode
     */
    public void updateLinkedList(SingleLinkedListNode newNode){
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        SingleLinkedListNode temp = head.next;
        boolean flag = false;
        while (true){
            if (temp == null){
                break;
            }
            if (temp.id == newNode.id){ //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.name = newNode.name;
        }else {
            System.out.println("待修改节点id不存在,id="+newNode.id);
        }
    }

    /**
     * 根据id,删除节点
     * @param id
     */
    public void deleteLinkedList(int id){
        SingleLinkedListNode temp = head;
        boolean flag =false;
        while (true){
            if (temp.next == null){
                break;
            }
            if (temp.next.id == id){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.next = temp.next.next;
        }else {
            System.out.println("待删除的节点不存在");
        }
    }

    /**
     * 求单链表中有效节点个数
     * @param head
     * @return
     */
    public int getLength(SingleLinkedListNode head){
        if (head.next == null){
            return 0;
        }
        int count = 0;
        SingleLinkedListNode temp = head.next;
        while (temp != null){
            count++;
            temp = temp.next;
        }
        return count;

    }

    /**
     * 查找单链表倒数第index个节点
     * @param head
     * @param index
     * @return
     */
    public SingleLinkedListNode findLastLinkedNode(SingleLinkedListNode head, int index){
        if (head.next == null){
            return null;
        }
        SingleLinkedListNode cur = head.next;
        int count = getLength(head);
        if (index <= 0 || index > count){
            return null;
        }
        for (int i = 0; i < count - index ; i++) {
            cur = cur.next;
        }
        return cur;

    }

    /**
     * 单链表反转
     * @param head
     */
    public void reverseSingleLinked(SingleLinkedListNode head){
        if (head.next == null || head.next.next == null){
            return;
        }
        SingleLinkedListNode cur = head.next;
        SingleLinkedListNode curNext = null; // cur的下一结点
        SingleLinkedListNode reverseHead = new SingleLinkedListNode(0,null);
        while (cur != null){
            curNext = cur.next;
            cur.next = reverseHead.next;
            reverseHead.next = cur;
            cur = curNext;
        }
        head.next = reverseHead.next;
    }

    /**
     * 逆序打印单链表
     * 思路:
     *      1. 先将链表反转,在打印. 但是破换了链表原有结构
     *      2. 使用栈
     * @param head
     */
    public void reversePrintLinkedList(SingleLinkedListNode head){
        if (head.next == null){
            return;
        }
        Stack<SingleLinkedListNode> stack = new Stack<>();
        SingleLinkedListNode cur =head.next;
        while (cur != null){
            stack.push(cur);
            cur = cur.next;
        }
        while (stack.size() > 0){
            System.out.println(stack.pop());
        }
    }

    /**
     * 合并单链表
     * @param head1
     * @param head2
     */
    public SingleLinkedListNode mergeLinkedList(SingleLinkedListNode head1, SingleLinkedListNode head2){
        if (head1.next ==null || head2.next == null){
            return head1==null ? head1 : head2;
        }
        SingleLinkedListNode mergeHead = new SingleLinkedListNode(0,null);
//        SingleLinkedListNode mergeHead = head1;
        SingleLinkedListNode cur1 = head1.next;
        SingleLinkedListNode cur2 = head2.next;
        while (cur1 != null && cur2 != null){
            if (cur1.id < cur2.id){
//                mergeHead.next = cur1;
                cur1.next = mergeHead.next;
                mergeHead.next =cur1;
                cur1 = cur1.next;
            }else {
//                mergeHead.next = cur2;
                cur2.next =mergeHead.next;
                mergeHead.next =cur2;
                cur2 = cur2.next;

            }
//            System.out.println(mergeHead);
            mergeHead = mergeHead.next;
        }
        mergeHead.next = (cur1 == null) ? cur2 : cur1;

        return mergeHead;
    }

    /**
     * 显示单链表数据
     */
    public void showLinkedList(){
        if (head.next == null){
            System.out.println("单链表为空！");
            return;
        }
        SingleLinkedListNode p =  head.next;
        while (true){
            if (p == null){
                break;
            }
            System.out.println(p);
            p = p.next;
        }
    }

    public void showLinkedList(SingleLinkedListNode head){
        if (head.next == null){
            System.out.println("单链表为空！");
            return;
        }
        SingleLinkedListNode p =  head;
        while (p != null){
            System.out.println(p);
            p = p.next;
        }
    }


}

测试

public class SingleLinkedListTest {
    public static void main(String[] args) {
        SingleLinkedList list1= new SingleLinkedList();
        SingleLinkedList list2 = new SingleLinkedList();
        SingleLinkedList list3 = new SingleLinkedList();
        SingleLinkedListNode node1 = new SingleLinkedListNode(1, "we");
        SingleLinkedListNode node2 = new SingleLinkedListNode(2, "are");
        SingleLinkedListNode node3 = new SingleLinkedListNode(5, "family");
        SingleLinkedListNode node4 = new SingleLinkedListNode(7, "!");
        SingleLinkedListNode node5 = new SingleLinkedListNode(4, "?????");
        SingleLinkedListNode node6= new SingleLinkedListNode(2, "Were");
        // 测试单链表的合并
        list1.addNode(node2);
        list1.addNode(node3);
        list1.addNode(node4);
        System.out.println("first1:");
        list1.showLinkedList();
        list2.addNode(node1);
        list2.addNode(node5);
        System.out.println("second2");
        list2.showLinkedList();
        System.out.println("*******************");
        SingleLinkedListNode head = list3.mergeLinkedList(list1.getHead(), list2.getHead());
        list3.showLinkedList(head);