JAVA单链表操作

JAVA单链表操作

java单链表图示

import java.util.Hashtable;
import java.util.Scanner;

class Node{
    public int data;
    public Node next = null;

    public Node(int data){
        this.data = data;
    }
}
//单向链表
public class Main {

    public static Node head = null;

    public static void addNode(int d){
        //新建一个节点
        Node newNode = new Node(d);
        //链表为空
        if(null == head){
            head = newNode;
            return;
        }
        //循环找到链表的末尾
        Node tmp = head;
        while (tmp.next != null){
            tmp = tmp.next;
        }
        tmp.next = newNode;
    }

    public static int length() {
        int length = 0;
        Node tmp = head;
        while (tmp.next != null) {
            length ++;
            tmp = tmp.next;
        }
        return length;
    }

    //根据索引删除节点
    public static boolean deleteNode(int index){
        if(index < 1 || index > length()){
            return false;
        }
        //特判删除头指针，因为单向链表没有前驱节点，删除比较简单
        if(index == 1){
            head = head.next;
            return true;
        }
        int i = 1;
        Node preNode = head;
        Node curNode = head.next;
        while (curNode != null){
            //找到索引的位置，将i对应的节点删除，
            //i的前驱节点指向index的后继节点（删除第index个节点）
            if(i == index){
                preNode.next = curNode.next;
                return true;
            }
            preNode = curNode;
            curNode = curNode.next;
            i++;
        }
        return true;
    }

    public static void insertNodeByIndex(int index,int nod){
        //首先需要判断指定位置是否合法，
        if(index < 1 || index > length() + 1){
            System.out.println("插入位置不合法。");
            return;
        }

        Node node = new Node(nod);

        int length = 1;           //记录我们遍历到第几个结点了，也就是记录位置。
        Node temp = head;         //可移动的指针
        while(temp.next != null){ //遍历单链表
            if(index == length++){        //判断是否到达指定位置
                //temp代表的是当前位置的前一个结点。
                //前一个结点        当前位置        后一个结点
                //temp            temp.next     temp.next.next
                //插入操作。
                node.next = temp.next;
                temp.next = node;
                return;
            }
            temp = temp.next;
        }
    }


    public static boolean isEmpty(){

        return null == head ? true : false;
    }

    public static Node orderList(){
        int tmp = 0;
        Node curNode = head;
        Node nextNode = null;
        while (curNode.next != null){
            nextNode = curNode.next;
            //从小到大排序
            while(nextNode != null){
                if(curNode.data > nextNode.data){
                    tmp = curNode.data;
                    curNode.data = nextNode.data;
                    nextNode.data = tmp;
                }
                nextNode = nextNode.next;
            }
            curNode = curNode.next;
        }
        return head;
    }

    /**
     * 去掉重复元素:
     * 需要额外的存储空间hashtable，调用hashtable.containsKey()来判断重复结点
     */
    public static void distinctLink(){
        Node temp = head;
        Node pre = null;
        Hashtable<Integer, Integer> hb = new Hashtable<Integer, Integer>();
        while(temp != null){
            if(hb.containsKey(temp.data)){//如果hashtable中已存在该结点，则跳过该结点
                pre.next = temp.next;
            }else{//如果hashtable中不存在该结点，将结点存到hashtable中
                hb.put(temp.data, 1);
                pre = temp;
            }
            temp = temp.next;
        }
    }

    /**
     * 返回倒数第k个结点,
     * 两个指针，第一个指针向前移动k-1次，之后两个指针共同前进，
     * 当前面的指针到达末尾时，后面的指针所在的位置就是倒数第k个位置
     */
    public static Node findReverNode(int k){
        if(k<1 || k>length()){//第k个结点不存在
            return null;
        }
        Node first = head;
        Node second = head;
        for(int i=0; i<k-1; i++){//前移k-1步
            first = first.next;
        }
        while(first.next != null){
            first = first.next;
            second = second.next;
        }
        return second;
    }

    /**
     * 查找正数第k个元素
     */
    public static Node findNode(int k){
        if(k<1 || k>length()){//不合法的k
            return null;
        }
        Node temp = head;
        for(int i = 0; i<k-1; i++){
            temp = temp.next;
        }
        return temp;
    }

    /**
     * 反转链表，在反转指针前一定要保存下个结点的指针
     */
    public static void reserveLink(){
        Node curNode = head;//头结点
        Node preNode = null;//前一个结点
        while(curNode != null){
            Node nextNode = curNode.next;//保留下一个结点
            curNode.next = preNode;//指针反转
            preNode = curNode;//前结点后移
            curNode = nextNode;//当前结点后移
        }
        head = preNode;
    }

    //递归方法。先找到最后一个节点，然后从最后一个开始反转,然后当前节点反转时其后面的节点已经进行反转了，不需要管。
    // 最后返回原来的最后一个节点
    /*public static Node reverse2(Node node, Node prev) {
        if (node.next == null) {
            node.next = prev;
            return node;
        } else {
            Node re = reverse2(node.next, node);
            node.next = prev;
            return re;
        }
    }*/

    /**
     * 反向输出链表，三种方式：
     * 方法一、先反转链表，再输出链表，需要链表遍历两次
     * 方法二、把链表中的数字放入栈中再输出，需要维护额外的栈空间
     * 方法三、依据方法2中栈的思想，通过递归来实现，递归起始就是将先执行的数据压入栈中，再一次出栈
     */
    public static void reservePrt(Node node){
        if(node != null){
            reservePrt(node.next);
            System.out.print(node.data + " ");
        }
    }

    /**
     * 寻找单链表的中间结点：
     * 方法一、先求出链表的长度，再遍历1/2链表长度，寻找出链表的中间结点
     * 方法二、：
     * 用两个指针遍历链表，一个快指针、一个慢指针，
     * 快指针每次向前移动2个结点，慢指针一次向前移动一个结点，
     * 当快指针移动到链表的末尾，慢指针所在的位置即为中间结点所在的位置
     */
    public static Node findMiddleNode(){
        Node slowPoint = head;
        Node quickPoint = head;
        //quickPoint.next == null是链表结点个数为奇数时，快指针已经走到最后了
        //quickPoint.next.next == null是链表结点数为偶数时，快指针已经走到倒数第二个结点了
        //链表结点个数为奇数时,返回的是中间结点；链表结点个数为偶数时，返回的是中间两个结点中的前一个
        while(quickPoint.next != null && quickPoint.next.next != null){
            slowPoint = slowPoint.next;
            quickPoint = quickPoint.next.next;
        }
        return slowPoint;
    }

    /**
     * 判断链表是否有环：
     * 设置快指针和慢指针，慢指针每次走一步，快指针每次走两步
     * 当快指针与慢指针相等时，就说明该链表有环
     */
    public static boolean isRinged(){
        if(head == null){
            return false;
        }
        Node slow = head;
        Node fast = head;
        while(fast.next != null && fast.next.next != null){
            slow = slow.next;
            fast = fast.next.next;
            if(fast == slow){
                return true;
            }
        }
        return false;
    }

    /**
     * 返回链表的最后一个结点
     */
    public Node getLastNode(){
        Node temp = head;
        while(temp.next != null){
            temp = temp.next;
        }
        return temp;
    }

    //打印链表
    public static void printList(){
        Node tmp = head;
        while(tmp != null){
            System.out.print(tmp.data + " ");
            tmp = tmp.next;
        }
    }

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        while (true) {
            int s = sc.nextInt();
            if(s == 0) {
                break;
            }else {
                addNode(s);
                //System.out.println(s);
            }
        }
        //输入样例
        //1
        //2
        //3
        //0
        //输入0结束
        System.out.println("length is " + length());
        System.out.println("before order");
        printList();
        orderList();
        System.out.println("after order");
        printList();

        System.out.println("插入位置以及数值：");

        Scanner in = new Scanner(System.in);
        int index1 = in.nextInt();
        int nod = in.nextInt();
        insertNodeByIndex(index1 , nod);
        printList();

        System.out.println("删除位置的索引：");
        int index2 = in.nextInt();
        deleteNode(index2);
        printList();

        System.out.println("去除重复元素：");
        distinctLink();
        printList();

        System.out.println("返回倒数第k个结点：");
        int k = in.nextInt();
        Node nk = findReverNode(k);
        System.out.println(nk);

        System.out.println("反转链表：");
        reserveLink();
        printList();

        System.out.println("反向输出链表：");
        Node re = head;
        reservePrt(re);
        printList();

        System.out.println("中间节点：");
        Node mid = findMiddleNode();
        System.out.println(mid);

        System.out.println("是否有环：");
        System.out.println(isRinged());

    }
}

https://www.cnblogs.com/tengdai/p/9279421.html