链表应用：逆序，翻转，获取长度和倒数第K个结点

最新推荐文章于 2021-10-07 08:06:02 发布

kekeoneone

最新推荐文章于 2021-10-07 08:06:02 发布

阅读量106

点赞数

分类专栏：链表

本文链接：https://blog.csdn.net/m0_45703532/article/details/104960701

版权

链表专栏收录该内容

8 篇文章 0 订阅

订阅专栏

本文介绍了四个链表操作的关键算法：通过遍历获取链表长度，找到倒数第k个节点，实现链表的翻转以及利用栈特性进行链表逆序。这些是链表数据结构常见的操作问题，对于理解和处理链表非常有帮助。

摘要由CSDN通过智能技术生成

1.获取长度（其实本质就是遍历）
2.获取倒数第k个结点
3.链表翻转
4.链表逆序（利用栈的特点）

package com;

import java.util.Stack;

public class Demo {

    public static void main(String[] args) {

        Demo demo=new Demo();

        Node one=new Node(1,"opop");
        Node two=new Node(2,"lklk");
        Node three=new Node(3,"hjhj");

        demo.add(one);
        demo.add(two);
        demo.add(three);

       reversePrint(demo.getHead());

      //  System.out.println(getLength(demo.getHead()));

       // System.out.println(search(demo.getHead(),3));
       //reverse(demo.getHead());
       //demo.show();
    }

    private Node head=new Node(0,"");

    public  Node getHead() {
        return head;
    }

    //add
    public void add(Node node){
        Node temp=head;
        while(true)
        {
            if(temp.next==null)
                break;

            temp=temp.next;
        }
        temp.next=node;
    }

    //show
    public void show(){

        if(head.next==null)
            return;

        Node temp=head.next;

        while(temp!=null)
        {
            System.out.println(temp);

            temp=temp.next;
        }

    }

    public static int getLength(Node head){
        int count=0;
        if(head.next==null)
            return 0;

        Node temp=head.next;
        while(true)
        {
            if(temp==null)
                break;
            count++;
            temp=temp.next;
        }
       return count;
}


    //获取倒数第k个结点
    public static Node search(Node head,int index){
        if(head.next==null)
            return null;
        Node temp=head.next;
        int count=0;
        int size=getLength(head);

        //遍历size-count个即可得到倒数第k个结点 (count是倒数第k个结点)

        if(index<=0||index>size)
            return null;

        for(int i=0;i<size-index;i++)
            temp=temp.next;

        return temp;

        }

        //单链表翻转
    public static void reverse(Node head){
        if(head.next==null||head.next.next==null)
            return ;

        //定义辅助指针变量，遍历原来的链表
        Node cur=head.next;
        Node next=null;   //指向当前cur的下一个结点
        Node reverseNode=new Node(0,""); //????新链表

        while(cur!=null)
        {
            next=cur.next;

            cur.next=reverseNode.next;
            reverseNode.next=cur;
            cur=next;
        }

        head.next=reverseNode.next;

    }

    //逆序打印
    public static void reversePrint(Node head){

        Stack<Node> stack=new Stack<>();
        if(head.next==null)
            return;

        Node cur=head.next;
        while(cur!=null)
        {
           stack.push(cur);
           cur=cur.next;

        }
        while(stack.size()>0)
            System.out.println(stack.pop());

    }


    }