数据结构 -线性结构 ->单向链表

定义:链表就是由包含值域和next域的多个节点组成，其中由头节点出发连接下一个节点直到最后，

        链表的逻辑储存结构和实际储存结构是不一样的，逻辑结构中每个节点都是按顺序连接，实际则不是，主要根据节点的next域来实现连接。

 

单链表：节点只有值域和next域，结构中的数据查询也只能按一个方向来实现

　　　　单链表实现增删改查功能：

/**
 * 定义一个SingleListed
 */
class SingleListed{
    //初始化头节点,头节点不能储存数据
    StartNode head = new StartNode( 0, "","");

    public StartNode getHead() {
        return head;
    }

    /**
     *删除节点，通过将要删除的节点的引用转到下一个即可，没有了引用，jvm的垃圾回收机制会自动回收
     */
    public void delete(int num){
        //头节点不能动
        StartNode temp = head;
        boolean flag = false;
        while(true){
            if(temp.next == null){
                break;//已到链表最后
            }
            if(temp.next.no == num){
                flag = true;//找到
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.next = temp.next.next;
        }
        else{
            System.out.printf("没有找到该%d的数据，无删除\n",num);
        }
    }

    /**
     * 链表添加数据
     */
    public void add(StartNode startNode){
        //定义一个临时变量代替节点
        StartNode temp = head;
        while(true){
            //找到链表的最后
            if( temp.next == null){
                break;
            }
            //如果没有找到最后，temp向后移
            temp = temp.next;
        }
        temp.next = startNode;
    }

    /**
     * 按照顺序添加数据
     */
    public void addByOder(StartNode startNode){
        //头节点不能动，利用temp来处理数据
        StartNode temp = head;
        boolean flag = false;//标记数据编号是否重复
        //遍历链表添加数据
        while(true){
            //判断是否到链表的最后
            if(temp.next == null){
                break;
            }
            else if(temp.next.no > startNode.no){
                break;
            }
            else if( temp.next.no == startNode.no) {
                flag = true;
                break;
            }
                temp = temp.next;//往后移动
        }
        if(flag){
            System.out.printf("该球星的排名%d已经有了,不能这么排了\n",temp.next.no);
        }
        else{
            startNode.next = temp.next;
            temp.next = startNode;
        }

    }

    /**
     * 修改已有编号的name和nickname
     * @param startNode
     */
    public void update(StartNode startNode){
        //判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空！");
            return;
        }
        //当no重复时进行更换
        StartNode temp = head.next;
        boolean flag = false;//判断是否找到目标
        while(true){
            if(temp == null){
                break;//链表已经遍历结束
            }
            if(temp.no == startNode.no){
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.nickName = startNode.nickName;
            temp.name = startNode.name;
        }
        else{
            System.out.println("无修改");
        }

    }

    /**
     * 显示链表中储存的数据
     */
    public void showList(){
        //判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空！");
            return;
        }
        //头节点不能动，需要一个辅助变量来遍历
        StartNode temp = head.next;
        while(true){
            //判断是否到最后
            if(temp == null){
                break;
            }
            //输出节点数据
            System.out.println(temp);
            temp = temp.next;
        }

    }
}

//定义StartNode，每个StartNode都是一个节点
class StartNode{
    int no;
    String name;
    String nickName;
    StartNode next;
    public StartNode(int no,String name,String nickName){
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

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

单链表的一些应用：

（1）求单链表的倒数第k个数：

　　　　思路：先取得链表中的有效数据个数，再找到有效数据个数-k即可得到链表中的倒数第k个数。

  /**
     *求链表倒数第K个节点
     * getLength - K  = 倒数的第K的节点位置
     */
    public static StartNode findLastIndexNode(StartNode head,int k){
        if(head.next == null){
            return  null;
        }
        int listedLength = getLength(head);
        //判断k值是否合理
        if(k <= 0 || k > listedLength){
            return null;
        }
        //遍历取得倒数第K个数
        StartNode temp = head.next;
        for(int x = 0;x < listedLength-k;x++){
            temp = temp.next;
        }
        return temp;
    }
    /**
     * 取得链表的有效数据个数
     */
    public static int getLength(StartNode head){
        if(head.next == null){
            return 0;
        }
        StartNode temp = head.next;
        int length = 0;
        while(true){
            if(temp == null){
                break;
            }
            length++;
            temp = temp.next;
        }
        return length;
    }

（2）反转链表

　　思路：新建一个带头节点的空的单链表，遍历原链表将头节点下的第一个数链接到新链表的头节点后，然后依次取原链表后面的数据，每取一个将取得的该数据插入到新链表的头节点之后，新链表中已有的数据依次往后移动，遍历完原链表后再将新链表的头节点后第一个节点链接回原链表的头节点后，即实现链表的反转，

      需要两个辅助变量，一个为原链表的头节点的后一个，一个为当前节点的后一个，保证原链表不断。

/**
     * 反转单链表
     */
   public static void inverseLinked(StartNode head){
       if(head.next == null || head.next.next == null){
           return;//链表中无数据或者只有一个数据就不用反转了
       }
       StartNode newHead = new StartNode(0,"","");
       StartNode temp = head.next;
       StartNode next = null;//指向当前节点的下一个节点
       while(temp != null){
          next = temp.next;//临时节点指向当前节点的下一个节点
          temp.next = newHead.next;//将temp的下一个节点指向新链表的最前
          newHead.next = temp;//将temp连接到新链表
          temp = next;//temp后移
       }
       head.next = newHead.next;
   }

（3）反向打印单链表

　　思路：反向打印不代表反转链表后打印，是在不改变链表的结构顺序下将链表中的数据从后往前依次打印，可以使用到栈先进后出的储存顺序完成，将链表中的数据依次压入栈中，然后打印栈中的弹出的数据即可。

 /**
     *反向打印链表：使用Stack栈（先进后出）的思路
     * 不应该使用反转，因为会破坏链表的的数据结构
     */
    public static void reversePrint(StartNode head){
        if(head.next == null){
            return ;
        }
        //使用jdk中stack
        Stack<StartNode> s = new Stack<StartNode>();
        //循环将链表中的节点压入栈中
        StartNode temp = head.next;
        while(temp != null){
            s.push(temp);
            temp = temp.next;
        }
        while(s.size()>0){
            System.out.println(s.pop());
        }
    }

（4）合并两有序单链表，并且合并后的链表也是有序的

　　思路：需要新建一个空链表，循环比较两个有序链表的第一个数，将满足比较条件的数存到新链表中即可

/**
     * 合并两个有序列表，合并后任然有序
     */
    public static SingleListed mergeLinked(SingleListed s1,SingleListed s2){
        SingleListed s = new SingleListed();
        StartNode head = s.head;//新链表的头节点
        StartNode head1 = s1.getHead();
        StartNode head2 = s2.getHead();
        StartNode temp1 = head1.next;
        StartNode temp2 = head2.next;
        //当两个表中任意一个表是空的时候，就不用比较大小，不为空的链表直接存入新链表
        if(temp1 == null) head.next = head2.next;
        if(temp2 == null) head.next = head1.next;
        //循环比较两个链表头节点之后的数据，满足比较条件的数据存入新链表，且存入的数据不参与下次比较
        while(temp1 != null && temp2 != null){
            if(temp1.no < temp2.no){
                head.next = temp1;
                temp1 = temp1.next;
            }
            else if(temp1.no > temp2.no){
                head.next = temp2;
                temp2 = temp2.next;
            }
            head = head.next;
        }
        return s;
    }