单链表常见编程题

1、求单链表中有效节点个数：获取单链表的有效节点个数 如果是带头结点的链表 需要不统计头节点。
2、查找单链表中的倒数第k个节点
思路：编写一个方法接收head节点 同时接收index 表示倒数第index个节点；先把链表从头到尾遍历 得到链表的总长度(getLength)，size；得到长度后 从链表头开始遍历 遍历到（size-index)个；如果找到返回该节点否则为空。
3、单链表的反转：节点的倒序

思路：先定义一个节点reverseHead=new heroNode{}作为头节点;从头到尾遍历原来的链表，每遍历一个节点 就将其取出，并放在新的链表reverseHead的最前端（每次都放在最前端 前插法，之前创建链表都是后插法添加节点)；原来的链表的head.next=reverseHead.next。
4、从尾到头打印单链表
思路：
方式一：先将单链表进行反转操作，在遍历即可；这样做的问题是会破坏原来单链表的结构，不建议，这个链表之后不能复用了。
方式二：利用栈数据结构，将各个节点依次压入到栈中（入栈），然后利用栈的先进后出的特点可实现逆序打印效果（出栈）。

import java.util.Stack;

public class SingleLinkedListDemo1 {
    public static  void main(String[] args){
        //先创建节点
        HeroNode heroNode1=new HeroNode(1,"宋江","及时雨");
        HeroNode heroNode2=new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode heroNode3=new HeroNode(3,"吴用","智多星");
        HeroNode heroNode4=new HeroNode(6,"林冲","豹子头");
        //创建单链表
        SingleLinkedList1 singleLinkedList=new SingleLinkedList1();
        //按no顺序往链表直接加入节点  这里no是唯一的 不能重复
        singleLinkedList.addByOrder(heroNode1);
        singleLinkedList.addByOrder(heroNode4);
        singleLinkedList.addByOrder(heroNode3);
        singleLinkedList.addByOrder(heroNode2);
        //singleLinkedList.addByOrder(heroNode2);
        singleLinkedList.list1();
        //修改节点
//        HeroNode newHeroNode=new HeroNode(4,"公孙胜","入云龙");
//        singleLinkedList.update(newHeroNode);
//        System.out.printf("修改后的链表情况\n");
//        singleLinkedList.list1();
//        System.out.printf("删除后的链表情况\n");
//        singleLinkedList.del(1);
//        singleLinkedList.list1();
//        System.out.printf("删除后的链表情况\n");
//        singleLinkedList.del(4);
//        singleLinkedList.list1();
//        System.out.printf("删除后的链表情况\n");
//        singleLinkedList.del(2);
//        singleLinkedList.del(3);
//        singleLinkedList.list1();
        System.out.printf("获取有效节点个数为\n");
        System.out.println(getLength(singleLinkedList.getHead()));
        System.out.printf("查找倒数第1个节点\n");
        HeroNode res=findLastIndexNode(singleLinkedList.getHead(),1);
        System.out.println("res="+res);
        System.out.printf("单链表反转：原始链表\n");
        singleLinkedList.list1();
        System.out.printf("单链表反转：反转后的链表\n");
        reverseList(singleLinkedList.getHead());
        singleLinkedList.list1();
        System.out.printf("逆序打印单链表,未改变链表本身的结构\n");
        reversePrint(singleLinkedList.getHead());

        //创建第二个有序链表
        HeroNode heroNode5=new HeroNode(4,"公孙胜","入云龙");
        HeroNode heroNode6=new HeroNode(5,"关胜","大刀");
        SingleLinkedList1 singleLinkedList2=new SingleLinkedList1();
        singleLinkedList2.addByOrder(heroNode5);
        singleLinkedList2.addByOrder(heroNode6);
        System.out.printf("第二个有序链表情况\n");
        singleLinkedList2.list1();




    }


    //4、逆序打印 使用栈
    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());
        }
    }



    //3、单链表反转
    public static void reverseList(HeroNode head){
        //如果当前链表为空 或者只有一个节点则无需返还 直接返回
        if(head.next==null||head.next.next==null){
            return ;
        }
        //定义一个辅助的变量 帮助遍历原链表
        HeroNode cur=head.next;
        HeroNode next=null;//指向当前节点的下一个节点 防止链表遍历中断
        HeroNode reverseHead=new HeroNode(0,"","");
        //遍历原来的链表  并取出数据 实现前插法
        while (cur!=null){
            //cur==null表示遍历结束了 走到了单链表的尾部
            next=cur.next;//保留当前节点的下一个节点 因为后边还需要继续遍历
            //前插法 下两行语句
            cur.next=reverseHead.next;
            reverseHead.next=cur;
            cur=next;//继续遍历原先的链表

        }
        head.next=reverseHead.next;

    }

    //2、查找单链表中的倒数第k个节点
    //思路：编写一个方法接收head节点 同时接收index 表示倒数第index个节点
    //先把链表从头到尾遍历  得到链表的总长度(getLength)，size
    //得到长度后 从链表头开始遍历 遍历到（size-index)个
    //如果找到返回该节点否则为空

    /**
     * 举例  比如一共10个节点 下标从0-9 查找倒数第3个（下标是7）
     * size=10 size-index=10-3=7刚好就是其要查找的元素的下标
     * @param head 头节点
     * @param index 倒数第几个节点位置
     * @return 倒数第k个节点
     */
    public static HeroNode findLastIndexNode(HeroNode head,int index){
        if(head.next==null){//链表到尾了 没找到
            return null;
        }
        //第一次遍历得到节点的个数
        int size=getLength(head);
        //第二次遍历 size-index位置 就是倒数的第k个节点（这个位置按下标算）
        //先做一个index的校验
        if(index<=0||index>size){
            return null;//范围不符合 找不到
        }
        //定义一个辅助变量
        HeroNode temp=head.next;
        for(int i=0;i<(size-index);i++){
            temp=temp.next;
        }
        return temp;
    }



    //1、获取单链表的有效节点个数 如果是带头结点的链表 需要不统计头节点

    /**
     *获取单链表的有效节点个数  没有统计头节点
     * @param head 链表的头节点
     * @return 返回有效的节点的个数
     */
    public static int getLength(HeroNode head){
         if(head.next==null){//空链表
             return 0;
         }
         int length=0;
         HeroNode cur=head.next;//定义一个辅助变量
         while(cur!=null){
             length++;
             cur=cur.next;
         }
         return  length;
    }
}
//定义一个SingleLinkedList管理节点 单向链表
class SingleLinkedList1{
    //初始化头节点
    private HeroNode head=new HeroNode(0,"","");

    //返回头节点
    public HeroNode getHead(){
        return head;
    }

    //向单向链表添加数据
    //找到当前链表的尾节点，然后将尾节点的next指向新节点
    public void add1(HeroNode heroNode){
        //因为头节点不能动 所以设置一个辅助移动的节点用于遍历
        HeroNode temp=head;
        while(true){
            //当next节点指向null空 就到链表最后了
            if(temp.next==null){
                break;
            }
            temp=temp.next;
        }
        //退出循环时 temp就指向了链表的最后了 此时将其指向新节点即完成添加
        temp.next=heroNode;
    }
    //有序添加 插入
    public void addByOrder(HeroNode heroNode){
        //因为头节点不能动 所以设置一个辅助移动的节点用于找到要添加的位置
        //单链表 要找添加位置的前一个结点 temp是位于添加位置的前一个节点，否则插入不了
        HeroNode temp=head;
        boolean flag=false;//标识添加的编号是否存在
        while(true){
            if(temp.next==null){
                //说明temp已经移到链表的最后
                break;
            }
            if(temp.next.no>heroNode.no){//位置找到，就在temp后边添加
                break;
            }else if(temp.next.no==heroNode.no){//说明希望添加的节点的编号已经存在 不可添加
                flag=true;
                break;
            }
            temp=temp.next;//后移 遍历
        }
        if(flag){//说明编号存在不可添加
            System.out.printf("准备添加的编号%d已经存在，不可添加\n",heroNode.no);
        }else{//插入链表 temp后边
            heroNode.next=temp.next;
            temp.next=heroNode;
        }
    }
    //修改节点信息，根据编号来修改 所以no不可以改
    //根据newHeroNode的no来修改信息
    public  void update(HeroNode newHeroNode){
        //判断链表是否为空
        if(head.next==null){
            System.out.println("链表为空");
            return ;
        }
        //找到需要修改的节点
        HeroNode temp=head.next;
        boolean flag=false;//表示是否找到该节点
        while (true){
            if(temp==null){
                break;//到链表的最后,已经遍历完这个链表了
            }
            if(temp.no==newHeroNode.no){
                //找到要修改的节点
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if(flag){//根据flag判断是否找到要修改的节点
            temp.name=newHeroNode.name;
            temp.nickname=newHeroNode.nickname;
        }else{
            System.out.printf("没有找到编号尾%d的节点,不能修改\n",newHeroNode.no);
        }
    }
    //删除节点
    //先找到要删除的节点的前一个节点temp;temp.next=temp.next.next即可；被删除的节点将不会有其他引用指向，会被垃圾回收机制回收。
    //因为头节点不能动 所以设置一个辅助移动的节点用于找到要删除节点的前一个节点
    //在比较时 是将temp.next.no 和 待删除结点的no比较的
    public void del(int no){
        HeroNode 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.printf("要删除的节点%d不存在\n",no);
        }
    }



    //显示链表 遍历
    public void list1(){
        //判断链表是否为空
        if(head.next==null){
            System.out.println("链表为空");
            return ;
        }
        HeroNode temp=head.next;
        while(true){
            //判断链表此时是否到最后了
            if(temp==null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            temp=temp.next;
        }

    }

}

//定义一个 HeroNode 类 节点类 每个HeroNode就是一个节点对象
class  HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点

    //构造函数
    public HeroNode(int hno, String hname, String hnickname) {
        this.no = hno;
        this.name = hname;
        this.nickname = hnickname;
    }
    //重写toString（）方法
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name=" + name +
                ", nickname=" + nickname  +
                '}';
    }

}

HeroNode{no=1, name=宋江, nickname=及时雨}
HeroNode{no=2, name=卢俊义, nickname=玉麒麟}
HeroNode{no=3, name=吴用, nickname=智多星}
HeroNode{no=6, name=林冲, nickname=豹子头}
获取有效节点个数为
4
查找倒数第1个节点
res=HeroNode{no=6, name=林冲, nickname=豹子头}
单链表反转：原始链表
HeroNode{no=1, name=宋江, nickname=及时雨}
HeroNode{no=2, name=卢俊义, nickname=玉麒麟}
HeroNode{no=3, name=吴用, nickname=智多星}
HeroNode{no=6, name=林冲, nickname=豹子头}
单链表反转：反转后的链表
HeroNode{no=6, name=林冲, nickname=豹子头}
HeroNode{no=3, name=吴用, nickname=智多星}
HeroNode{no=2, name=卢俊义, nickname=玉麒麟}
HeroNode{no=1, name=宋江, nickname=及时雨}
逆序打印单链表,未改变链表本身的结构
HeroNode{no=1, name=宋江, nickname=及时雨}
HeroNode{no=2, name=卢俊义, nickname=玉麒麟}
HeroNode{no=3, name=吴用, nickname=智多星}
HeroNode{no=6, name=林冲, nickname=豹子头}
第二个有序链表情况
HeroNode{no=4, name=公孙胜, nickname=入云龙}
HeroNode{no=5, name=关胜, nickname=大刀}

5、合并两个有序地单链表，合并之后的链表依然有序
参考原博客：https://www.cnblogs.com/huanglei2010/articles/7801998.html

import java.util.Scanner;

public class SingleLinkedListDemo{
    public static void main(String args[]) {
        Node la, lb, lc;
        la = creat_list(5);
        lb = creat_list(4);
        lc = la;
        // print_list(la);
        //PRINT_LIST(LB);
        // merge_list(la, lb);
        print_list(merge_list(la, lb));
    }
    // 链表创建方法
    static Node creat_list(int n) {
        System.out.println("input "+n+" values:");
        Scanner scn = new Scanner(System.in);
        Node p, head = null,t = null;
        //head = new Node();
        //head.next = null;
        for (int i = 0; i < n; i++) {
            if(i==0){
                head =new Node();
                head.data=scn.nextInt();
                head.next=null;
                t=head;
                continue;
            }
            // while (t.next!=null) t=t.next;
            p = new Node();
            p.data = scn.nextInt();
            p.next=null;
            t.next = p;
            t=p;
        }
        return head;
    }
    static Node merge_list(Node la, Node lb) {
        Node pa, pb, pc=null,lc=null,pt;
        pa = la;
        pb = lb;
        //lc = pc;
        int i=0;
        while ((pa != null) && (pb != null)) {
            if(i==0) {
                if (pa.data <= pb.data) {
                    pc = pa;
                    pa = pa.next;
                } else {
                    pc = pb;
                    pb = pb.next;
                }
                lc=pc;
                i++;
                continue;
            }
            if (pa.data <= pb.data) {
                pc.next = pa;
                pc=pa;
                pa = pa.next;
            } else {
                pc.next = pb;
                pc=pb;
                pb = pb.next;
            }

        }
        pc.next = (pa==null)?pb:pa;
        return lc;
    }
    // 链表打印输出方法
    static void print_list(Node head) {
        Node p;
        p = head;
        while (p != null) {
            System.out.println("[" + p.data + "]");
            p = p.next;
        }
    }
}
//节点类声明
class Node {
    int data;
    Node next;
}