链表

 

1.单链表

　　（1）单链表的增、删、改、查、查找倒数第K个节点、链表反转

package LianBiao;

import java.util.Stack;

/*
 * 单链表：头节点不存数据，只存下一节点地址
 * 编号唯一
 */
public class LinkedListDemo1 {
    public static void main(String[] args){
        MyLinkedList1 t=new MyLinkedList1();
        
        t.addNodeByNo(1, "宋江", "及时雨");
        t.addNodeByNo(3, "吴用", "智多星");
        t.addNodeByNo(2, "卢俊义", "玉麒麟");
        t.addNodeByNo(4, "林冲", "豹子头");
        t.addNodeByNo(5, "武松", "行者");
        t.addNodeByNo(6, "鲁智深", "花和尚");
        t.show();
        System.out.println("-------------");
        //System.out.println("链表长度："+t.getListLength());
        //System.out.println("-------------");
        //t.getLastNode(8);
        
        //t.reverseList();
        t.reverseList1();
    
        //t.findNodeByNo1(4);
        
        //t.findNodeByName1("宋江");
        //System.out.println("-----------------");
        //t.deleteNode1(5);
        //t.show();
        
    }

}

class Node1{
    
     int no;
     String name;
     String nickName;
     Node1 next;
    public Node1(int no, String name, String nickName, Node1 next) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
        this.next = next;
    }
    @Override
    public String toString() {
        return "座次: " + no + ", 姓名: " + name + ", 绰号: " + nickName;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((next == null) ? 0 : next.hashCode());
        result = prime * result + ((nickName == null) ? 0 : nickName.hashCode());
        result = prime * result + no;
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Node1 other = (Node1) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (next == null) {
            if (other.next != null)
                return false;
        } else if (!next.equals(other.next))
            return false;
        if (nickName == null) {
            if (other.nickName != null)
                return false;
        } else if (!nickName.equals(other.nickName))
            return false;
        if (no != other.no)
            return false;
        return true;
    }
    
    
    
}

class MyLinkedList1{
    
    Node1 head=new Node1(0,"","",null);
    
    
    
    //添加节点
    public void addNode(int no, String name, String nickName){
        Node1 temp=head;
        //遍历整个链表，寻找尾节点
        while(true){
            if(temp.next==null){
                break;
                }else{
                    temp=temp.next;
                }
            }
            
            temp.next=new Node1(no,name,nickName,null);
        }
    
    
    
    
    //添加节点，使得添加进去的数据按照编号由小到大排序，这样取出来时直接就是排好的数据，不需要在遍历功能的代码里再想办法实现排序，有点类似set。
    //同时保证编号的唯一性
    public void addNodeByNo(int no, String name, String nickName){
        Node1 temp=head;
        boolean flag=false;
        while(true){
            if(temp.next==null){
                break;
            }else{
                if(temp.next.no==no){
                    flag=true;
                    break;
                }else{
                    if(temp.next.no>no){
                        break;
                    }else{
                        temp=temp.next;
                    }
                }
            }
        }
        if(flag==true){
            System.out.println("编号重复!!!");
        }else{
            temp.next=new Node1(no,name,nickName,temp.next);
        }
    }
    
    
    
    
    //遍历整个链表：因为头节点只存下一节点的地址而不存数据，所以从头节点的下一个节点开始遍历
    public void show(){
        if(head.next==null){
            System.out.println("链表为空!!!");
        }else{
           Node1 temp=head.next;//这里的指针指的是head.next
           while(true){
               if(temp==null){
                   break;
               }else{
                   System.out.println(temp);
                   temp=temp.next;
               }
           }
        }
    }
    
    
    
    
    
    //删除节点(根据编号删除)---成功实现，代码有点复杂，需要优化代码
    public void deleteNode(int no){
        if(head.next==null){
            System.out.println("链表为空!!!");
        }else{
            Node1 temp=head;//这里的指针指的是head
            while(true){
                if(temp.next==null){
                    if(temp.no!=no){
                    System.out.println("无此人!!!");
                    break;
                    }else{
                        temp=null;
                        break;
                    }
                }else{
                    if(temp.next.no==no){
                        temp.next=temp.next.next;
                        break;
                    }else{
                        temp=temp.next;
                    }
                }
            }
        }
    }
    
    
    
    
    //优化：删除节点功能(根据编号删除)
    
    public void deleteNode1(int no){
        if(head.next==null){
            System.out.println("链表为空!!!");
        }else{
            boolean flag=false;;
            Node1 temp=head;//这里的指针指的是head
            while(true){
                if(temp.next==null){
                    break;
                }else{
                    if(temp.next.no==no){
                        //temp.next=temp.next.next;
                        flag=true;
                        break;
                    }else{
                        temp=temp.next;
                    }
                }
            }
            if(flag){
                temp.next=temp.next.next;
            }else{
                System.out.println("无此人!!!");
            }
        }
    }
    
    
    
    
    //修改节点数据(根据编号修改)---成功实现，代码有点复杂，需要优化代码
    public void modifyNode(int no,String name,String nickName){
        if(head.next==null){
            System.out.println("链表为空!!!");
        }else{
            Node1 temp=head.next;//这里的指针指的是head.next
            while(true){
                if(temp.next==null){
                    if(temp.no!=no){
                        System.out.println("无此人!!!");
                        break;
                    }else{
                        temp.name=name;
                        temp.nickName=nickName;
                        break;
                    }
                }else{
                    if(temp.no==no){
                        temp.name=name;
                        temp.nickName=nickName;
                        break;
                    }else{
                        temp=temp.next;
                    }
                }
            }
        }
    }
    
    
    //优化：修改节点数据(根据编号修改)
    public void modifyNode1(int no,String name,String nickName){
        if(head.next==null){
            System.out.println("链表为空!!!");
        }else{
            boolean flag;//设置标志，用来表示是否找到相应数据
            Node1 temp=head.next;//这里的指针指的是head.next
            while(true){
                if(temp==null){
                    flag=false;
                }else{
                    if(temp.no==no){
                        flag=true;
                        break;
                    }else{
                        temp=temp.next;
                    }
                }
            }
            
            if(flag==true){
                temp.name=name;
                temp.nickName=nickName;
            }else{
                System.out.println("无此人!!!");
            }
        }
    }
        
    
    
    
        //查询节点(根据编号:编号拥有唯一性)---成功实现，代码有点复杂，需要优化代码
        public void findNodeByNo(int no){
            if(head.next==null){
                System.out.println("链表为空!!!");
            }else{
                Node1 temp=head.next;
                while(true){
                    if(temp.next==null){
                        if(temp.no==no){
                            System.out.println(temp);
                            break;
                            
                        }else{
                            System.out.println("查无此人");
                            break;
                        }
                    }else{
                        if(temp.no==no){
                            System.out.println(temp);
                        }else{
                            temp=temp.next;
                        }
                    }
                }
                
            }
            
        }
        
        
        
        
        //优化：查询节点(根据编号:编号拥有唯一性)
        public void findNodeByNo1(int no){
            if(head.next==null){
                System.out.println("链表为空!!!");
            }else{
                Node1 temp=head.next;
                while(true){
                    if(temp==null){
                        System.out.println("查无此人");
                        break;
                    }else{
                        if(temp.no==no){
                            System.out.println(temp);
                            break;
                        }else{
                            temp=temp.next;
                        }
                    }
                }
                
            }
            
        }
        
        
        
        
        
        //查询节点(根据姓名，注：姓名不唯一)---成功实现，代码有点复杂，需要优化代码
        
        public void findNodeByName(String name){
            int count=0;
            if(head.next==null){
                System.out.println("链表为空!!!");
            }else{
                Node1 temp=head.next;
                while(true){
                if(temp.next==null){
                    if(temp.name.equals(name)){
                        System.out.println(temp);
                        count++;
                        break;
                   }else{
                       break;
                   }
                }else{
                    if(temp.name.equals(name)){
                        System.out.println(temp);
                        count++;
                        temp=temp.next;
                    }else{
                        temp=temp.next;
                        }
                            }
                        }
                if(count==0){
                    System.out.println("没有关于"+name+"的信息!!!");
                }
                        
                    }
                    
                }
                
        
        
        
        
        //查询节点(根据姓名，注：姓名不唯一)
        public void findNodeByName1(String name){
            if(head.next==null){
                System.out.println("链表为空!!!");
            }else{
                boolean flag=false;//用来标识是否找到相应的数据
                Node1 temp=head.next;
                while(true){
                if(temp==null){
                    break;
                }else{
                    if(temp.name.equals(name)){
                        flag=true;
                        System.out.println(temp);
                        temp=temp.next;
                    }else{
                        temp=temp.next;
                        }
                            }
                        }
                if(flag==false){
                    System.out.println("无此人!!!");
                }
                        
                    }
            }
        
        
        
        
        
                
        //查询节点(根据绰号,绰号没有唯一性)---成功实现，代码有点复杂，需要优化代码
        public void findNodeBynickName(String nickName){
            int count=0;
            if(head.next==null){
                System.out.println("链表为空!!!");
              }else{
                    Node1 temp=head.next;
                    while(true){
                    if(temp.next==null){
                        if(temp.nickName.equals(nickName)){
                            System.out.println(temp);
                            count++;
                            break;
                        }else{
                            break;
                        }
                    }else{
                        if(temp.nickName.equals(nickName)){
                            System.out.println(temp);
                            count++;
                            temp=temp.next;
                        }else{
                            temp=temp.next;
                              }
                         }
                    }
                        
                }
            if(count==0){
                System.out.println("没有关于"+nickName+"的信息!!!");
            }
                    
        }
        
        
        
        //优化：查询节点(根据绰号,绰号拥有唯一性)
        public void findNodeBynickName1(String nickName){
            if(head.next==null){
                System.out.println("链表为空!!!");
              }else{
                      boolean flag=false;//用来标识是否找到相应的数据
                    Node1 temp=head.next;
                    while(true){
                    if(temp==null){
                        break;
                    }else{
                        if(temp.nickName.equals(nickName)){
                            flag=true;
                            System.out.println(temp);
                            temp=temp.next;
                        }else{
                            temp=temp.next;
                              }
                         }
                    }
                    
                    if(flag==false){
                        System.out.println("无此人!!!");
                    }
                        
                }
            
                    
        }
        
        //获取链表中的有效节点个数
        
        public int getListLength(){
            int count=0;
            if(head.next==null){
                System.out.println("链表为空!!!");
                return 0;
            }else{
                Node1 temp=head.next;
                while(true){
                    if(temp!=null){
                        count++;
                        temp=temp.next;
                    }else{
                        break;
                    }
                }
                //System.out.println("有效节点个数为:"+count);
                return count;
            }
        }
        
        
        
        //获取链表中倒数第k个节点
        public void getLastNode(int index){
            int size=getListLength();
            if(index<1||index>size){
                System.out.println("超出范围");
            }else{
                Node1 temp=head.next;
                for(int i=0;i<size-index;i++){
                    temp=temp.next;
                }
                System.out.println("获取倒数第"+index+"节点:");
                System.out.println(temp);
            }
            
        }
        
        
        //反转链表(改变原链表的顺序，使其也为反向)
        public void reverseList(){
            MyLinkedList1 reverseList=new MyLinkedList1();
            if(head.next==null){
                System.out.println("链表为空!!!");
            }else{
                Node1 temp=head.next;
                Node1 save;
                Node1 header=new Node1(0,"","",null);
                while(true){
                    if(temp==null){
                        break;
                    }else{
                        save=temp.next;
                        /*
                        temp.next=temp;
                        temp=save;    
                        */
                        temp.next=header.next;
                        header.next=temp;
                        temp=save;
                    }
                }
                reverseList.head.next=header.next;
                reverseList.show();
                
            }
            

        }

        
        //反转链表(不改变原链表的结构)---使用栈
        public void reverseList1(){
            if(head.next==null){
                System.out.println("链表为空!!!");
            }else{
                //创建一个栈
                Stack stack=new Stack();
                int count=0;
                Node1 temp=head.next;//这里的指针指的是head.next
                   while(true){
                       if(temp==null){
                           break;
                       }else{
                          stack.add(temp);
                          count++;
                           temp=temp.next;
                       }
                   }
                   for(int i=0;i<count;i++){
                      System.out.println( stack.pop());
                   }
            }
        }
        
    
    
}

　　（2）链表排序

package XianXingBiao;
/*
 * 使用链表:
 * 未做完，比较大小部分有问题
 */
import java.util.LinkedList;
import java.util.List;

public class PaiXuTest2 {
    public static void main(String[] args){
        int[] a={1,3,5,7,9};
        int[] b={2,6,8,10,12};
        NewLinkedList l1=new NewLinkedList();
        NewLinkedList l2=new NewLinkedList();
        
        for(int i=0;i<a.length;i++){
            l1.addNode(a[i]);;
        }
        
        for(int j=0;j<a.length;j++){
            l2.addNode(b[j]);
        }
        l1.showLink();
        l2.showLink();
        
        /*
        PaiXuTest2 t=new PaiXuTest2();
        t.paiXu1(l1, l2);
        */
        
        
        
        
        
        
        
    
    }
    
    //排序:未成功，结果里面有错误(一定要注意：若要操作某个节点，应当将指针指在它的前一个节点，和删除节点的道理一样)
        public void paiXu(NewLinkedList a,NewLinkedList b){
            System.out.println("排序如下：");
            Node ta=a.head.next;
            Node tb=b.head.next;
            Node temp;
            NewLinkedList c=new NewLinkedList();
            temp=c.head;
            
            while(ta.next!=null&&tb.next!=null){
                if(ta.data<tb.data){
                    temp.next=ta;
                    ta=ta.next;
                    temp=temp.next;
                }else{
                    temp.next=tb;
                    tb=tb.next;
                    temp=temp.next;
                }
            }
            
            if(ta.next!=null){
                temp.next=ta;
              }
            if(tb.next!=null){
                temp.next=tb;
            }
            c.showLink();
            
            
        }
        
        //排序:成功(一定要注意：若要操作某个节点，应当将指针指在它的前一个节点，和删除节点的道理一样)
                public void paiXu1(NewLinkedList a,NewLinkedList b){
                    System.out.println("排序如下：");
                    Node ta=a.head.next;
                    Node tb=b.head.next;
                    Node temp;
                    NewLinkedList c=new NewLinkedList();
                    temp=c.head;
                    
                    while(ta!=null&&tb!=null){
                        if(ta.data<tb.data){
                            temp.next=ta;
                            ta=ta.next;
                            temp=temp.next;
                        }else{
                            temp.next=tb;
                            tb=tb.next;
                            temp=temp.next;
                        }
                    }
                    
                    if(ta!=null){
                        temp.next=ta;
                      }
                    if(tb!=null){
                        temp.next=tb;
                    }
                    c.showLink();
                    
                    
                }

        
        //运行结果为空，未查找问题，回头查找问题
        public void paiXu2(NewLinkedList a,NewLinkedList b){
            System.out.println("排序如下：");
            Node ta=a.head.next;
            Node tb=b.head.next;
            Node temp;
            NewLinkedList c=new NewLinkedList();
            temp=c.head.next;
            //c.head.next=temp;
            while(ta!=null&&tb!=null){
                if(ta.data<tb.data){
                    System.out.println("--------------------");
                    temp=ta;
                    System.out.println(c.head.next);
                    System.out.println("temp=ta="+temp);
                    System.out.println("temp.next=ta.next"+temp.next);
                    ta=ta.next;
                    //System.out.println("ta-->"+ta);
                    temp=temp.next;
                    System.out.println("temp:"+temp);
                    System.out.println("--------------------");
                }else{
                    System.out.println("**********");
                    temp=tb;
                    System.out.println("temp=tb="+temp);
                    System.out.println("temp.next=tb.next"+temp.next);
                    //System.out.println("tb"+tb);
                    tb=tb.next;
                    //System.out.println("tb.next"+tb.next);
                    temp=temp.next;
                    System.out.println("temp:"+temp);
                    System.out.println("**********");
                    
                }
            }
            
            if(ta!=null){
                temp=ta;
                System.out.println("--------"+temp);
              }
            if(tb!=null){
                temp=tb;
                System.out.println("*******"+temp);
            }
            System.out.println(c.head.next);
            c.showLink();
            
            
        }
        
        
        
        
}

class Node{
    int data;
    Node next;

    public Node(){
        
    }
    
    public Node(int data,Node next){
        this.data=data;
        this.next=next;
    }

    @Override
    public String toString() {
        return " " + data ;
    }

    
    
    
}

class NewLinkedList{
    
    Node head=new Node(-1,null);
    
    //增加节点
    public void addNode(int data){
        
            Node temp=head;
            while(true){
                if(temp.next==null){
                    temp.next=new Node(data,null);
                    break;
                }else{
                    temp=temp.next;
                }
            }
        }
    
    
    //遍历链表:因为头节点只存下一节点的地址而不存数据，所以从头节点的下一个节点开始遍历
    public void showLink(){
        if(head.next==null){
            System.out.println("链表为空!!!");
        }else{
            Node temp=head.next;
            while(true){
                if(temp.next==null){ //最后一个节点，打印后直接跳出循环
                    System.out.print(temp);
                    break;
                }else{
                    System.out.print(temp+",");
                    temp=temp.next;
                }
            }
        }
        System.out.println();
    }
    
    
    
    /*
    //排序:
    public  static void paiXu(NewLinkedList a,NewLinkedList b){
        System.out.println("排序如下：");
        Node ta=new Node(-1,null);
        Node tb=new Node(-1,null);
        Node temp=new Node(-1,null);
        NewLinkedList c=null;
        c.head=temp;
        ta=a.head.next;
        tb=b.head.next;
        
        {
            if(ta.data<tb.data){
                temp.next=ta;
                temp=temp.next;
                ta=ta.next;
            }else{
                temp.next=tb;
                temp=temp.next;
                tb=tb.next;
                
            }
        }while(ta.next==null&&tb.next ==null)
        
        
            
        if(ta.next!=null){
            temp.next=ta;
          }
        if(tb.next!=null){
            temp.next=tb;
        }
        c.showLink();
        
        
    }
    
    */
    
    
    
}

 2.双向链表

2.1单向链表的缺点

　　（1）查找方向只能是一个方向；

　　（2）单向链表不能自我删除，所以单向链表删除节点时（记为B），只能先找到待删除节点的上一个节点（记为A），然后再让A.next指向B的下一个节点（记为C），即：A.next=A.next.next，完成删除B的任务，最后B会被垃圾回收机制回收；

 

　　而双向链表可以弥补单链表的缺点：

　　双向链表可以双向查找节点；双向链表可以进行自我删除

2.2 双向链表的增、删、改、查

 

package LianBiao;
/*
 * 双向链表的增删改查
 * 基本就是在单向链表的基础上做修改
 * 
 */
public class DoubleLinkedListDemo {
    public static void main(String[] args){
        
        DoubleLinkedList dt=new DoubleLinkedList();
    
        dt.addNode(1, "宋江", "及时雨");
        dt.addNode(2, "卢俊义", "玉麒麟");
        dt.addNode(3, "吴用", "智多星");
        dt.addNode(4, "公孙胜", "入云龙");
        dt.addNode(5, "林冲", "豹子头");
        dt.addNode(6, "鲁智深", "花和尚");
        dt.addNode(7, "武松", "行者");
        dt.addNode(8, "李逵", "黑旋风");
        dt.addNode(9, "杨志", "青面兽");
        
        /*
        System.out.println("---------------------------");
        dt.show();
        System.out.println("---------------------------");
        dt.backShow();
        System.out.println("---------------------------");
        dt.showHeadTail();
        System.out.println("---------------------------");
        */
        
        //dt.findNodeDouble(5);
        //dt.deleteNodeDouble(8);
         dt.show();
         System.out.println("--------------------");
         dt.modifyNodeDouble(9, "刘备", "玄德");
        dt.show();
         System.out.println("dt.tail---->"+dt.tail);
    }

}

class HeroNode{
    int no;
    String name;
    String nickName;
    HeroNode next;
    HeroNode pre;
    
    

    public HeroNode(int no, String name, String nickName, HeroNode next, HeroNode pre) {
        super();
        this.no = no;
        this.name = name;
        this.nickName = nickName;
        this.next = next;
        this.pre = pre;
    }



    @Override
    public String toString() {
        return "座次: " + no + " 姓名: " + name + " 绰号: " + nickName;
    }
    
}

class DoubleLinkedList{
    
    HeroNode head=new HeroNode(-1,"","",null,null);
    HeroNode tail=new HeroNode(-1,"","",null,null);
    
    /*
     * 增加节点（默认加到尾部）.和单向链表的方法基本一样，只是在末尾节点的指向上，使的添加节点的pre指向上一节点即可
     */
    public void addNode(int no,String name,String nickName){
        HeroNode temp=head;
        //遍历整个链表，寻找尾节点
        while(true){
            if(temp.next==null){
                break;
                }else{
                    temp=temp.next;
                }
            }
            
            temp.next=new HeroNode(no,name,nickName,null,temp);
            tail=new HeroNode(no,name,nickName,null,temp);
        }
    
        
    
    
    
    //正向遍历
    
    public void show(){
        System.out.println("****************"+tail);
        if(head.next==null){
            System.out.println("链表为空!!!");
        }else{
            HeroNode temp=head.next;
            while(true){
                if(temp==null){
                    break;
                }else{
                    System.out.println(temp);
                    temp=temp.next;
                }
            }
            
        }
    }
    
    
    //反向遍历
    public void backShow(){
        long startTime=System.nanoTime();
        if(tail==null){
            System.out.println("链表为空");
        }else{
            HeroNode index=tail;
            while(true){
                if(index==head){  
                    break; //当尾节点=头节点时，遍历完毕，退出
                }else{
                    System.out.println(index);
                    index=index.pre;
                }
            }
            
            long endTime=System.nanoTime();
            System.out.println("运行耗时:"+(endTime-startTime));
            
        }
    }
    
    
    //双向遍历
    public void showHeadTail(){
        long startTime=System.nanoTime();
        if(head.next==null){
            System.out.println("链表为空!!!");
        }else{
            HeroNode temp=head.next;
            HeroNode index=tail;
            boolean flag=true;//true:单数;false:双数
        while(true){
            if(temp==index){
                flag=true;//单数
                break;
            }
            if(temp.next==index){
                flag=false;//双数
                break;
            }
            System.out.println(temp);
            System.out.println(index);
            temp=temp.next;
            index=index.pre;
            
        }
        
        if(flag==true){
            System.out.println(temp);
        }else{
            System.out.println(temp);
            System.out.println(index);
        }
        
        long endTime=System.nanoTime();
        System.out.println("运行耗时:"+(endTime-startTime));
    }
}
    
    //查找节点(单向正向查找)
    public void findNode(int no){
        if(head.next==null){
            System.out.println("链表为空!!!");
        }else{
            HeroNode temp=head.next;
            while(true){
                if(temp==null){
                    System.out.println("查无此人");
                    break;
                }else{
                    if(temp.no==no){
                        System.out.println(temp);
                        break;
                    }else{
                        temp=temp.next;
                    }
                }
            }
            
        }
    }
    
    //查找节点（双向查找）
    public void findNodeDouble(int no){
        if(head.next==null){
            System.out.println("链表为空!!!");
        }else{
            
            HeroNode temp=head.next;
            HeroNode index=tail;
            while(true){
                
              if(temp==index){
                  if(temp.no==no){
                      System.out.println(temp);
                      break;
                  }else{

                  System.out.println("查无此人!!!");
                  break;
                  }
              }
              if(index.next==temp){
                  System.out.println("查无此人!!!");
                  break;
              }
                 

                  if(temp.no==no){
                      System.out.println(temp);
                      break;
                  }
                  if(index.no==no){
                      System.out.println(index);
                      break;
                  }
                  temp=temp.next;
                  index=index.pre;
                  
              }
           }
        }
    
    
    //删除节点（单向查找并删除）
    public void deleteNode(int no){
        if(head.next==null){
            System.out.println("链表为空!!!");
        }else{
            HeroNode temp=head.next;//这里的指针指的是head
            boolean flag=false;
            while(true){
                if(temp==null){
                    break;
                }else{
                    if(temp.no==no){
                        flag=true;
                        break;
                    }else{
                        temp=temp.next;
                    }
                }
            }
            if(flag){
                if(temp.next==null){
                    temp.pre.next=temp.next;
                }else{
                    temp.pre.next=temp.next;
                    temp.next.pre=temp.pre;
                }
            }else{
                System.out.println("无此人!!!");
            }
            
        }
    }
    
    
    //删除节点（单向查找并删除）
        public void deleteNode2(int no){
            if(head.next==null){
                System.out.println("链表为空!!!");
            }else{
                HeroNode temp=head.next;//这里的指针指的是head
                while(true){
                    if(temp.next==null){
                        if(temp.no==no){
                            //tail=null;//删除不了最后一个节点
                            temp.pre.next=null;
                        
                        }else{
                            System.out.println("无此人!!!");
                        }
                        break;
                    }else{
                        if(temp.no==no){
                            temp.pre.next=temp.next;
                            temp.next.pre=temp.pre;
                            break;
                        }else{
                            temp=temp.next;
                        }
                    }
                }
                
                
            }
        }
        
    
    //删除节点（双向遍历）
        public void deleteNodeDouble(int no){
            if(head.next==null){
                System.out.println("链表为空!!!");
            }else{
                HeroNode temp=head.next;
                HeroNode index=tail;
                /*
                 * 1.判断是否删除的是最后一个节点
                 * 2.while循环
                 */
                if(tail.no==no){ 
                    index.pre.next=null;//如果删除的是最后一个节点，则将其删除
                }else{
                    //若不是，则执行循环
                    while(true){
                    if(temp==index){  //链表长度为单数,当前后指针相遇
                          if(temp.no==no){//如果相遇的节点是需要删除的节点，则将其删掉
                               temp.pre.next=temp.next;
                               temp.next.pre=temp.pre;
                           }else{
                               //如果不是，则说明这条链表中没有找到符合删除条件的节点
                               System.out.println("无此人!!!");
                           }
                               break;
                      }
                   if(index.next==temp){  //链表长度为双数时，若链表中没有符合删除条件的节点，则会出现这种情况，所以当出现这种情况，证明这条链表中没有找到符合删除条件的节点
                         System.out.println("无此人!!!");
                         break;
                     }
                   if(temp.no==no){
                         temp.pre.next=temp.next;
                         temp.next.pre=temp.pre;
                             break;
                      }else{
                         temp=temp.next;
                      }
                   if(index.no==no){
                       index.pre.next=index.next;
                       index.next.pre=index.pre;
                       break;
                   }else{
                       index=index.pre;
                   }
                    
                }
                
             }
            }
        }
        
        
        //修改某个节点(单向遍历)
        public void modifyNode(int no,String name,String nickName){
            
        }
        
        //修改某个节点(双向遍历)
        /*
         * 存在一个问题：修改尾节点后，再进行单向正向遍历，发现尾节点是之前没有修改的，但是对尾节点进行打印发现是已经修改过的；而对其他节点的修改操作是成功的
         * 而进行反向单向遍历以及双向遍历时，发现一切正常，修改功能可以正常实现
         */
        
       public void modifyNodeDouble(int no,String name,String nickName){
           if(head.next==null){
                System.out.println("链表为空!!!");
            }else{
                HeroNode temp=head.next;
                HeroNode index=tail;
                while(true){
                    if(temp==index){  //链表长度为单数,当前后指针相遇
                          if(temp.no==no){//如果相遇的节点是需要修改的节点，则修改
                               temp.name=name;
                               temp.nickName=nickName;
                           }else{
                               //如果不是，则说明这条链表中没有找到符合条件的节点
                               System.out.println("无此人!!!");
                           }
                               break;
                      }
                   if(index.next==temp){  //链表长度为双数时，若链表中没有符合条件的节点，则会出现这种情况，所以当出现这种情况，证明这条链表中没有找到符合条件的节点
                         System.out.println("无此人!!!");
                         break;
                     }
                   if(temp.no==no){
                       temp.name=name;
                       temp.nickName=nickName;
                       break;
                      }else{
                         temp=temp.next;
                      }
                   if(index.no==no){
                       index.name=name;
                       index.nickName=nickName;
                       break;
                   }else{
                      index=index.pre;
                   }
                    
                }
                System.out.println("打印尾节点----》"+tail);
            }
        }

}

　　问题：在modifyNodeDouble()方法中，如果修改的是尾节点，在使用show()正向单向遍历打印时，发现尾节点还是之前的那个，并未成功修改，而测试其他节点的修改时，发现可以修改成功；当使用backShow()反向单向遍历以及showHeadTail()双向遍历时，发现，所有位置的节点的修改功能都能成功实现。

　　在main()方法，以及show()方法，还有modifyNodeDouble()方法中，对tail进行打印：

 

　　main()方法中打印

 

             show()方法中打印

 

          modifyNodeDouble()方法中打印

　　发现tail的值都是修改后的值，那么问题可能就出在正向单向遍历那里：可能是当show()方法中的temp指针移到倒数第二个节点时，temp.next指针指的不是tail，而是原来之前未修改时的节点。这样导致即使修改了尾节点，但是采用这种遍历方法，遍历后还是原来之前未修改的值。

　　可是该如何解决这个问题？？？

3.单向环型链表及约瑟夫问题

　　约瑟夫问题：

 

package LianBiao;
/*
 * 循环链表
 */
public class CircleLinkedListDemo {
    public static void main(String[] args){
        
        ChildNode c1=new ChildNode(1,"佟湘玉");
        ChildNode c2=new ChildNode(2,"白展堂");
        ChildNode c3=new ChildNode(3,"郭芙蓉");
        ChildNode c4=new ChildNode(4,"吕秀才");
        ChildNode c5=new ChildNode(5,"李大嘴");
        ChildNode c6=new ChildNode(6,"莫小贝");
        ChildNode c7=new ChildNode(7,"老邢");
        ChildNode c8=new ChildNode(8,"燕小六");
        
        
        CircleLinkedList cl=new CircleLinkedList();
        cl.addNode(c1);
        cl.addNode(c2);
        cl.addNode(c3);
        cl.addNode(c4);
        cl.addNode(c5);
        cl.addNode(c6);
        cl.addNode(c7);
        cl.addNode(c8);
        cl.showNode();
        System.out.println("------------");
        cl.showByNum(1, 10);
        System.out.println("------------");
        cl.showNode();
    
        
    }

}

class ChildNode{
    int no;
    String name;
    ChildNode next;
    
    @Override
    public String toString() {
        return "no: " + no + ", name: " + name ;
    }

    public ChildNode(int no, String name) {
        super();
        this.no = no;
        this.name = name;

    }
    
    
    
}

class CircleLinkedList{
    ChildNode first=new ChildNode(-1,null);
    int num=0;//记录圈中成员个数
    
    
    //添加节点--成功实现
    public void addNode(ChildNode child){
     if(first.next==null){
         first=child;
         first.next=first;
         num++;
     }else{
         ChildNode temp=first;
         while(true){
            if(temp.next==first){
                break;
            }else{
                temp=temp.next;
            }
         }
         temp.next=child;
         child.next=first;
         num++;
        
     }
     
    }
    
    //遍历节点--成功实现
    public void showNode(){
        if(first.next==null){
            System.out.println("链表为空!!!");
        }else{
        ChildNode temp=first;
        while(true){
            if(temp.next==first){
                System.out.println(temp);
                break;
            }else{
                System.out.println(temp);
                temp=temp.next;
            }
          }
        }
    }
    
    //测试是否是环形链表--成功
    public void showNodeTest(){
        ChildNode temp=first;
        while(true){
            System.out.println(temp);
            temp=temp.next;
        }
    }
    
    //约瑟夫问题--成功实现(存在的问题：运行完此功能后，原有链表结构被破坏)
    /*
     * @param startNo:表示从第几个人出数
     * @param countNum:表示数几下
     * @param total:表示圈中成员总数
     */
    public void showByNum(int startNo,int countNum){
        System.out.println("出圈顺序为:");
        int total=num;
        ChildNode last;//last指针，用来指向first的上一个节点
        if(first==null){
            System.out.println("链表为空，请添加数据!!!");
        }else{
            if(startNo<1||startNo>total){
                System.out.println("非法输入!!!");
            }else{
                
                //找到开始数的成员，将first指针移到此处，同时将last指针移到其后面
                ChildNode temp=first;
                while(true){
                    if(temp.next.no==startNo){
                        last=temp;
                        first=temp.next;
                        break;
                    }else{
                        temp=temp.next;
                    }
                }
                
                //开始循环
                while(true){
                    if(first.next==first){
                        System.out.println(first);
                        break;
                    }else{
                        for(int i=1;i<countNum;i++){
                            first=first.next;
                            last=last.next;
                        }
                        System.out.println(first);
                        first=first.next;
                        last.next=first;
                    }
                }
                
                
            }
        }
        
    }
}