单链表（SingleLinkedList）

链表

 

 

带头节点的链表：

 

 

 

//定义一个节点
class Node{
    public int no;
    public String name;
    public Node next;
    
    public Node(int no,String name) {
        this.no = no;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Node [no=" + no + ", name=" + name + "]";
    }    
    
}

//定义一个单链表
class SingleLinkedList{
    //定义一个头节点,作用是表示单链表的头
    private Node headNode = new Node(0,"");
}

//没有顺序的往链表后面加节点
    //思路：
    //1找到没有写一个节点的节点，把新节点赋值给此节点的下一个节点
    public void addNode(Node node) {
        Node temp = headNode;
        while(true) {
            if (temp.next == null) {
                temp.next= node;
                System.out.println("Add node"+ node+"successfully!");
                break;
            }
            //如果不是最后一个则接着往下找
            temp = temp.next;
            
        }
    }

//有序插入节点
public void addOrderNode(Node node) {
        Node temp = headNode;//因为单链表，所以temp要为添加节点的前一个节点，否则添加不了
        boolean isFind = false;//定义一个标识来判断是否找到合适位置插入
        while(!isFind) {
            if(temp.next == null) {//如果已经到最后一个节点了，则直接插入
                temp.next = node;
                isFind = true;
            }
            else if(temp.next.no>node.no) {//如果找到一个节点比插入的节点大，则在找到的这个节点的前面插入数据
                node.next = temp.next;
                temp.next = node;
                isFind = true;
            }else if(temp.next.no == node.no){
                System.out.println("The node is already exist.");
                isFind = true;
            }else {
                temp = temp.next;
            }
        }
    }

//更新节点，只需要更新name,要根据no来找到对应的节点再更新
    public void updateNode(Node node) {
        Node temp = headNode.next;

　　　　　　if (temp == null) {
　　　　　　　　System.out.println("The linkedList is empty!");
　　　　　　　　return;
　　　　　　}

　　　　　while(true) {
            if(temp == null) {
                System.out.println("Cannot find the node!");
                break;
            }else if(temp.no ==node.no) {
                temp.name = node.name;
                break;
            }else {
                temp = temp.next;
            }
        }
    }

//删除节点    
public void deleteNode(Node node) {
　　　//因为我单链表，只能找到下一个节点，找不到上一个节点
　　　//因为要把当前节点的下一个节点重新赋值，所以这里要初始化一个临时变量为头节点而不是头节点的下一个节点
    Node temp = headNode;//这里注意临时变量要初始化为头节点而不是头节点的下一个节点
    while(true) {
        if(temp.next == null) {
        　　System.out.println("Cannot find the node!");
       　　 break;
    　　}else if (temp.next.no == node.no) {
        　　temp.next = temp.next.next;
        　　break;
    　　}else {
       　　 temp = temp.next;
    　　}
    }        
}        

 单链表的反转：

1.遍历法：

思路：把原来的链表进行遍历，每遍历出来一个节点就放入新链表的头节点的下一个节点

    public void reverse(Node headNode) {
        if(headNode.next ==null||headNode.next.next == null) {
            return;
        }
        //新链表的头节点
        Node newHeadNode = new Node(0, "");
        Node cur = headNode.next;
        Node next = null;
        while(cur !=null) {
            next = cur.next;
            cur.next = newHeadNode.next;
            newHeadNode.next = cur;
            cur = next;//把节点往后移一个，所以提前要把cur.next 节点保存起来                        
        }
        headNode.next = newHeadNode.next;//最后需要把原来的链表的头节点指向新的链表的头节点        
    }

 2.使用栈来遍历

    //使用栈来逆序打印单链表
    public void reversePrint(Node headNode) {
        if (headNode.next == null) {
            return;//空链表，直接返回
        }
        Node temp = headNode.next;
        Stack<Node> stack = new Stack<Node>();//定义一个stack来存放各个节点
        while(temp!=null) {
            stack.add(temp);
            temp = temp.next;
        }
        while(stack.size()>0) {
            System.out.println(stack.pop());
        }        
        
    }