【数据结构与算法】单链表

import java.util.Stack;

public class singleLinkedListDemo {
    public static void main(String[] args) {
        StuNode stu1 = new StuNode(2, "张三", "小三");
        StuNode stu2 = new StuNode(4, "李四", "小四");
        StuNode stu3 = new StuNode(6, "王五", "小五");
        StuNode stu4 = new StuNode(7, "赵六", "小六");
        SingleLinkedList sll = new SingleLinkedList();
        sll.addByOrder(stu1);
        sll.addByOrder(stu4);
        sll.addByOrder(stu2);
        sll.addByOrder(stu3);
        sll.list();
        StuNode stu5 = new StuNode(1, "张三", "小三");
        StuNode stu6 = new StuNode(3, "李四", "小四");
        StuNode stu7 = new StuNode(6, "王五", "小五");
        StuNode stu8 = new StuNode(8, "赵六", "小六");
        SingleLinkedList sll2 = new SingleLinkedList();
        sll2.addByOrder(stu5);
        sll2.addByOrder(stu6);
        sll2.addByOrder(stu7);
        sll2.addByOrder(stu8);
        sll2.list();
        StuNode stuNode = mergeList(sll.getHead(), sll2.getHead());
        while (stuNode != null){
            System.out.println(stuNode);
            stuNode = stuNode.next;
        }
//        StuNode newStu4 = new StuNode(4, "赵小六", "小六六");
//        sll.update(newStu4);
//        sll.list();
//        sll.del(1);
//        sll.list();
//        System.out.println(getLastIndexNode(sll.getHead(), 1));
//        reverseList(sll.getHead());
//        sll.list();
//        reversePrint(sll.getHead());


    }
    //链表有效个数
    public static int getLength(StuNode head){
        if(head.next == null){
            return 0;
        }
        StuNode temp = head.next;
        int len = 0;
        while (true){
            len++;
            if(temp.next == null){
                break;
            }
            temp = temp.next;
        }
        return len;
    }

    //查找单链表中倒数第K个节点
    public static StuNode getLastIndexNode(StuNode head, int index){
        if(head.next == null){
            return null;
        }
        int size = getLength(head);//获得总长度
        if(index <= 0 || index > size){
            return null;
        }
        StuNode temp = head.next;
        for (int i = 0; i < size - index; i++) {
            temp = temp.next;
        }
        return temp;
    }

    //反转单链表
    public static void reverseList(StuNode head){
        if(head.next == null || head.next.next == null){
            return;
        }
        StuNode temp = head.next;
        StuNode next = null;
        StuNode reverseHead =  new StuNode(0,"","");
        //遍历原链表的每个节点，将其取出放在reverseHead的最前端
        while(temp!=null){
            next = temp.next;
            temp.next = reverseHead.next;
            reverseHead.next = temp;
            temp = next;//后移
        }
        head.next = reverseHead.next;
    }

    //逆向打印链表
    public static void reversePrint(StuNode head){
        if(head.next == null){
            return;
        }
        Stack<StuNode> stack = new Stack<StuNode>();
        StuNode temp = head.next;
        while(temp != null){
            stack.push(temp);
            temp = temp.next;
        }
        while (stack.size() > 0){
            System.out.println(stack.pop());
        }
    }

    //合并两个有序的单链表
    public static StuNode mergeList(StuNode head1,StuNode head2){
        if(head1.next == null){
            return head2;
        }
        if(head2.next == null){
            return head1;
        }
        StuNode temp1 = head1.next;
        StuNode temp2 = head2.next;
        StuNode merge = new StuNode(0,"","");
        StuNode temp = merge;//头不动，用临时
        while(temp1 != null || temp2 != null){
            if(temp1 != null && temp2 !=null && temp1.no <= temp2.no){
                temp.next = temp1;
                temp1 = temp1.next;
            }else if(temp1 != null && temp2 !=null){
                temp.next = temp2;
                temp2 = temp2.next;
            }else if(temp1 == null && temp2 != null){
                temp.next = temp2;
                temp2 = temp2.next;
            }else if(temp2 == null && temp1 != null){
                temp.next = temp1;
                temp1 = temp1.next;
            }
            temp = temp1.next;
        }
        return merge.next;
    }


}
//定义SingleLinkedList
class SingleLinkedList{
    //初始化头节点
    private StuNode head = new StuNode(0,"","");

    public StuNode getHead() {
        return head;
    }

    //添加节点到单向链表
    public void add(StuNode stuNode){
        //head节点不能动，用temp辅助
        StuNode temp = head;
        while (true){
            if(temp.next == null){
                break;
            }
            temp = temp.next;
        }
        temp.next = stuNode;
    }

    //添加到指定位置
    public void addByOrder(StuNode stuNode){
        StuNode temp = head;
        boolean flag = false;
        while (true){
            if (temp.next == null){
                break;
            }
            if (temp.next.no > stuNode.no){
                break;
            }else if(temp.next.no == stuNode.no){
                flag = true;//说明已存在
                break;
            }
            temp = temp.next;
        }
        if(flag){
            System.out.println("编号"+stuNode.no+"已经存在！不能添加");
        }else {
            //插入到链表中
            stuNode.next = temp.next;
            temp.next = stuNode;
        }
    }

    //删除节点，被删除的节点会被垃圾回收机制回收   temp.next = temp.next.next
    public void del(int no){
        StuNode temp = head;
        boolean flag = false;//是否找到删除节点
        while(true){
            if (temp.next == null){
                break;
            }
            if(temp.next.no == no){//待删除的前一个节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.next = temp.next.next;
        }else{
            System.out.println(no+"节点不存在！");
        }
    }

    //修改节点的信息,no不能改
    public void update(StuNode newStuNode) {
        if(head.next == null){//判断是否为空
            System.out.println("链表为空！");
            return;
        }
        StuNode temp = head.next;
        boolean flag = false;//表示是否找到该节点
        while(true){
            if(temp == null){
                break;
            }
            if(temp.no == newStuNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.name = newStuNode.name;
            temp.nickname = newStuNode.nickname;
        }else{
            System.out.println("没有找到编号为"+newStuNode.no+"的节点！修改失败！");
        }
    }

    //显示链表
    public void list(){
        if(head.next == null){
            System.out.println("链表为空！");
            return;
        }
        StuNode temp = head.next;
        while (true){
            if(temp == null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }
}

//定义stuNode节点，每个对象就是一个节点
class StuNode{
    public int no;
    public String name;
    public String nickname;
    public StuNode next;

    public StuNode(int no,String name, String nickname){
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    @Override
    public String toString() {
        return "stuNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}