Java数据结构与算法

1. 数组

1.1 稀疏数组

/**
 * 欧几里得算法
 *      计算两个非负整数p和q的最大公约数：若q为0,则最大公约数就是p,否则,将p除以得到的余数r
 *      则p和q的最大公约数即为q和r的最大公约数
 */
public class GcdTest {

    public static void main(String[] args) {

        System.out.println("请输入两个数: ");

        Scanner scanner = new Scanner(System.in);

        int p = scanner.nextInt();

        int q = scanner.nextInt();

        int result = gcd(p,q);

        System.out.println("最大公约数为: " + result);

        scanner.close();  //关闭流

    }

    public static int gcd(int p,int q){
        if(q == 0){
            return p;
        }else{
            int r = p % q;
            return gcd(q,r);
        }
    }

}



/**
 * 稀疏数组的实现
 *      1.二维数组转稀疏数组的思路
 *          a.遍历原始的二维数组，得到有效数据的个数sum
 *          b.根据sum就可以创建稀疏数组sparseArray  int[sum + 1][3]
 *          c.将二维数组的有效数据存入到稀疏数组
 *      2.稀疏数组转原始数组的思路
 *          a.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
 *          b.再读取稀疏数组后几行的数据，并赋给原始的二维数组即可
 */
public class SparseArray {

    public static void main(String[] args) {

        /*
            创建一个原始的二维数组 11 * 11
            0:表示没有棋子
            1:表示黑子
            2:表示蓝子
         */
        int chessArr[][] = new int[11][11];

        chessArr[1][2] = 1;
        chessArr[2][3] = 2;
        chessArr[5][7] = 4;

        System.out.println("原始的二维数组: ");

        for (int[] row : chessArr){
            for (int data : row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

        //1.先遍历二维数组，得到非0数据的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr[i][j] != 0){
                    sum++;
                }
            }
        }

        //2.创建对应的稀疏数组
        int sparseArray[][] = new int[sum + 1][3];

        //给稀疏数组赋值
        sparseArray[0][0] = 11;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = sum;

        //用来记录是第几个非0数据
        int count = 0;

        //遍历二维数组，将非0数据存放到稀疏数组中
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr[i][j] != 0){
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = chessArr[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println();
        System.out.println("得到的稀疏数组: ");

        for (int i = 0; i < sparseArray.length; i++) {
            System.out.printf("%d\t%d\t%d\t\n",sparseArray[i][0],sparseArray[i][1],sparseArray[i][2]);
        }
        System.out.println();

        //将稀疏数组恢复成原始的二维数组
        int newChessArray[][] = new int[sparseArray[0][0]][sparseArray[0][1]];

        //读取稀疏数组后几行的数据(从第二行开始)，并赋给原始的二维数组即可
        for (int i = 1; i < sparseArray.length; i++) {
            newChessArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }

        //恢复后的原始二维数组
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                System.out.printf("%d\t",newChessArray[i][j]);
            }
            System.out.println();
        }
    }

}

斐波那契数列

/*
斐波那契数列
	0 1 1 2 3 5 8 13 21 ...
每一项都是前一项和前两项之和
*/
public class Fib {

    public static void main(String[] args) {
        System.out.println(fib2(0));
        System.out.println(fib2(1));
        System.out.println(fib2(2));
        System.out.println(fib2(3));
        System.out.println(fib2(4));
        System.out.println(fib2(5));
        System.out.println(fib2(6));

    }

    //时间复杂度分析O(2^n),效率极低
    public static int fib1(int n){
        if(n <= 1){
            return n;
        }
        return fib1(n - 1) + fib1(n - 2);
    }

    //时间复杂度分析O(n),效率较高
    public static int fib2(int n){
        if(n <= 1){
            return n;
        }
        int first = 0;
        int second = 1;
        int sum = 0;
        for(int i = 0;i < n - 1;i++){
            sum = first + second;
            first = second;
            second = sum;
        }
        return second;
    }
    
    //简化版
    public static int fib3(int n){
        if(n <= 1){
            return n;
        }
        int first = 0;
        int second = 1;
        while(n-- > 1){  //执行n-1次
            second = first + second;
            first = second - first;   //将原来的second赋给first
        }
        return second;
    }
}

2. 线性表

2.1 顺序表

//实现动态数组
public class DynamicArrayTest {

    public static void main(String[] args) {
        //创建动态数组
        DynamicArray<Integer> array = new DynamicArray();
        //添加元素
        array.add(10);
        array.add(20);
        array.add(30);
        //往指定下标添加元素
        array.add(1,40);
        //删除元素
        array.remove(1);
        //修改元素
        array.set(1,2);
        //输出
        System.out.println(array);
    }

}

//定义List，因为数组和单链表的实现操作一样，可以同时实现该接口
public interface List<E> {

    int size();

    boolean isEmpty();

    void clear();

    boolean contains(E data);

    void add(E data);

    void add(int index,E data);

    void remove(E data);

    E remove(int index);

    E get(int index);

    E set(int index,E data);

    int indexOf(E data);
}

class DynamicArray<E> implements List{

    private int size;   //数组大小

    private E[] array;   //存放元素

    private static final int DEFAULT_CAPATICY = 10;   //数组默认容量

    private static final int ELEMENT_NOT_FOUND = -1;  //数组下标找不到时的返回值

    public DynamicArray(){
        //初始化数组
        array = (E[]) new Object[DEFAULT_CAPATICY];
    }

    public DynamicArray(int capaticy){
        //判断是否合理
        if(capaticy <= 0){
            throw new RuntimeException("数组容量应该大于0");
        }
        //如果传进来的容量比默认值小，那就直接用默认值
        capaticy = (capaticy < DEFAULT_CAPATICY) ? DEFAULT_CAPATICY : capaticy;
        array = (E[]) new Object[capaticy];
    }

    //返回数组大小
    public int size(){
        return size;
    }

    //判断数组是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    //在数组尾部添加元素
    public void add(E data){
        array[size++] = data;
    }

    //往指定下标插入元素
    public void add(int index,E data){
        if(index < 0 || index > size){
            throw new IndexOutOfBoundsException("你输入的下标不合法");
        }

        //一旦容量不够，这里需要用到数组的扩容,保证数组的容量
        ensureCapacity(size + 1);

        //index后面的元素往后移
        for(int i = size;i > index;i--){
            array[i + 1] = array[i];
        }
        array[index] = data;
        size++;
    }

    private void ensureCapacity(int capacity){
        //旧容量
        int oldCapacity = array.length;
        //如果旧容量比当前数组的大小大，也就是说此时数组还够用，就不需要扩容
        if(oldCapacity > capacity){
            return;
        }
        //扩容: 新容量为旧容量的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);   // oldCapacity >> 1 表示减小一半
        E[] newArray = (E[]) new Object[newCapacity];
        //移动元素
        for(int i = 0;i < size;i++){
            newArray[i] = array[i];
        }
        //让array引用指向新的数组，旧的数组就会被垃圾回收器回收
        array = newArray;
    }

    //删除指定下标的元素
    public E remove(int index){
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("你输入的下标不合法");
        }
        //定义res保存index下标对应的元素
        E res = array[index];
        //index后面的所有元素往前移
        for(int i = index + 1;i < size;i++){
            array[i - 1] = array[i];
        }
        size--;
        array[size] = null;
        
        //每删除一个元素，需要考虑是否需要缩容
        trim();
        
        return res;
    }
    
    //缩容
    private void trim(){
        int capacity = array.length;
        int newCapacity = capacity >> 1;  //新容量缩小为一半
        if(size >= newCapacity || newCapacity <= DEFAULT_CAPATICY){
            return;
        }
        //程序执行到这，表示剩余空间还有很多
        E[] newArray = (E[]) new Object[newCapacity];
        //移动元素
        for(int i = 0;i < size;i++){
            newArray[i] = array[i];
        }
        array = newArray;
    }

    //删除指定的元素
    public void remove(E data){
        remove(indexOf(data));
    }

    //返回指定下标的元素
    public E get(int index){
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("你输入的下标不合法");
        }
        return array[index];
    }

    //设置指定下标的元素,并返回覆盖之前的元素
    public E set(int index,E data){
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("你输入的下标不合法");
        }
        E res = array[index];
        array[index] = data;
        return res;
    }

    //查看指定元素的下标
    public int indexOf(E data){
        for(int i = 0;i < size;i++){
            if(data.equals(array[i])){
                return i;
            }
        }
        return ELEMENT_NOT_FOUND;
    }

    //判断是否包含某个元素
    public boolean contains(E data){
        return indexOf(data) != ELEMENT_NOT_FOUND;
    }

    //清楚所有的元素
    public void clear(){
        for(int i = 0;i < size;i++){
            array[i] = null;
        }
        size = 0;
        
        //清空后，数组容量也需要缩容
        if(array != null && array.length > DEFAULT_CAPATICY){
            array = (E[]) new Object[DEFAULT_CAPATICY];
        }
    }

    @Override
    public String toString() {
        StringBuilder s = new StringBuilder();
        s.append("[");
        for(int i = 0;i < size;i++){
            if(i != 0){
                s.append(", ");
            }
            s.append(array[i]);
        }
        s.append("]");
        return s.toString();
    }
}

2.2 单链表

//方式一
public class SingleLinkedList {

    public static void main(String[] args) {

        //先创建节点
        PersonNode personNode1 = new PersonNode(1, "汤昕", "昕昕");
        PersonNode personNode2 = new PersonNode(2, "李一桐", "一桐");
        PersonNode personNode3 = new PersonNode(3, "袁冰妍", "冰淇淋");
        PersonNode personNode4 = new PersonNode(4, "林允儿", "允儿");

        //创建一个链表
        SingleList singleList = new SingleList();

        //加入节点
//        singleList.add(personNode1);
//        singleList.add(personNode2);
//        singleList.add(personNode3);
//        singleList.add(personNode4);

        //按照顺序添加
        singleList.addByOrder(personNode1);
        singleList.addByOrder(personNode3);
        singleList.addByOrder(personNode4);
        singleList.addByOrder(personNode2);
        //遍历
        System.out.println("修改之前的链表: ");
        singleList.list();

        //测试修改节点
        PersonNode newPersonNode = new PersonNode(4, "赵丽颖", "萤火虫");
        singleList.update(newPersonNode);
        //遍历
        System.out.println("修改之后的链表: ");
        singleList.list();

        //删除结点
        singleList.delete(4);
//        singleList.delete(2);
        //遍历
        System.out.println("删除后的链表: ");
        singleList.list();

        //链表的有效节点的个数
        System.out.println("单链表有效节点的个数为: " + getLength(singleList.getHead()));


        //获取倒数第k个结点
        PersonNode resultNode = findLastIndexNode(singleList.getHead(), 1);
        System.out.println("resultNode = " + resultNode);


        //测试单链表的反转
        System.out.println("反转之前的链表: ");
        singleList.list();

        System.out.println("反转之后的链表: ");
        reverseList(singleList.getHead());
        singleList.list();


        //逆序打印单链表
        System.out.println("逆序打印的单链表(链表本身的结构并没有改变): ");
        reversePrintList(singleList.getHead());
    }

    //获取单链表有效节点的个数(如果是带头结点的链表，则不统计头节点)
    public static int getLength(PersonNode head) {
        if (head.next == null) {
            return 0;
        } else {
            int length = 0;
            PersonNode temp = head.next;

            while (temp != null) {
                length++;
                temp = temp.next;
            }
            return length;
        }
    }

    /*
        新浪面试题:查找单链表中的倒数第k个结点
            思路:
                1.编写方法，接收两个参数:head和index(表示倒数第index个结点)
                2.先把链表遍历一遍，得到链表的总长度(调用getLength)
                3.得到长度后，我们可以从链表的第一个结点开始，遍历(length - index)个，就可以得到
                4.如果找到了，就返回该结点，否则返回空
     */
    public static PersonNode findLastIndexNode(PersonNode head, int index) {
        if (head.next == null) {
            return null;
        } else {
            int length = getLength(head);

            if (index <= 0 || index > length) {
                return null;
            } else {
                PersonNode temp = head.next;

                for (int i = 0; i < (length - index); i++) {
                    temp = temp.next;
                }
                return temp;
            }
        }
    }

    /*
        腾讯面试题:实现单链表的反转
            思路:
                1.先定义一个新的头结点reverseHead = new PersonNode()
                2.从头到尾遍历原来的链表，每遍历一个结点，就将其取出，并放在新的链表头节点reverseHead的最前端
                3.原来的链表的头节点head.next = reverseHead.next
     */
    public static void reverseList(PersonNode head) {
        //如果当前链表为空，或者只有一个结点，则无需进行反转，直接返回
        if (head.next == null || head.next.next == null) {
            return;
        }
        PersonNode temp = head.next;
        PersonNode reverseHead = new PersonNode();  //定义新的头节点
        PersonNode nextNode = null;   //指向当前结点(temp)的下一个结点

        while (temp != null) {
            nextNode = temp.next;  //先暂时保存当前结点的后一个结点，避免取出当前结点时，会找不到下一个结点
            temp.next = reverseHead.next;  //将当前结点的下一个结点指向新的链表的最前端
            reverseHead.next = temp;
            temp = nextNode;
        }
        //将head.next指向reverseHead.next，实现单链表的反转
        head.next = reverseHead.next;
    }

    /*
        百度面试题:逆序打印单链表
            思路:
                1.方式一:先将单链表进行反转操作，然后再遍历即可，这样做的问题是会破坏原来的单链表的结构，不可取
                2.方式二:可以利用栈，将各个结点压入栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果
     */
    public static void reversePrintList(PersonNode head) {
        if (head.next == null) {
            return;
        }
        Stack<PersonNode> stack = new Stack<>();
        PersonNode temp = head.next;

        while (temp != null) {
            stack.push(temp);
            temp = temp.next;
        }

        //出栈，逆序打印
        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }
    }

}

//定义SingleList类来管理PersonNode对象
class SingleList {
    //先初始化一个头节点,里面可以不放东西，注意:头节点不要动
    private PersonNode head = new PersonNode();

    //获取头节点
    public PersonNode getHead() {
        return head;
    }

    /*
        添加节点到单向链表
            思路:当不考虑编号的顺序时
                1.找到当前链表的最后一个节点
                2.将最后这个节点的next指向我们要添加的节点
     */
    public void add(PersonNode node) {
        //定义辅助指针，代替head节点
        PersonNode temp = head;

        //遍历链表，找到最后一个节点
        while (true) {
            if (temp.next == null) {
                //此时说明已经到了最后
                break;
            }
            //如果没有找到，就将temp后移
            temp = temp.next;
        }
        //当退出循环时，说明temp就指向了链表的最后,然后让最后这个节点的next指向我们要添加的node
        temp.next = node;
    }

    //添加节点到链表的指定位置
    public void addByOrder(PersonNode node) {
        PersonNode temp = head;

        //flag表示添加的编号是否存在，默认为false
        boolean flag = false;

        while (true) {
            if (temp.next == null) {
                break;
            } else if (temp.next.getNo() > node.getNo()) {
                break;
            } else if (temp.getNo() == node.getNo()) {
                flag = true;  //说明编号存在
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            //说明编号存在，不能添加
            System.out.println("准备插入的编号" + node.getNo() + "已经存在，不能加入");
        } else {
            //插入到temp的后面
            node.next = temp.next;
            temp.next = node;
        }
    }

    //修改节点信息，根据编号no来修改
    public void update(PersonNode node) {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空...");
            return;
        } else {
            //找到需要修改的节点
            PersonNode temp = head.next;
            boolean flag = false;

            while (true) {
                if (temp == null) {
                    //表示链表已经遍历结束
                    break;
                } else if (temp.getNo() == node.getNo()) {
                    flag = true;
                    break;
                }
                temp = temp.next;
            }
            //根据flag判断是否找到了要修改的节点
            if (flag) {
                temp.setName(node.getName());
                temp.setNickName(node.getNickName());
            } else {
                System.out.println("没有找到编号为" + node.getNo() + "的节点,无法修改...");
            }
        }
    }

    /*
        从单链表中删除节点的思路:
            1.先找到需要删除的这个节点的前一个结点
            2.让temp.next = temp.next.next;
            3.被删除的结点将不会有其他引用指向，会被JVM垃圾回收机制回收
     */
    public void delete(int no) {
        PersonNode temp = head;
        boolean flag = false;

        while (true) {
            if (temp.next == null) {
                break;
            } else if (temp.next.getNo() == no) {
                //说明找到了待删除结点的前一个结点temp
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.println("要删除的" + no + "结点不存在,无法删除...");
        }
    }

    //遍历链表
    public void list() {
        //首先判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空...");
            return;
        } else {
            PersonNode temp = head.next;
            while (true) {
                //判断是否到了最后
                if (temp == null) {
                    break;
                }
                //输出节点信息
                System.out.println(temp);
                //将temp后移
                temp = temp.next;
            }
        }
    }

}


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

    //构造器
    public PersonNode() {

    }

    public PersonNode(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "PersonNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

//方式二
public abstract class AbstractList<E> implements List<E> {

    protected int size;

    public void outOfBounds(int index){
        throw new IndexOutOfBoundsException("Index" + index + ", Size: " + size);
    }

    public void rangeCheck(int index){
        if(index < 0 || index >= size){
            outOfBounds(index);
        }
    }

    public void rangeCheckForAdd(int index){
        if(index < 0 || index > size){
            outOfBounds(index);
        }
    }

    public boolean contains(E data) {
        return indexOf(data) != ELEMENT_NOT_FOUND;
    }

    public void remove(E data) {

    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int indexOf(E data) {
        return 0;
    }
}

//没有增加头结点
public class LinkedList<E> extends AbstractList<E> {

    private Node<E> first;   //指向单链表的第一个节点

    //定义静态内部类
    private static class Node<E>{

        E element;  //节点存放的值

        Node<E> next;  //存放下一个节点的地址

        public Node(E element,Node<E> next){
            this.element = element;
            this.next = next;
        }

    }

    public void clear() {
        size = 0;
        //让头指针指向null
        first = null;
    }

    //获取index位置对应的节点对象
    public Node<E> node(int index){
        rangeCheck(index);
        //让first移动到index位置对应的节点
        Node<E> node = first;
        for(int i = 0;i < index;i++){
            node = node.next;
        }
        return node;
    }

    public void add(E data){
        add(size,data);
    }

    public void add(int index, E data) {
        if(index == 0){
            Node<E> node = new Node<>(data, first);
            //first始终指向第一个节点
            first = node;
        }else{
            //先获取index-1位置处的节点
            Node<E> preNode = node(index - 1);
            Node<E> newNode = new Node<>(data, preNode.next);
            preNode.next = newNode;
        }
        size++;
    }

    public E remove(int index) {
        //先保存idnex位置处的节点
        Node<E> resNode = first;
        if(index == 0){
            first = first.next;
        }else{
            Node<E> preNode = node(index - 1);
            resNode = preNode.next;
            if(index == size){
                preNode.next = null;
            }else{
                preNode.next = resNode.next;
            }
        }
        size--;
        return resNode.element;
    }

    public E get(int index) {
        return node(index).element;
    }

    public E set(int index, E data) {
        Node<E> node = node(index);
        E res = node.element;
        node.element = data;
        return res;
    }

    public int indexOf(E data) {
        Node<E> node = first;
        for(int i = 0;i < size;i++){
            if(data.equals(node.element)){
                return i;
            }
            node = node.next;
        }
        return ELEMENT_NOT_FOUND;
    }

    @Override
    public String toString() {
        StringBuilder s = new StringBuilder();
        Node<E> node = first;
        s.append("[");
        for(int i = 0;i < size;i++){
            if(i != 0){
                s.append(", ");
            }
            s.append(node.element);
            node = node.next;
        }
        s.append("]");
        return s.toString();
    }
}

public class LinkedListTest {

    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>();
        list.add(10);
        list.add(0,20);
        list.add(30);
        list.add(list.size(),40);
        list.remove(1);
        System.out.println(list);
    }

}

//增加虚拟的头结点
public class LinkedList2<E> extends AbstractList<E> {

    private Node<E> first;   //指向单链表的第一个节点

    public LinkedList2(){
        first = new Node(null,null);  //不存放任何值
    }

    //定义静态内部类
    private static class Node<E>{

        E element;  //节点存放的值

        Node<E> next;  //存放下一个节点的地址

        public Node(E element,Node<E> next){
            this.element = element;
            this.next = next;
        }

    }

    public void clear() {
        size = 0;
        //让头指针的next指向null
        first.next = null;
    }

    //获取index位置对应的节点对象
    public Node<E> node(int index){
        rangeCheck(index);
        //让first移动到index位置对应的节点
        Node<E> node = first.next;      //first.next指向的才是真正的第一个节点
        for(int i = 0;i < index;i++){
            node = node.next;
        }
        return node;
    }

    public void add(E data){
        add(size,data);
    }

    public void add(int index, E data) {
        rangeCheckForAdd(index);
        //先获取index-1位置处的节点,如果index==0,直接指向first
        Node<E> preNode = (index == 0 ? first : node(index - 1));
        Node<E> newNode = new Node<>(data, preNode.next);
        preNode.next = newNode;
        size++;
    }

    public E remove(int index) {
        rangeCheck(index);
        Node<E> preNode = (index == 0 ? first : node(index - 1));
        //先保存idnex位置处的节点
        Node<E> resNode = preNode.next;
        if(index == size){
            preNode.next = null;
        }else{
            preNode.next = resNode.next;
        }
        size--;
        return resNode.element;
    }

    public E get(int index) {
        return node(index).element;
    }

    public E set(int index, E data) {
        Node<E> node = node(index);
        E res = node.element;
        node.element = data;
        return res;
    }

    public int indexOf(E data) {
        Node<E> node = first.next;
        for(int i = 0;i < size;i++){
            if(data.equals(node.element)){
                return i;
            }
            node = node.next;
        }
        return ELEMENT_NOT_FOUND;
    }

    @Override
    public String toString() {
        StringBuilder s = new StringBuilder();
        Node<E> node = first.next;
        s.append("[");
        for(int i = 0;i < size;i++){
            if(i != 0){
                s.append(", ");
            }
            s.append(node.element);
            node = node.next;
        }
        s.append("]");
        return s.toString();
    }
}

2.3 双链表

//方式一
public class DoubleLinkedList {

    public static void main(String[] args) {

        //先创建节点
        PersonDoubleNode personNode1 = new PersonDoubleNode(1, "王晨", "晨晨");
        PersonDoubleNode personNode2 = new PersonDoubleNode(2, "李一桐", "一桐");
        PersonDoubleNode personNode3 = new PersonDoubleNode(3, "袁冰妍", "冰淇淋");
        PersonDoubleNode personNode4 = new PersonDoubleNode(4, "林允儿", "允儿");

        //创建一个双向链表
        DoubleList doubleList = new DoubleList();

//        //添加节点
//        doubleList.add(personNode1);
//        doubleList.add(personNode2);
//        doubleList.add(personNode3);
//        doubleList.add(personNode4);

        //按顺序添加结点
        doubleList.addByOrder(personNode1);
        doubleList.addByOrder(personNode4);
        doubleList.addByOrder(personNode3);
        doubleList.addByOrder(personNode2);

        //遍历
        doubleList.list();


        //修改
        PersonDoubleNode newNode = new PersonDoubleNode(4,"赵丽颖","萤火虫");
        doubleList.update(newNode);

        System.out.println("修改后的链表: ");
        doubleList.list();

        //删除
        doubleList.delete(4);
        System.out.println("删除后的链表: ");
        doubleList.list();

    }

}

//创建一个双向链表的类
class DoubleList{

    //初始化一个头结点
    private PersonDoubleNode head = new PersonDoubleNode();

    //获取头节点
    public PersonDoubleNode getHead() {
        return head;
    }

    //添加结点
    public void add(PersonDoubleNode node){
        PersonDoubleNode temp = head;

        //遍历链表，找到最后一个节点
        while (true) {
            if (temp.next == null) {
                //此时说明已经到了最后
                break;
            }
            //如果没有找到，就将temp后移
            temp = temp.next;
        }
        temp.next = node;
        node.pre = temp;
    }

    //添加节点到链表的指定位置
    public void addByOrder(PersonDoubleNode node) {
        if(head.next == null){
            head.next = node;
            node.pre = head;
            return;
        }

        PersonDoubleNode temp = head;

        boolean flag = false;
        boolean flag1 = false;

        while (true) {
            if (temp.next == null) {
                flag1 = true;
                break;
            } else if (temp.next.getNo() > node.getNo()) {
                break;
            } else if (temp.next.getNo() == node.getNo()) {
                flag = true;  //说明编号存在
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            //说明编号存在，不能添加
            System.out.println("准备插入的编号" + node.getNo() + "已经存在，不能加入");
        }else if(flag1){
            add(node);
        }else{
            node.next = temp.next;
            node.pre = temp;
            temp.next.pre = node;
            temp.next = node;
        }
    }

    //修改结点信息,和单链表一样
    public void update(PersonDoubleNode node) {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空...");
            return;
        } else {
            //找到需要修改的节点
            PersonDoubleNode temp = head.next;
            boolean flag = false;

            while (true) {
                if (temp == null) {
                    //表示链表已经遍历结束
                    break;
                } else if (temp.getNo() == node.getNo()) {
                    flag = true;
                    break;
                }
                temp = temp.next;
            }
            //根据flag判断是否找到了要修改的节点
            if (flag) {
                temp.setName(node.getName());
                temp.setNickName(node.getNickName());
            } else {
                System.out.println("没有找到编号为" + node.getNo() + "的节点,无法修改...");
            }
        }
    }

    //删除结点(对于双向链表，我们可以直接找到要删除的这个结点，找到后，自我删除即可)
    public void delete(int no) {
        //判断链表是否为空
        if(head.next == null){
            System.out.println("当前链表为空，无法删除...");
            return;
        }

        PersonDoubleNode temp = head.next;
        boolean flag = false;

        while (true) {
            if (temp == null) {
                break;
            } else if (temp.getNo() == no) {
                //说明找到了待删除结点的前一个结点temp
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.pre.next = temp.next;
            //如果要删除的是最后一个结点，就不需要执行下面这句话，否则会出现空指针异常
            if(temp.next != null){
                temp.next.pre = temp.pre;
            }
        } else {
            System.out.println("要删除的" + no + "结点不存在,无法删除...");
        }
    }

    //遍历双向链表
    public void list() {
        //首先判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空...");
            return;
        } else {
            PersonDoubleNode temp = head.next;
            while (true) {
                //判断是否到了最后
                if (temp == null) {
                    break;
                }
                //输出节点信息
                System.out.println(temp);
                //将temp后移
                temp = temp.next;
            }
        }
    }

}

class PersonDoubleNode {
    private int no;
    private String name;
    private String nickName;
    public PersonDoubleNode next;  //指向下一个节点
    public PersonDoubleNode pre;   //指向前一个结点

    //构造器
    public PersonDoubleNode() {

    }

    public PersonDoubleNode(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "PersonDoubleNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

//方式二
public class DoubleList<E> extends AbstractList<E> {

    //测试
    public static void main(String[] args) {
        List<Integer> list = new DoubleList<>();
        list.add(11);
        list.add(22);
        list.add(33);
        list.add(44);
        list.add(0,55);
        list.add(2,66);
        list.add(list.size(),77);
        System.out.println(list);
        list.remove(0);
        list.remove(2);
        list.remove(list.size() - 1);
        System.out.println(list);
    }

    private Node<E> first;  

    private Node<E> last;   

    //定义静态内部类
    private static class Node<E>{

        E element;  //节点存放的值

        Node<E> next;  //存放下一个节点的地址

        Node<E> pre;  //存放上一个结点的地址

        public Node(Node<E> pre,E element,Node<E> next){
            this.element = element;
            this.next = next;
            this.pre = pre;
        }

        @Override
        public String toString() {
            StringBuilder s = new StringBuilder();
            if(pre != null){
                s.append(pre.element);
            }else{
                s.append("null");
            }
            s.append("->").append(element).append("->");
            if(next != null){
                s.append(next.element);
            }else{
                s.append("null");
            }
            return s.toString();
        }
    }

    public void clear() {
        size = 0;
        //让头指针指向null
        first = null;
        //让尾指针也指向null
        last = null;
    }

    //获取index位置对应的节点对象
    public Node<E> node(int index){
        rangeCheck(index);
        Node<E> node = null;
        if(index < (size >> 1)){
            node = first;
            for(int i = 0;i < index;i++){
                node = node.next;
            }
        }else{
            node = last;
            for(int i = size - 1;i > index;i--){
                node = node.pre;
            }
        }
        return node;
    }

    public void add(E data){
        add(size,data);
    }

    public void add(int index, E data) {
        rangeCheckForAdd(index);

        //往最后面添加元素
        if(index == size){
            Node<E> oldLast = last;
            last = new Node<E>(oldLast,data,null);
            //如果是添加链表的第一个元素
            if(oldLast == null){
                first = last;     //让first和last同时指向第一个元素
            }else{   //否则添加的不是第一个元素
                oldLast.next = last;
            }
        }else{  //其他位置添加元素
            //先获取index位置处的结点
            Node<E> node = node(index);
            //index的前一个结点
            Node<E> preNode = node.pre;
            //需要插入的结点
            Node<E> newNode = new Node(preNode,data,node);
            node.pre = newNode;
            if(preNode == null){  //表示index=0
                first = newNode;
            }else{
                preNode.next = newNode;
            }
        }
        size++;
    }

    public E remove(int index) {
        rangeCheck(index);

        //先获取当前节点
        Node<E> node = node(index);
        Node<E> preNode = node.pre;    //前一个结点
        Node<E> nextNode = node.next;  //后一个结点

        if(preNode == null){  //index==0
            first = nextNode;
        }else{
            preNode.next = nextNode;
        }

        if(nextNode == null){  //index==size-1
            last = preNode;
        }else{
            nextNode.pre = preNode;
        }

        size--;
        return node.element;
    }

    public E get(int index) {
        return node(index).element;
    }

    public E set(int index, E data) {
        Node<E> node = node(index);
        E res = node.element;
        node.element = data;
        return res;
    }

    public int indexOf(E data) {
        Node<E> node = first;
        for(int i = 0;i < size;i++){
            if(data.equals(node.element)){
                return i;
            }
            node = node.next;
        }
        return ELEMENT_NOT_FOUND;
    }

    @Override
    public String toString() {
        StringBuilder s = new StringBuilder();
        Node<E> node = first;
        s.append("[");
        for(int i = 0;i < size;i++){
            if(i != 0){
                s.append(", ");
            }
            s.append(node);
            node = node.next;
        }
        s.append("]");
        return s.toString();
    }

}

2.4 单向循环链表

//方式一: 实现约瑟夫环问题
public class Josepfu {

    public static void main(String[] args) {

        //创建环形链表
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();

        circleSingleLinkedList.add(10);
        circleSingleLinkedList.show();

        circleSingleLinkedList.countNode(4,2,5);
    }

}

//定义环形的单向链表
class CircleSingleLinkedList {
    //先创建一个first结点
    private Node first = null;

    //添加结点
    //data:表示传入的节点总个数
    public void add(int data) {
        if (data < 1) {
            System.out.println("data的值不正确...");
            return;
        } else {
            //定义一个辅助指针，帮助我们构建环形链表
            Node temp = null;

            //使用for循环创建环形链表
            for (int i = 1; i <= data; i++) {
                Node node = new Node(i);

                //如果是第一个结点，则自身需要形成环形
                if (i == 1) {
                    first = node;
                    first.setNext(first);
                    temp = first;  //让temp指向first,代替first往后遍历，因为first是不能移动的
                } else {
                    temp.setNext(node);
                    node.setNext(first);
                    temp = node;
                }

            }
        }
    }

    //遍历
    public void show() {
        //判断链表是否为空
        if (first == null) {
            System.out.println("当前链表没有任何结点...");
            return;
        }

        Node temp = first;

        while (true) {
            System.out.println("当前结点的编号为: " + temp.getNo());
            if (temp.getNext() == first) {
                //说明已经遍历完毕
                break;
            }
            temp = temp.getNext();  //让temp后移
        }
    }


    /*
        根据用户的输入，生成一个结点出圈的顺序
            n = 5--->即总结点个数为5
            k = 1--->即从第一个人开始报数
            m = 2--->表示数两下
            1.需要创建一个辅助指针helper，事先应该指向环形链表的最后一个结点
            2.当报数之前,先让first和helper移动k-1次到指定位置,再让first和helper指针同时移动m - 1次
            3.这时就可以将first指向的结点出圈
                first = first.next
                helper.next = first
            4.原来first指向的结点此时就没有任何引用指向它，就会被回收，即可以出圈了

            startNo:表示从第几个结点开始数数
            countNum:表示数几下
            nums:表示最开始有多少个结点
     */
    public void countNode(int startNo, int countNum, int nums) {
        //先对数据进行校验
        if (first == null || startNo < 1 || startNo > nums) {
            System.out.println("你的输入有误,请重新输入...");
            return;
        }

        //创建辅助指针
        Node helper = first;

        while (true) {
            if (helper.getNext() == first) {
                //说明此时helper已经指向了最后一个结点
                break;
            }
            helper = helper.getNext();  //否则helper后移
        }

        for (int i = 0; i < startNo - 1; i++) {
            first = first.getNext();
            helper = helper.getNext();
        }

        while (true) {
            if(first == helper){
                //说明此时圈中只有一结点
                break;
            }

            //否则同时让first和helper同时移动countNum - 1次
            for (int i = 0; i < countNum - 1; i++) {
                first = first.getNext();
                helper = helper.getNext();
            }

            //这时first指向的结点就是要出圈的结点
            System.out.println("结点" + first.getNo() + "出圈");

            //出圈
            first = first.getNext();
            helper.setNext(first);
        }

        System.out.println("最后留在圈中的结点是: " + first.getNo());
    }

}

//定义一个结点类
class Node {
    private int no;
    private Node next;  //指向下一个结点

    public Node(int no) {
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}

//方式二
public class SingleCircleLinkedList<E> extends AbstractList<E> {

    //测试
    public static void main(String[] args) {
        List<Integer> list = new SingleCircleLinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(0,5);
        list.add(list.size(),6);
        list.remove(0);
        System.out.println(list);
    }

    private Node<E> first;

    private static class Node<E>{

        E element;

        Node<E> next;

        public Node(E element,Node<E> next){
            this.element = element;
            this.next = next;
        }

        @Override
        public String toString() {
            StringBuilder s = new StringBuilder();
            s.append(element).append("->").append(next.element);
            return s.toString();
        }
    }

    public void clear() {
        size = 0;
        first = null;
    }

    //获取index位置对应的节点对象
    public Node<E> node(int index){
        rangeCheck(index);
        //让first移动到index位置对应的节点
        Node<E> node = first;
        for(int i = 0;i < index;i++){
            node = node.next;
        }
        return node;
    }

    public void add(E data){
        add(size,data);
    }

    public void add(int index, E data) {
        rangeCheckForAdd(index);
        if(index == 0){
            Node<E> newFirst = new Node<>(data, first);

            //拿到最后一个结点
            Node<E> lastNode = (size == 0) ? newFirst : node(size - 1);
            //让最后一个结点指向头结点
            lastNode.next = newFirst;

            最后first始终指向第一个节点
            first = newFirst;
        }else{
            //先获取index-1位置处的节点
            Node<E> preNode = node(index - 1);
            Node<E> newNode = new Node<>(data, preNode.next);
            preNode.next = newNode;
        }
        size++;
    }

    public E remove(int index) {
        rangeCheck(index);
        //先保存idnex位置处的节点
        Node<E> resNode = first;
        if(index == 0){
            if(size == 1){  //如果只有一个结点
                first = null;
            }else{
                //先拿到最后一个结点
                Node<E> lastNode = node(size - 1);
                first = first.next;
                lastNode.next = first;
            }
        }else{
            Node<E> preNode = node(index - 1);
            resNode = preNode.next;
            if(index == size){
                preNode.next = null;
            }else{
                preNode.next = resNode.next;
            }
        }
        size--;
        return resNode.element;
    }

    public E get(int index) {
        return node(index).element;
    }

    public E set(int index, E data) {
        Node<E> node = node(index);
        E res = node.element;
        node.element = data;
        return res;
    }

    public int indexOf(E data) {
        Node<E> node = first;
        for(int i = 0;i < size;i++){
            if(data.equals(node.element)){
                return i;
            }
            node = node.next;
        }
        return ELEMENT_NOT_FOUND;
    }

    @Override
    public String toString() {
        StringBuilder s = new StringBuilder();
        Node<E> node = first;
        s.append("[");
        for(int i = 0;i < size;i++){
            if(i != 0){
                s.append(", ");
            }
            s.append(node);
            node = node.next;
        }
        s.append("]");
        return s.toString();
    }
}

2.5 双向循环链表

public class DoubleCircleList<E> extends AbstractList<E> {

    //测试
    public static void main(String[] args) {
        List<Integer> list = new DoubleCircleList<>();
        list.add(11);
        list.add(22);
        list.add(33);
        list.add(44);
        list.add(0,55);
        list.add(2,66);
        list.add(list.size(),77);
        System.out.println(list);
        list.remove(0);
        list.remove(2);
        list.remove(list.size() - 1);
        System.out.println(list);
    }

    private Node<E> first;   

    private Node<E> last;   

    //定义静态内部类
    private static class Node<E>{

        E element;  //节点存放的值

        Node<E> next;  //存放下一个节点的地址

        Node<E> pre;  //存放上一个结点的地址

        public Node(Node<E> pre,E element,Node<E> next){
            this.element = element;
            this.next = next;
            this.pre = pre;
        }

        @Override
        public String toString() {
            StringBuilder s = new StringBuilder();
            if(pre != null){
                s.append(pre.element);
            }else{
                s.append("null");
            }
            s.append("->").append(element).append("->");
            if(next != null){
                s.append(next.element);
            }else{
                s.append("null");
            }
            return s.toString();
        }
    }

    public void clear() {
        size = 0;
        //让头指针指向null
        first = null;
        //让尾指针也指向null
        last = null;
    }

    //获取index位置对应的节点对象
    public Node<E> node(int index){
        rangeCheck(index);
        Node<E> node = null;
        if(index < (size >> 1)){
            node = first;
            for(int i = 0;i < index;i++){
                node = node.next;
            }
        }else{
            node = last;
            for(int i = size - 1;i > index;i--){
                node = node.pre;
            }
        }
        return node;
    }

    public void add(E data){
        add(size,data);
    }

    public void add(int index, E data) {
        rangeCheckForAdd(index);

        //往最后面添加元素
        if(index == size){
            Node<E> oldLast = last;
            last = new Node<E>(oldLast,data,first);  //最后一个元素指向第一个元素
            //如果是添加链表的第一个元素
            if(oldLast == null){
                first = last;     //让first和last同时指向第一个元素
                first.next = first;
                first.pre = first;
            }else{   //否则添加的不是第一个元素
                oldLast.next = last;
                first.pre = last;
            }
        }else{  //其他位置添加元素
            //先获取index位置处的结点
            Node<E> node = node(index);
            //index的前一个结点
            Node<E> preNode = node.pre;
            //需要插入的结点
            Node<E> newNode = new Node(preNode,data,node);
            node.pre = newNode;
            preNode.next = newNode;
            if(node == first){  //表示index=0
                first = newNode;
            }
        }
        size++;
    }

    public E remove(int index) {
        rangeCheck(index);

        Node<E> node = first;  //用来保存最后的结果
        //如果只有一个结点
        if(size == 1){
            first = null;
            last = null;
        }else{
            //先获取当前节点
            node = node(index);
            Node<E> preNode = node.pre;    //前一个结点
            Node<E> nextNode = node.next;  //后一个结点
            preNode.next = nextNode;
            nextNode.pre = preNode;

            if(node == first){  //index==0
                first = nextNode;
            }

            if(node == last){  //index==size-1
                last = preNode;
            }
        }

        size--;
        return node.element;
    }

    public E get(int index) {
        return node(index).element;
    }

    public E set(int index, E data) {
        Node<E> node = node(index);
        E res = node.element;
        node.element = data;
        return res;
    }

    public int indexOf(E data) {
        Node<E> node = first;
        for(int i = 0;i < size;i++){
            if(data.equals(node.element)){
                return i;
            }
            node = node.next;
        }
        return ELEMENT_NOT_FOUND;
    }

    @Override
    public String toString() {
        StringBuilder s = new StringBuilder();
        Node<E> node = first;
        s.append("[");
        for(int i = 0;i < size;i++){
            if(i != 0){
                s.append(", ");
            }
            s.append(node);
            node = node.next;
        }
        s.append("]");
        return s.toString();
    }

}

3. 栈