2021/9/14 ～15(单链表 + 单链表反转)

2021/9/14 ～15(单链表)

dizzy day

单链表习题

对于单链表的再度学习，我明白了引用的概念，变量在栈区，new 出来的对象在堆区。

变量可以操作内存中的数据。a = head. 指变量a指向head变量所在的内存区。 即a和head都指向了一块内存区。a和head = 其他值并不会改变内存地址的值。

做题了。

单链表反转4种方式

http://c.biancheng.net/view/8105.html

我这里的头节点包含了信息，在某些操作时还是需要头节点指针的（纯粹）

package LinkedList;

import java.util.Stack;

/**
 * 我定义的单向链表，其中第一个元素index为1
 *
 * @param <T>
 */
public class MyLinkedList<T> {
    private Node<T> head;
    private Node<T> tail;
    private int size; //仅仅记录链表长度，不做规定

    public Node<T> getTail() {
        return tail;
    }

    private class Node<T> {
        private T data;
        private Node<T> next;
        public Node() {
            data = null;
            next = null;
        }
        public Node(T data) {
            this.data = data;
            next = null;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "data=" + data +
                    ", next="  +
                    '}';
        }
    }

    public int getSize() {
        return this.size;
    }

    public void setTail(Node<T> tail) {
        this.tail = tail;
    }

    //构造函数
    public MyLinkedList() {
        this.head = null;
        this.tail = null;
        this.size = 0;
    }

    public T getFirst() throws Exception {
        rangeCheck();
        return this.head.data;
    }
    public Node<T> getHead(){
        return this.head;
    }
    private void rangeCheck() throws Exception {
        if (isEmpty()) {
            throw new Exception("List is empty");
        }
    }

    private void indexCheck(int index) throws Exception {
        if (index > this.size || index <= 0) {
            throw new IllegalArgumentException("Illegal Index");
        }
    }

    public T getLast() throws Exception {
        rangeCheck();
        return this.tail.data;
    }

    public Boolean isEmpty() {
        return this.size == 0;
    }

    public Boolean isNotEmpty() {
        return !isEmpty();
    }

    /**
     * 我定义第一个节点就为头节点，最后一个节点为size大小,index 从一开始
     */
    public T getAt(int index) throws Exception {
        return (T) getNodeAt(index).data;
    }

    /**
     * 根据Node中的data查找在表中的位序
     *
     * @param data
     */
    public int getIndexAt(T data) throws Exception {
        int index = 1;
        rangeCheck();
        Node<T> tmp = this.head;
        while (tmp != null && tmp.data != data) {
            tmp = tmp.next;
            index++;
        }
        if (tmp == null) return -1;
        else return index;
    }

    public Node getNodeAt(int index) throws Exception {
        rangeCheck();
        indexCheck(index);
        Node<T> temp = this.head;
        for (int i = 1; i <= index - 1; i++) {
            temp = temp.next; // 这段代码多多理解。temp = 一个内存地址
        }
        return temp;
    }

    /**
     * 尾插法
     *
     * @param data
     */
    public void addLast(T data) {
        // create
        Node<T> node = new Node();
        node.data = data;
        // attach
        if (isNotEmpty()) {
            this.tail.next = node;
        }
        if (isEmpty()) {
            this.head = node;
        }
        this.tail = node;
        this.size += 1;
    }

    /**
     * 头插法
     *
     * @param data
     */
    public void addFirst(T data) {
        Node<T> node = new Node();
        node.data = data;
        if (isNotEmpty()) {
            node.next = head;
        }
        if (isEmpty()) {
            this.tail = node;
        }
        this.head = node;
        this.size += 1;
    }
    public void addFirst(Node<T> node) {
        if (isNotEmpty()) {
            node.next = this.head;
        }
        if (isEmpty()) {
            this.tail = node;
            this.tail.next = null;
        }
        this.head = node;
        this.size += 1;
    }



    /**
     * 假如idx=1，那么头插，如果idx>siz，尾插
     *
     * @param data
     * @param idx
     */
    public void addAt(T data, int idx) throws Exception {
        if (idx <= 0) {
            throw new IllegalArgumentException("Illegal Index");
        }
        if (idx == 1) {
            addFirst(data);
        } else if (idx > size) {
            addLast(data);
        }
        Node<T> node = new Node();
        node.data = data;
        Node preNode = getNodeAt(idx - 1);
        node.next = preNode.next;
        preNode.next = node;
    }

    public T removeFirst() throws Exception {
        rangeCheck();
        Node<T> tmp = this.head;
        if (this.size == 1) {
            this.head = null;
            this.tail = null;
            this.size = 0;
        } else {
            head = head.next;
            this.size--;
        }
        return tmp.data;
    }

    public T removeLast() throws Exception {
        rangeCheck();
        if (this.size == 1) {
            this.head = null;
            this.tail = null;
            this.size = 0;
        }
        Node<T> tmp = this.tail;
        Node preNode = getNodeAt(this.size - 1);
        preNode.next = null;
        this.tail = preNode;
        this.size--;
        return tmp.data;
    }

    public T removeAt(int idx) throws Exception {
        rangeCheck();
        indexCheck(idx);
        if (idx == 1) {
            return removeFirst();
        } else if (idx == this.size) {
            return removeLast();
        }
        Node<T> prefix = getNodeAt(idx - 1);
        Node<T> removeNode = prefix.next;
        prefix.next = removeNode.next;
        this.size--;
        return removeNode.data;
    }

    public void removeAll() throws Exception {
        while (this.size > 0) {
            removeFirst();
        }
    }

    public void display() {
        System.out.println("========================");
        Node<T> temp = this.head;
        while (temp != null) {
            System.out.println(temp.data);
            temp = temp.next;
        }
        System.out.println("Over");
    }

    /**
     * 新的需求，根据id排序
     * 今天状态好差我就不写了
     * 思路：1。在头节点设置前缀：preHead
     * 2。有bug tail怎么变化呢？
     */
    public void addByOrder(Integer data) {
        Node<Integer> node = new Node<Integer>(data);
        Node<Integer> preHead = new Node<Integer>();
        preHead.next = (Node<Integer>) this.head;
        Node<Integer> tmp = preHead;
        while (true) {
            if (tmp.next == null) {
                addLast((T) data); // 操作有设置tail
                break;
            }
            if (tmp.next.data > node.data) {
                node.next = tmp.next;
                tmp.next = node;
                break;
            }
            if (tmp.next.data == node.data) {
                System.out.println("重复啦");
                break;
            }
            tmp = tmp.next;
        }

    }

    /**
     * 习题练习一 ： 获取链表节点个数
     */
    public int getLength() {
        Node<T> tmp = this.head;
        int count = 0;
        while (tmp != null) {
            count++;
            tmp = tmp.next;
        }
        return count;
        // return getSize();
    }

    /**
     * 习题练习二：查找单链表中的倒数第index个节点、
     * 解答：因为是单链表，只能从头开始，不能从尾巴开始，效率有点低
     *
     * @param index
     * @return
     * @throws Exception
     */
    public Node<T> getIndexOfLast(int index) throws Exception {
        return getNodeAt(size - index + 1);
    }

    /**
     * 链表反转 解决方法一：头插法 2🌟🌟
     */
    public MyLinkedList<T> linkedListReverse() throws Exception {
        if (this.head==null || this.head.next==null){
            System.out.println("链表为空or只有一个节点");
            return null ;
        }
        MyLinkedList list = new MyLinkedList();
        Node<T> tmp;
        while(head!=null){
            tmp = this.head;
            head = head.next;
            list.addFirst(tmp);
        }
        return list;
    }

    /**
     * 链表反转 解决方法二：迭代反转   推荐指数🌟🌟🌟🌟🌟
     *          注意点：下面这种while循环不会导致空指针！
     */
    public void linkedListReverse2() {
        if (head == null || head.next == null) {
            System.out.println("can't not reverse");
            return;
        }
        Node<T> beg = null;
        Node<T> mid = head;
        Node<T> end = head.next;
        while (true) {
            mid.next = beg;
            if (end == null) {
                break;
            }
            beg = mid;
            mid = end;
            end = end.next;
        }
        Node<T> tmp = tail;
        tail = head;
        head = tmp;
    }
    /**
     * 链表反转 解决方法三：迭代反转    思路NB
     *                   推荐指数🌟🌟🌟🌟🌟
     *                   迭代可以反着来
     *                   不知道为什么有bug ==>需要解决首位的位置
     */
    public Node<T> linkedListReverse3(Node<T> head) throws Exception {
        if (head==null || head.next==null){
            // 需要交换首位的位置！！
            Node<T> tmp = this.head;
            this.head = head;
            this.tail = tmp;
            return head;
        }
        // newNode永远是尾
        Node<T> newNode = linkedListReverse3(head.next);
        head.next.next = head;
        head.next = null;
        return newNode;
    }

    /**
     * 逆序打印单链表  方式一：栈
     */
    public  void reverseListAndPrint(){
        if (head==null){
            return;
        }
        Stack<Node<T>> stack = new Stack<>();
        Node<T> copyHead = head;
        Node<T> tmp ;
        while(head!=null){
            tmp = head;
            head = head.next;
            stack.add(tmp);
        }
        this.head = copyHead;
        while(stack.size()>0){
            System.out.println(stack.pop());
        }
    }
    /**
     * 逆序打印单链表  方式二：递归
     *
     */
    public void reverseListAndPrint3(Node<T> head){
        if(head !=null && head.next!=null){
            reverseListAndPrint3(head.next);
        }
        System.out.println(head.data);
    }

}

测试

package LinkedList;

import LinkedList.pojo.Person;

import java.util.ArrayList;

public class MyLinkedListTest {
    public static void main(String[] args) throws Exception {
        MyLinkedList<Person> list = new MyLinkedList<Person>();
        Person person = new Person(1,"22",1);
        Person person2 = new Person(2,"22",1);
        Person person3 = new Person(3,"22",1);
        Person person4 = new Person(4,"22",1);
        list.addLast(person);
        list.addLast(person2);
        list.addLast(person4);
        list.addLast(person3);
        list.display();
        System.out.println("==");
        list.reverseListAndPrint3(list.getHead());
        System.out.println("size"+list.getSize());
        System.out.println("firse"+list.getFirst());
        System.out.println("last"+list.getLast());

        System.out.println("000000000000000000000000000000");
        // first element i.e.10 should be printed


        // element at 3rd index i.e.40 should be printed

        //System.out.println(list.getAt(3));

        // a memory address of a node should be printed

        System.out.println(list.getNodeAt(3));

        // 10 should be removed and printed

        System.out.println(list.removeFirst());

        // 40 should be removed and printed

        System.out.println(list.removeLast());

        // list without 10 and 40 should be printed

        list.display();

        // 100 should be added at first


        list.display();

        // 30 should be removed

        list.removeAt(2);

        // 300 should be added at 2nd index

        list.display();
        System.out.println(list.getSize());
        list.removeAll();
        System.out.println(list.getSize());

    }
}