单链表的节点数查询和链表的反转，链表的倒序打印

单链表的节点数查询和链表的反转，链表的倒序打印

package 链表;

import java.util.Scanner;
import java.util.Stack;

/*
*链表是以接点的形式存储的
* 每个接点都有date域和指针next域：指向下一个接点
* 链表分带头节点与不带头的节点
* 链式存储
* */
/*
* 单链表的实现先创建一个head节点：中不存放任何数据只是引导链表的开始
* 先创建一个头节点后面我们每添加一个节点会向下移
* 通过辅助遍历进行遍历每一个节点
* */
public class Linked_list {
    public static void main(String[] args) {
        //进行测试
        //创建节点
        HerNode herNode2=new HerNode(9,"张飞","A");
        HerNode herNode3=new HerNode(10,"曹操","B");
        HerNode herNode4=new HerNode(8,"马超","C");
        HerNode herNode5=new HerNode(5,"刘备","K");
        HerNode herNode6=new HerNode(7,"宋飞","K");
        HerNode herNode7=new HerNode(7,"李逵","黑玄风");
        HerNodeList herNodeList=new HerNodeList();
        herNodeList.AddHerNode(herNode2);
        herNodeList.AdHerNode(herNode3);
        herNodeList.AdHerNode(herNode4);
        herNodeList.AdHerNode(herNode5);
        herNodeList.AdHerNode(herNode6);
        herNodeList.ChaoZhaoNerHod();
       /* herNodeList.DateNodeList(7);*/
        herNodeList.ShowHerNodeList();
        herNodeList.UpdateHerNode(herNode7);
        herNodeList.DateNodeList(7);
        herNodeList.ShuChuDaoShuNerod(2);
        System.out.println("链表的反转测试");
        FaiZhuangNEoHder(herNodeList.GetHerNode());
        System.out.println("链表的倒序输出，通过使用栈来进行实现，原本的链表并没有进行破坏……");
        ReserHerNOdeLIst(herNodeList.GetHerNode());
        System.out.println("输出链表");
        herNodeList.ShowHerNodeList();
        System.out.println("请输入你想要查找的人名");
        Scanner scanner = new Scanner(System.in);
        String name=scanner.next();
        herNodeList.SelectHerNodeName(name);
        System.out.println("请输入你想要查找的人名,修改的编号和昵称");
        String name2=scanner.next();
        int no1=scanner.nextInt();
        String noname=scanner.next();
        herNodeList.ModifyHerNodeList(name2,no1,noname);
       /* herNodeList.New_order();*/
        System.out.println("修改后的链表");
        herNodeList.ShowHerNodeList();

    }

//反转节点
//思路:
//先定义一个反转新节点ReNoHder后面
//从头到尾访问节点并取出，放在ReNoHder后面
//原来的head节点为head.next=ReNoHder.next;
//将单链表反转
public static void FaiZhuangNEoHder(HerNode herNode_a){
        if (herNode_a.next==null||herNode_a.next.next==null){//判断链表是否为空，或是只有一个节点
        System.out.println("链表为空或者链表只有一个节点无需反转");
        }else{
        //定义一个辅助指针进行，帮助我们进行编列缘来的链表
        HerNode cur=herNode_a.next;
        HerNode next=null;
        HerNode ResHerNode=new HerNode(0,"","");//定义一个新节点
        //遍历原来的链表每遍历一个就放在ResHerNode的最前面
        while(cur!=null){
        next=cur.next;
        cur.next=ResHerNode.next;
        ResHerNode.next=cur;
        cur=next;

        }
        herNode_a.next=ResHerNode.next;
        }
        }

    //将链表逆序输出
//思路一将链表进行反转，在进行遍历（会破坏原来的链表，对以后链表的使用不太友好（不建议））
//思路二将链表进行栈的压入，利用栈的先进后出进行，倒序输出链表
//创建一个HerNodeList来管理节点（就是一个链表）
//栈的特点先进后出
    public static void ReserHerNOdeLIst(HerNode herNode_b){
        if (herNode_b.next==null){
            System.out.println("链表为空……");
            return;
        }

            Stack<HerNode> herNodes = new Stack<>();//生成栈来进行压入节点
           //开始压入节点
            HerNode temp=herNode_b.next;//引入辅助变量进行遍历
            while (temp!=null){
                herNodes.push(temp);
                temp=temp.next;
            }
            //现在开始进出栈实现节点的逆序打印
            while (herNodes.size()>0){
                System.out.println(herNodes.pop());//出栈
            }
        }


}

class HerNodeList{
    //创建一个头节点不存放一个数据
    private HerNode herNode=new HerNode(0," "," ");
    //创建，节点
    //返回头节点
    public HerNode GetHerNode(){
        return herNode;
    }

    public void AddHerNode(HerNode herNode1){
        //因为头节点不能动所以用一个临时变量进行遍历，
        //遍历是为了找到节点为好添加下一个节点
        HerNode temp=herNode;//用一个temp（指针）指向第一个头节点
        //遍历整个链表找到最后
        while(temp.next!=null){
            temp=temp.next;
        }
       temp.next=herNode1;//指针是至指向下一个节点的，最后一个指针的next==null;

    }
    //显示节点，遍历整个链表
    public void ShowHerNodeList(){
        //判断链表是否为空，
        if(herNode.next==null){
            System.out.println("链表为为空……");
        }
        //因为头节点不能动所以的用一个变量进行遍历
        HerNode temp=herNode.next;
        while (temp!=null){//不能是temp.next！=null，这样就会只循环到倒数第二个节点就会终止运行
            System.out.println(temp);
            temp=temp.next;//节点后移
        }
    }
//求单链表的节点个数
    public void ChaoZhaoNerHod(){
        int count=0;//定义一个变量进行存放
        if (herNode.next==null){
            System.out.println("节点数为空"+count);
            return;
        }
        HerNode temp=herNode.next;
        while (temp!= null) {
            count++;
            temp = temp.next;

        }
        System.out.println("节点数为"+count);
    }
    //查找倒数第n个节点
    //链表只能正序遍历得找出是正序第几个
    //用总的去减去倒数第几位输出
    public void ShuChuDaoShuNerod(int n)
    {
        int cuont=0;//得到总节点的个数
        HerNode temp=herNode.next;
        while(temp!=null){
            cuont++;
            temp=temp.next;
        }
        int n1=cuont-n;
        temp=herNode.next;
        while (n1>0){
            temp=temp.next;
            n1--;
        }
        System.out.println(temp);
        System.out.println();
    }
    public void SelectHerNodeName(String name1){
      //创建一个变量，头节点不能动
        //判断链表是否为空，
        if(herNode.next==null){
            System.out.println("链表为为空……,查无此人");
            return;
        }
        HerNode temp=herNode.next;
        while (true){
            if (temp.name.equals(name1)){
                System.out.println("为您找到名字为"+name1+"的节点，节点信息为如下");
                System.out.println(temp);
                return ;
            }
            temp=temp.next;
            if (temp==null){
                System.out.println("已经查找到链表尾，链表中没有此人");
                return;
            }
        }

    }
    //根据编号来进修改节点信息
    public void UpdateHerNode(HerNode herNode1){
        if (herNode.next==null){
            System.out.println("链表为空……");
            return ;
        }
        HerNode temp=herNode.next;
        while(true){
            if (herNode1.no==temp.no){
              temp.anthername=herNode1.anthername;
              temp.name=herNode1.name;
              System.out.println("修改完成");
              return;
            }
            temp=temp.next;
            if (temp==null){
                System.out.println("已经查找链表尾，并未查找到此编号");
                return;
            }
        }
    }
    public void ModifyHerNodeList(String name1,int no1,String noname){
        //创建一个变量，头节点不能动
        //判断链表是否为空，
        if(herNode.next==null){
            System.out.println("链表为为空……,查无此人");
            return;
        }
        HerNode temp=herNode.next;
        while (true){
            if (temp.name.equals(name1)){
                System.out.println("为您找到名字为"+name1+"的节点，节点信息修改为如下");
                temp.no=no1;
                temp.anthername=noname;
                /*HerNode temp2=herNode;//编号更改从新排序
                while (true){
                    if (temp2.next == null){
                        break;
                    }
                    if (temp2.no>temp2.next.no){
                        HerNode temp3;
                        temp3=temp2.next;
                        temp2.next=temp2;
                        temp2=temp3;
                    }
                    temp2=temp2.next;
                }*/
                System.out.println(temp);
                return ;
            }
            temp=temp.next;
            if (temp==null){
                System.out.println("已经查找到链表尾，链表中没有此人");
                return;
            }
        }
    }

    //在添加节点时放在指定的位置
    //如果用排名则添加失败，返回提示
    public void AdHerNode(HerNode herNode8){
        //因为头节不能动所以的需要一个辅助指针去找到要添加的位置
        //得找到需要添加的位置的前一个位置让你要添加的节点被指向上一个节点的下一个指针;
        if (herNode.next == null){
            System.out.println("链表为空……");
            return;
        }
        HerNode temp=herNode;
        boolean flag=false;//标识添加节点
        while (true){
            if (temp.next==null){
                break;
            }
            if (temp.next.no>herNode8.no){//找到位置//跳出来会保留temp的位置temp下一个位置的值大于你想要添加的位值这样就会实现降序排列
                break;
            }
            if (temp.no==herNode8.no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            System.out.println("你想要的添加的位置编号"+herNode8.no+"已经存在不能添加");
        }else {
            herNode8.next=temp.next;
            temp.next=herNode8;

        }
    }
    //删除节点，
    //找到删除节点的上一个节点根据编号来进行
    public void DateNodeList(int no2){
        boolean flag=false;
        if (herNode.next==null){
            System.out.println("链表为空……");
            return;
        }
        HerNode temp=herNode.next;
        while(true){
            if (temp.next.no==no2){//找到你想要删除的信息节点的上一个节点
                flag=true;
               break;
            }

            temp=temp.next;
            if (temp.next==null){
                System.out.println("查找到链尾了，未能找到"+no2+"编号的节点");
               break;
            }

        }
        if (flag){
            temp.next=temp.next.next;
            System.out.println("删除成功");
        }
    }
 /*   public void New_order(){
        HerNode temp2=herNode;//编号更改从新排序
        while (temp2.next!= null) {
            if (temp2.no > temp2.next.no) {
                HerNode temp3;
                temp3 = temp2.next;
                temp2.next = temp2;
                temp2 = temp3;
            }
            temp2 = temp2.next;
        }
    }*/
}



//节点就是一个类的对象
//创建一个节点，每一个节点就是一个对象
class HerNode{
     public int no;
     public String name;
     public String anthername;
     public HerNode next;

    public HerNode(int no, String name, String anthername ) {
        this.no = no;
        this.name = name;
        this.anthername = anthername;
    }
    //为了显示明显从写Tostring方法

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

节点数为5
HerNode{no=5, name=‘刘备’, anthername=‘K’
HerNode{no=7, name=‘宋飞’, anthername=‘K’
HerNode{no=8, name=‘马超’, anthername=‘C’
HerNode{no=9, name=‘张飞’, anthername=‘A’
HerNode{no=10, name=‘曹操’, anthername=‘B’
修改完成
删除成功
HerNode{no=9, name=‘张飞’, anthername=‘A’

链表的反转测试
链表的倒序输出，通过使用栈来进行实现，原本的链表并没有进行破坏……
HerNode{no=5, name=‘刘备’, anthername=‘K’
HerNode{no=8, name=‘马超’, anthername=‘C’
HerNode{no=9, name=‘张飞’, anthername=‘A’
HerNode{no=10, name=‘曹操’, anthername=‘B’
输出链表
HerNode{no=10, name=‘曹操’, anthername=‘B’
HerNode{no=9, name=‘张飞’, anthername=‘A’
HerNode{no=8, name=‘马超’, anthername=‘C’
HerNode{no=5, name=‘刘备’, anthername=‘K’
请输入你想要查找的人名
张飞
为您找到名字为张飞的节点，节点信息为如下
HerNode{no=9, name=‘张飞’, anthername=‘A’
请输入你想要查找的人名,修改的编号和昵称
马超
4
标枪
为您找到名字为马超的节点，节点信息修改为如下
HerNode{no=4, name=‘马超’, anthername=‘标枪’
修改后的链表
HerNode{no=10, name=‘曹操’, anthername=‘B’
HerNode{no=9, name=‘张飞’, anthername=‘A’
HerNode{no=4, name=‘马超’, anthername=‘标枪’
HerNode{no=5, name=‘刘备’, anthername=‘K’

进程已结束,退出代码0