2020-12-10

最新推荐文章于 2024-09-14 21:48:00 发布

zhp_000228

最新推荐文章于 2024-09-14 21:48:00 发布

阅读量101

点赞数

文章标签： java 单链表

本文链接：https://blog.csdn.net/zhp_000228/article/details/110996781

版权

单链表

单链表的七道练习题

1.逆序输出单链表

2.将当前链表逆置

3.不遍历链表在已知节点前插入节点

4.输出倒数第k个节点

5.合并两个有序的链表，保持有序

6.找到两个相交链表的相交节点

7.判断一个链表是否有环，并且输出环的入口节点

单链表的定义：
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以节点来表示的，每个节点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个节点的地址数据。
如何在java编译器上创建一个单链表：
我们可以将单链表定义为一个类，而节点就是链表的每一个实例化对象，而每个节点都有自己的元素和下一个节点的指针，这样每一个节点连在一起就变成了单链表。
如下我们简单的创建一个单链表。

class MySingleList<T> {
    private Node<T> head; //永远指向链表当中的第一个节点
    class Node<T> {
        private T data; //数据域名
        private Node<T> next; //next引用域
         public Node(T data) {
            this.data = data;
        }
        public T getData() {
            return data;
        }
        public void setData(T data) {
            this.data = data;
        }
        public Node<T> getNext() {
            return next;
        }
        public void setNext(Node<T> next) {
            this.next = next;
        }
    }
    public void addTail(T value) {
        //尾插法创建链表，新插入的节点一直在最后
        Node<T> newNode = new Node(value);
        if (head == null) {//特殊情况下，当前链表是一个空链表，不存在任何节点
            head = newNode;
        } else {//正常情况下         
            Node<T> tmp = head;
            //让tmp向后走，直到tmp指向当前链表的最后一个节点
            while (tmp.next != null) {
                tmp = tmp.next;
            }       
            tmp.next = newNode;
        }
    }
     public void addHead(T value) {
        //头插法 新插入的节点在head之后
        Node<T> newNode = new Node(value);
        if (head == null) {//特殊情况下，当前链表是一个空链表，不存在任何节点
            head = newNode;
        } else {
            newNode.next = head.next;
            head.next = newNode;
        }
    }
    
}

1.逆序输出单链表
使用递归来逆序输出每一个节点的元素值，让节点一直向后走，直到节点为空，同时去输出每一个节点的元素值。代码如下

 public static <T> void reversePrintList(MySingleList<T>.Node<T> head){
        if(head == null){
            return;//当节点为空时结束
        }
        reversePrintList(head.getNext());//让节点一直向后走，直到节点为空，他会每次调用reversePrintList(head.getNext())，这里就会自己调用自己，不会进行下面的输出操作，当遇到return就结束返回，开始一层一层的输出操作，这里就开始逆序输出了。
        System.out.println(head.getData());//每次输出节点的值
    }

2.将当前链表逆置
定义三个引用，当前节点、当前节点的前一个节点以及当前节点的后一个节点，首先保存当前节点的下一个节点，控制这三个节点同时向后走，修改当前节点的next为前一个节点，当当前节点为最后一个节点时，该节点就是新的链表的头，保存该链表的头节点并且返回。代码如下：

public static <T> MySingleList<T>.Node<T> reverseList(MySingleList<T>.Node<T> head){
        MySingleList<T>.Node<T> curNode = head;//当前节点
        MySingleList<T>.Node<T> prevNode = null; //当前节点的前驱
        MySingleList<T>.Node<T> nextNode = null; //当前节点的后继
        
        MySingleList<T>.Node<T> newHead = null; //逆置后链表的头
        while(curNode != null){//控制前三个引用向后走，直到节点为空
            nextNode = curNode.getNext();
            if(next == null){
                newHead = curNode;
            }
            curNode.setNext(prev);//修改当前节点的next为上一个节点
            //当前节点的前一个节点往后走
            prevNode = curNode;
            //当前节点往后走
            curNode = nextNode;
        }
        return newHead;
    }

3.不遍历链表在已知节点前插入节点
保存已知节点的下一个节点，在已知节点后面插入一个与自己有相同的元素的新节点，在这个新节点之后添加之前的下一个节点，将已知节点的元素值修改为所要插入的元素的值。代码如下：

public static <T> boolean insertPosBefore(MySingleList<T> list,  MySingleList<T>.Node<T> pos, T value){
        if(list.getHead() == null || pos == null){
            return false;
        }
        MySingleList<T>.Node<T> nextNode=pos.getNext();//保存pos节点的下一个节点
        //创建新节点，并且新节点的元素值与pos相同
        MySingleList<T>.Node<T> newNode= list.creatNode(pos.getData());
        pos.setNext(newNode);//将新的pos节点插入到pos之后
        pos.getNext().setNext(nextNode);//将之前的pos节点后的节点添加到新的pos节点之后
        pos.setData(value);//将pos节点的元素改为需要修改的值
        return true;
    }

4.输出倒数第k个节点
做法一：先遍历链表得到链表长度length，定义新的引用为头节点，向后走length-k-1次，就是第length-k节点，得到得新的节点就是倒数第k个节点。代码如下：

public static <T> MySingleList<T>.Node<T> findKNode(MySingleList<T>.Node<T> head, int k){
        //如果链表为空，则返回null
        if (head == null) {
            //没有找到
            return null;
        }
        //第一次遍历得到链表的长度(节点个数)
        int length = 0;
        MySingleList<T>.Node<T> tmp = head;
        while(tmp != null){
            length++;
            tmp = tmp.getNext();
        }
        //k的合法性判断
        if (k <= 0 || k > length) {
            return null;
        }
        tmp=head;
        //for循环定位到倒数的第k个位置
        //第二次遍历，length-k的位置，就是倒数第k个节点
        for (int i = 0; i < length - k; i++) {
            tmp = tmp.getNext();
        }
        return tmp;
    }

方法二：倒数第k个节点和最后一个节点的距离为k-1，定义两个引用，先让右节点先走k-1次，然后两个引用的距离为k-1，让两个引用同时向后走，直到右节点为最后一个节点。代码如下所示：

public static <T> MySingleList<T>.Node<T> findKNode1(MySingleList<T>.Node<T> head, int k){
        if(head == null){
            return null;
        }
        //定义两个引用
        MySingleList<T>.Node<T> right = head;
        MySingleList<T>.Node<T> left = head;
        //k的合法性判断
        if (k <= 0) {
            return null;
        }
        //right先走k-1次
        for(int i=0; i<k-1; i++){
            if(right == null){
                return null;
            }
            right= right.getNext();
        }
        //right，left同时走
        while(right.getNext() != null){
           right = right.getNext();
            left = left.getNext();
        }
        return left;
    }

5.合并两个有序的链表，保持有序
定义一个节点引用来保存新的有序链表，首先确定新链表的头节点，比较两个链表的头节点，小的为新链表的头节点，并且小的链表的头向后走。
接下来定义一个新的引用来给新的链表添加元素，通过比较两个链表的头节点，小的添加到新链表的后面，并且小的链表的头节点向后走一个节点，直到一个链表为空，然后将另一个链表的所有节点添加到新的链表后面。代码如下所示：

public static <T extends Comparable<T>> MySingleList<T>.Node<T> mergeOrderList(MySingleList<T>.Node<T> head1, MySingleList<T>.Node<T> head2) {
        if(head1 == null && head2 == null){
            return null;
        }else if(head1 == null){
            return head2;
        }else if(head2 == null){
            return head1;
        }
        //其中就可以使用compareTo方法比较大小
        //要求所传的泛型类型也必须要实现Compareable
        MySingleList<T>.Node<T> newHead = null;
        //确定合并后链表的头节点
        if (head1.getData().compareTo(head2.getData()) >= 0) {
            newHead = head2;
            head2 = head2.getNext();
        } else {
            newHead = head1;
            head1 = head1.getNext();
        }
        //遍历list1和list2，将对应位置更小的节点链到新链表之后
        //一旦list1和list2其中一个遍历完成，则直接链入另外一个未遍历完的链表
        MySingleList<T>.Node<T> tmp = newHead;
        while (head1 != null && head2 != null) {
            if (head1.getData().compareTo(head2.getData()) >= 0) {
                tmp.setNext(head2);
                //head2为更小的位置点，head2需要往后走
                head2 = head2.getNext();
                //tmp永远指向新链表尾巴
                tmp = tmp.getNext();
            } else {
                tmp.setNext(head1);
                //head1为更小的位置点，head1需要往后走
                head1 = head1.getNext();
                //tmp永远指向新链表尾巴
                tmp = tmp.getNext();
            }
        }

        if (head1 == null) {
            tmp.setNext(head2);
        }

        if (head2 == null) {
            tmp.setNext(head1);
        }
        return newHead;
    }

6.找到两个相交链表的相交节点
如下所示构造两个相交的链表

   public static void main(String[] args) {       
    //构造两个相交的链表       
     MySingleList<Integer> list1 = new MySingleList<>();           
     MySingleList<Integer> list2 = new MySingleList<>();      
     list1.addTail(1);       
     list1.addTail(10);       
     list1.addTail(6);       
     list1.addTail(5);       
     list1.addTail(3);       
     list1.addTail(2);     
     list1.addTail(7);   
     MySingleList<Integer>.Node<Integer> tmp = list1.getHead();        
     MySingleList<Integer>.Node<Integer> commonNode = null;      
       while(tmp != null){         
          if(tmp.getData() == 6){ //元素值为6的作为相交节点             
            commonNode = tmp;             
               break;        
            }         
            tmp = tmp.getNext();   
        }     
     list2.addTail(3);      
     list2.addTail(5);     
     tmp = list2.getHead();      
       while(tmp.getNext() != null){          
         tmp = tmp.getNext();       
       }       
      tmp.setNext(commonNode);

第一种做法：定义两个栈用保存链表的所有节点，然后进行出栈操作，当栈顶结果不同时，上一个栈顶元素就是两个链表的相交节点。代码如下所示：

public static <T>  MySingleList<T>.Node<T> commonNode1(MySingleList<T>.Node<T> head1, MySingleList<T>.Node<T> head2){
        if(head1 == null || head2 == null){
            return null;
        }
        //将两个链表中的元素进行入栈操作
        Stack<MySingleList<T>.Node<T>> stack1 = new Stack<>();
        Stack<MySingleList<T>.Node<T>> stack2 = new Stack<>();
        MySingleList<T>.Node<T> tmp = head1;
        while(tmp != null){//list1入栈
            stack1.push(tmp);
            tmp = tmp.getNext();
        }       
        tmp = head2;
        while(tmp != null){ //list2入栈
            stack2.push(tmp);
            tmp = tmp.getNext();
        }

        MySingleList<T>.Node<T> commonNode = null;
        while(stack1.peek() == stack2.peek()){
           commonNode = stack1.peek();//保存每一次的栈顶元素
           stack1.pop();
           stack2.pop();
        }
        return commonNode;
    }

方法二：首先遍历两个链表得到两个链表的长度，然后的到两个链表的差值k，定义两个节点引用为两个链表的头节点，让长链表向后遍历k次，使两个引用的的距离为k，然后通过是让个两个引用向后遍历，直到两个引用相同时，则该引用为相交节点。代码如下所示：

 public static <T>  MySingleList<T>.Node<T> commonNode2(MySingleList<T> list1, MySingleList<T> list2){
        if(list1.getHead() == null || list2.getHead() == null){
            return null;
        }
        //得到两个链表的长度
        int length1 = list1.getLength();
        int length2 = list2.getLength();

        //得到差值
        int diff = Math.abs(length1-length2);

        MySingleList<T>.Node<T> longHead = list1.getHead();
        MySingleList<T>.Node<T> shortHead = list2.getHead();
        if(length1 < length2){
            longHead = list2.getHead();
            shortHead = list1.getHead();
        }
        //长链表先走
        for(int i=0; i<diff; i++){
            longHead = longHead.getNext();
        }

        //同时走
        while(longHead != shortHead){
            longHead = longHead.getNext();
            shortHead = shortHead.getNext();
        }
        return longHead;
    }

7.判断一个链表是否有环，并且输出环的入口节点
如下所示构造一个有环的链表

MySingleList<Integer> mySingleList=new MySingleList<>();
        mySingleList.addTail(1);
        mySingleList.addTail(3);
        mySingleList.addTail(5);
        mySingleList.addTail(7);
        mySingleList.addTail(9);
        roundNode(mySingleList);
        MySingleList<Integer>.Node<Integer> head=mySingleList.getHead();
        while(head.getData()!=7){
            head=head.getNext();
        }
        MySingleList<Integer>.Node<Integer> tmp =mySingleList.getHead();
        while(tmp.getNext()!=null){
            tmp=tmp.getNext();
        }
        tmp.setNext(head);

第一种做法：首先判断是否有环，定义两个节点引用，一个右节点每次向后走两次（变成该节点的下两个节点），一个左节点每次向后走一次（变成该节点的下一个节点），如果这两个相同，则有环。定义一个环引用保存相同的环上节点，定义一个直节点引用为链表的头节点，然后两个引用同时向后走，当两个引用相同时，则该节点就是环的入口节点。
这里为什么两个引用时就是环的入口节点呢？这更像一个数学问题。
首先我们假设直链的长度为l，环的长度为r，换节点到环入口节点的距离为s，
左节点走的距离为l+s，右节点走的距离为l+s+nr，
可以直到2l+2s=l+s+nr，可以知道l=nr-s,n是一定大于一的。当直节点向后走，走到环入口节点时，环节点也一定是环的入口节点。代码如下所示。

 public static <T> MySingleList<T>.Node<T> roundNode(MySingleList<T> list) {
        MySingleList<T>.Node<T> tmp1 = list.getHead();//定义两个引用
        MySingleList<T>.Node<T> tmp2 = list.getHead();
        while (tmp1 != null && tmp2 != null) {
            if (tmp2.getNext() == null) {
                System.out.println("没有环");
                return null;
            }
            tmp1 = tmp1.getNext();
            tmp2 = tmp2.getNext().getNext();
            if (tmp1 == tmp2) {//两个引用相同时，跳出循环，
                break;
            }
        }
        MySingleList<T>.Node<T> head= list.getHead();//保存头节点
        MySingleList<T>.Node<T> tail= tmp1;//保存相同的环节点
        while (head != tail) {
            head = head.getNext();
            tail = tail.getNext();
        }
        return head;

    }

第二种做法：首先判断是否有环，定义两个节点引用，一个右节点每次向后走两次（变成该节点的下两个节点），一个左节点每次向后走一次（变成该节点的下一个节点），如果这两个相同，则有环，保存这个相同的环节点。
定义新的节点引用为这个环节点，定义一个计数器，让这个环节点向后走，每走一次计数器计数+1，直到引用等于这个环节点时，得到这个环的节点个数k。
定义两个节点引用，使右节点为第k个节点，保持和左节点的距离为环的长度，开始让左右节点同时向后走，直到两个节点相同时，这个节点就是环的入口节点，代码如下所示。

 public static <T> MySingleList<T>.Node<T> isRing(MySingleList<T>.Node<T> head) {
        if (head == null) {
            return null;
        }
        //定义快慢引用
        MySingleList<T>.Node<T> slow = head.getNext();    
        MySingleList<T>.Node<T> fast = slow.getNext();
        while (fast != null && fast.getNext() != null && slow != null) {
            //两个引用指向相同的节点(相遇)，返回该节点
            if (slow == fast) {
                return slow;
           }
            slow = slow.getNext();
            fast = fast.getNext().getNext();
        }
        return null;
    }

    //求环的入口节点
    public static <T> MySingleList<T>.Node<T> entranceNode(MySingleList<T>.Node<T> head) {
        MySingleList<T>.Node<T> tmp1=null;
        if(isRing(head)==null){
            System.out.println("没有环");
            return null;
        }
        if(isRing(head)!=null) {
         tmp1 = isRing(head);
        }
        MySingleList<T>.Node<T> tmp2=tmp1;
        int count=1;//得到环的节点个数
        while(tmp1.getNext()!=tmp2){
        tmp1=tmp1.getNext();
        count++;
        }
        MySingleList<T>.Node<T> right =head;//
        MySingleList<T>.Node<T> left=head;
        for(int i=0;i<count;i++){//右边引用先变为到第count个节点
        right=right.getNext();
        }
        while(left!=right){//左右节点直接的距离为一圈环的距离，同时向后遍历，直到两个引用想等
        right=right.getNext();
        left=left.getNext();
        }
        return left;
    }