链表的创建

1、链表的信息的创建：

class HeroNode{
    public int no;      // 编号
    public String name;    // 姓名
    public String nickName;   // 昵称
    public HeroNode next;   // 指向下一个节点的指针

    // 构造器
    public HeroNode(int no,String name,String nickName ){
        this.no = no;                       // 定义值
        this.name = name;
        this.nickName = nickName;            //
    }

    // 为了显示方法，重写toString
    @Override
    public String toString(){
        return "HeroNode [no = " + no + ",name = " + name + ",nickName = " + nickName + "]";
    }
}

2.1、链表无序的增加数据

  public void add(HeroNode heroNode){
        // 因为head不能动，因此我们需要一个辅助遍历 temp
        HeroNode temp = head;

        while(temp.next != null){    // 获取到链表最后一个节点。
            temp = temp.next;
        }
        temp.next = heroNode;
    }

2.2、链表有序的增加数据

public void addList(HeroNode heaoNode){
        // head不能顺便移动，添加temp 作为辅助变量
        HeroNode temp = head;
        boolean flag = false;
        while(temp.next != null){
            if(temp.next.no > heaoNode.no){
                break;
            }
            if(temp.next.no == heaoNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            System.out.printf("链表中有该%d节点，不能进行增加。",heaoNode.no);
        }else{
            heaoNode.next = temp.next;
            temp.next = heaoNode;
        }
    }

3、链表的删除

 public void del(int no){
        HeroNode temp = head;
        boolean flag = false;     // 表示是否找到需要删除的节点
        while(temp.next != null){
            if(temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;   // temp 后移，遍历
        }
        if(flag){   // 是否找到该节点
            temp.next = temp.next.next;
        }else{
            System.out.printf("要删除的%d节点不存在\n",no);
        }
    }

4、链表的遍历

public void list(){
        // 判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空!");
            return;
        }
        //需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while(temp != null){
            System.out.println(temp);   // 输出节点信息
            temp = temp.next;
        }
    }

5、显示当前的链表的长度

public static int currentLength(HeroNode head){
        int length = 0;     // 记录链表的长度
        if(head.next == null){     // 没有节点数据，返回0
            return 0;
        }
        while(head.next != null){         // 遍历链表
            head = head.next;
            length++;
        }
        return length;       // 返回链表的长度
    }

6、获取链表的头结点

    public HeroNode getHead(){
        return head;
    }

7、更新链表中的数据

  public void update(HeroNode newHreoNode){
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据no编号
        HeroNode temp = head.next;      // 定义一个辅助的变量 temp
        boolean flag = false;       // 表示是否找到该节点。
        while(temp != null){
            if(temp.no == newHreoNode.no){   // 找到该节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        // 根据flag判断是否找到要修改的节点
        if(flag){
            temp.name = newHreoNode.name;
            temp.nickName = newHreoNode.nickName;
        }else{
            System.out.printf("没有找到编号 %d 的节点，不能修改\n",newHreoNode.no);
        }
    }

8、获取链表中的倒数某个节点的数据

 public static HeroNode findLastIndexNode(HeroNode head,int index){
        //如果链表为空，返回为Null
        if(head.next == null){
            return null;
        }
        //获取到第一次遍历得到链表的长度
        int size = currentLength(head);
        // 不在范围内的标签，返回为null
        if(index <= 0 || index > size){
            return null;
        }
        HeroNode temp = head.next;    // 创建辅助变量
        for(int i = 0; i < size - index; i++){     // 遍历到指定的节点
            temp = temp.next;
        }
        return temp;
    }

9、反转某个链表的数据

 public static void reverseLinkNode(HeroNode head){
        // 定义一个反转链表的变量
        HeroNode reverseNode = new HeroNode(0,"","");
        // 定义以临时的链表变量
        HeroNode temp = head.next;
        // 指向当前节点的下一个结点
        HeroNode next = null;
        if(temp.next == null || temp.next.next == null){
            return ;
        }
        while(temp != null){
            next = temp.next;  //保存下一个结点的信息
            temp.next = reverseNode.next;   // 将当前节点的下一个结点指向的是反转过来的链表的节点
            reverseNode.next = temp;        // 将反转链表的下一个结点指向当前的节点。添加当前节点的信息
            temp = next;
        }
        head.next = reverseNode.next;
    }

10、利用栈来逆序打印链表

public static void reversePrint(HeroNode head){
        if(head.next == null){
            return;    // 空链表，不能打印
        }
        //创建栈，将各个节点压入栈中
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode cur = head.next;
        // 将链表的所有节点压入栈
        while(cur != null){
            stack.push(cur);
            cur = cur.next;
        }

        while(stack.size() > 0){
            System.out.println(stack.pop());  // 栈的特点是先进后出
        }
    }

12、将两个有序列表合并

    public static void mergeLinked(HeroNode head,HeroNode rear){
        HeroNode temp = head;    // 作为一个指定插入的链表
        HeroNode cur = rear.next;     // 作为一个拆解开的链表进行插入。
        HeroNode next;
        while(cur != null){
            next = cur.next;
            while(temp.next != null){
                if(temp.next.no > cur.no){
                    break;
                }
                temp = temp.next;
            }
            cur.next = temp.next;
            temp.next = cur;
            cur = next;
        }
    }

总体的代码：

package com.Queue.day1;

import java.util.Stack;

public class obj1 {
    public  static void main(String[] args){
        // 先创建节点
//        HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");

        // 创建链表
        LinkedList linkedList = new LinkedList();

/*        linkedList.add(hero1);
        linkedList.add(hero2);
        linkedList.add(hero3);
        linkedList.add(hero4);*/

        //有序的链表数据添加
        linkedList.addList(hero2);
//        linkedList.addList(hero1);
        linkedList.addList(hero4);
        linkedList.addList(hero3);

//        linkedList.del(2);

        // 显示链表的当前长度
        System.out.println("当前链表的长度为：" + LinkedList.currentLength(linkedList.getHead()));

        // 查询倒数某个节点信息，并将之删除
/*        HeroNode res = LinkedList.findLastIndexNode(linkedList.getHead(),2);
        System.out.println("倒数第2个节点的数据为：" + res);*/

        //显示链表信息
        linkedList.list();

        //不修改链表的顺序进行对链表进行反转输出
//        LinkedList.reversePrint(linkedList.getHead());

        // 反转链表的顺序。
//        LinkedList.reverseLinkNode(linkedList.getHead());
//        linkedList.list();

        // 将两个有序的列表进行重新的合并排序

        HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
        HeroNode hero5 = new HeroNode(5,"李逵","黑旋风");
        HeroNode hero7 = new HeroNode(6,"杨志","青面兽");


        LinkedList linkedList2 = new LinkedList();
        linkedList2.add(hero1);
        linkedList2.add(hero5);
        linkedList2.add(hero7);

        linkedList2.list();

        LinkedList.mergeLinked(linkedList.getHead(),linkedList2.getHead());
        System.out.println("**********************合并后***********************");
        linkedList.list();
    }
}

class LinkedList{
    // 初始化头节点，头节点不需要存放具体的数据，只需要存放下一个地址。
    private HeroNode head = new HeroNode(0,"","");

    public HeroNode getHead(){
        return head;
    }
    // 添加节点到单链表
    // 当不考虑编号的顺序时，找到链表的最后一个节点，并将最后的一个节点指向新的结点。
    public void add(HeroNode heroNode){
        // 因为head不能动，因此我们需要一个辅助遍历 temp
        HeroNode temp = head;

        while(temp.next != null){    // 获取到链表最后一个节点。
            temp = temp.next;
        }
        temp.next = heroNode;
    }

    //有序的增加链表信息
    public void addList(HeroNode heaoNode){
        // head不能顺便移动，添加temp 作为辅助变量
        HeroNode temp = head;
        boolean flag = false;
        while(temp.next != null){
            if(temp.next.no > heaoNode.no){
                break;
            }
            if(temp.next.no == heaoNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            System.out.printf("链表中有该%d节点，不能进行增加。",heaoNode.no);
        }else{
            heaoNode.next = temp.next;
            temp.next = heaoNode;
        }
    }

    //修改节点的信息，根据no编号进行修改，即no编号不能修改
    // 根据newHeroNode的no来修改即可
    public void update(HeroNode newHreoNode){
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据no编号
        HeroNode temp = head.next;      // 定义一个辅助的变量 temp
        boolean flag = false;       // 表示是否找到该节点。
        while(temp != null){
            if(temp.no == newHreoNode.no){   // 找到该节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        // 根据flag判断是否找到要修改的节点
        if(flag){
            temp.name = newHreoNode.name;
            temp.nickName = newHreoNode.nickName;
        }else{
            System.out.printf("没有找到编号 %d 的节点，不能修改\n",newHreoNode.no);
        }
    }

    // 删除节点
    // 说明我们在比较时，是temp.next.no 和 需要删除的节点的no相比较。
    public void del(int no){
        HeroNode temp = head;
        boolean flag = false;     // 表示是否找到需要删除的节点
        while(temp.next != null){
            if(temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;   // temp 后移，遍历
        }
        if(flag){   // 是否找到该节点
            temp.next = temp.next.next;
        }else{
            System.out.printf("要删除的%d节点不存在\n",no);
        }
    }

    // 显示链表[遍历]
    public void list(){
        // 判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空!");
            return;
        }
        //需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while(temp != null){
            System.out.println(temp);   // 输出节点信息
            temp = temp.next;
        }
    }

    //获取当前的链表的长度
    public static int currentLength(HeroNode head){
        int length = 0;     // 记录链表的长度
        if(head.next == null){     // 没有节点数据，返回0
            return 0;
        }
        while(head.next != null){         // 遍历链表
            head = head.next;
            length++;
        }
        return length;       // 返回链表的长度
    }

    // 获取倒数的某个节点
    public static HeroNode findLastIndexNode(HeroNode head,int index){
        //如果链表为空，返回为Null
        if(head.next == null){
            return null;
        }
        //获取到第一次遍历得到链表的长度
        int size = currentLength(head);
        // 不在范围内的标签，返回为null
        if(index <= 0 || index > size){
            return null;
        }
        HeroNode temp = head.next;    // 创建辅助变量
        for(int i = 0; i < size - index; i++){     // 遍历到指定的节点
            temp = temp.next;
        }
        return temp;
    }

    //反转链表中的数据
    public static void reverseLinkNode(HeroNode head){
        // 定义一个反转链表的变量
        HeroNode reverseNode = new HeroNode(0,"","");
        // 定义以临时的链表变量
        HeroNode temp = head.next;
        // 指向当前节点的下一个结点
        HeroNode next = null;
        if(temp.next == null || temp.next.next == null){
            return ;
        }
        while(temp != null){
            next = temp.next;  //保存下一个结点的信息
            temp.next = reverseNode.next;   // 将当前节点的下一个结点指向的是反转过来的链表的节点
            reverseNode.next = temp;        // 将反转链表的下一个结点指向当前的节点。添加当前节点的信息
            temp = next;
        }
        head.next = reverseNode.next;
    }

    //利用栈来逆序打印链表
    public static void reversePrint(HeroNode head){
        if(head.next == null){
            return;    // 空链表，不能打印
        }
        //创建栈，将各个节点压入栈中
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode cur = head.next;
        // 将链表的所有节点压入栈
        while(cur != null){
            stack.push(cur);
            cur = cur.next;
        }

        while(stack.size() > 0){
            System.out.println(stack.pop());  // 栈的特点是先进后出
        }
    }

    //和并两个有序的链表
    public static void mergeLinked(HeroNode head,HeroNode rear){
        HeroNode temp = head;    // 作为一个指定插入的链表
        HeroNode cur = rear.next;     // 作为一个拆解开的链表进行插入。
        HeroNode next;
        while(cur != null){
            next = cur.next;
            while(temp.next != null){
                if(temp.next.no > cur.no){
                    break;
                }
                temp = temp.next;
            }
            cur.next = temp.next;
            temp.next = cur;
            cur = next;
        }
    }
}


class HeroNode{
    public int no;      // 编号
    public String name;    // 姓名
    public String nickName;   // 昵称
    public HeroNode next;   // 指向下一个节点

    // 构造器
    public HeroNode(int no,String name,String nickName ){
        this.no = no;                       // 定义值
        this.name = name;
        this.nickName = nickName;            //
    }

    // 为了显示方法，重写toString
    @Override
    public String toString(){
        return "HeroNode [no = " + no + ",name = " + name + ",nickName = " + nickName + "]";
    }
}