轻松的小希

线性结构：链表

第一章单向链表介绍
第二章单向链表实现
- 2.01、定义链表的结点类
- 2.02、定义链表的属性值
- 2.03、初始化各个属性值
- 2.04、获取链表当前大小
- 2.05、判断链表是否为空
- 2.06、检查下标是否合法
- 2.07、连接链表两个结点
- 2.08、释放链表指定结点
- 2.09、返回链表最后结点
- 2.10、返回链表首个结点
- 2.11、获取指定位置结点
- 2.12、获取位置之前结点
- 2.13、链表尾后添加数据
- 2.14、链表头后添加数据
- 2.15、指定位置添加数据
- 2.16、删除指定位置结点
- 2.17、删除链表首个结点
- 2.18、删除链表最后结点
- 2.19、输出链表所有结点
- 2.20、反转链表所有结点
- 2.21、清空链表所有结点
- 2.22、顺序查找数据首次出现位置
- 2.23、逆序查找数据首次出现位置
第三章双向链表介绍
第四章双向链表实现
- 4.01、且看代码如此多娇
- 4.02、获取位置之前结点
- 4.03、删除链表最后结点
- 4.04、逆序查找数据首次出现位置
第五章单向循环链表介绍
第六章单向循环链表实现
- 6.01、定义链表的结点类
- 6.02、定义链表的属性值
- 6.03、初始化各个属性值
- 6.04、获取链表当前大小
- 6.05、判断链表是否为空
- 6.06、检查下标是否合法
- 6.07、连接链表两个结点
- 6.08、释放链表指定结点
- 6.09、返回链表最后结点
- 6.10、返回链表首个结点
- 6.11、获取指定位置结点
- 6.12、获取位置之前结点
- 6.13、链表尾后添加数据
- 6.14、链表头后添加数据
- 6.15、指定位置添加数据
- 6.16、删除指定位置结点
- 6.17、删除链表首个结点
- 6.18、删除链表最后结点
- 6.19、输出链表所有结点
- 6.20、反转链表所有结点
- 6.21、清空链表所有结点
- 6.22、顺序查找数据首次出现位置
- 6.23、逆序查找数据首次出现位置
第七章双向循环链表介绍
第八章双向循环链表实现
- 8.01、再看代码如此多娇
- 8.02、获取位置之前结点
- 8.03、删除链表最后结点
- 8.04、逆序查找数据首次出现位置

项目地址：https://gitee.com/caochenlei/data-structures

第一章单向链表介绍

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针连接次序实现的。链表由一系列结点组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

单向链表（单链表）是链表的一种，其特点是链表的连接方向是单向的，对链表的访问要从头部开始顺序读取，head指针指向第一个结点又称为头结点，而终止于最后一个指向null的结点。链表的头结点的数据域不存储数据，而头结点的指针域指向第一个真正存储数据的结点。这里为了方便操作，我又增加了一个last结点，这个结点就是为了指向最后一个结点，节约操作时间，提升查询性能。

第二章单向链表实现

2.01、定义链表的结点类

/**
 * 单向链表实现代码
 */
public class SinglyLinkedList<E> {
    //定义结点类
    public class Node {
        E data;     //代表结点数据
        Node next;  //指向下个结点

        public Node(E data) {
            this.data = data;
        }

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

    //下节内容写这...
}

2.02、定义链表的属性值

/**
 * 单向链表实现代码
 */
public class SinglyLinkedList<E> {
    //省略以上代码...

    private Node head;  //代表链表头部
    private Node last;  //代表链表尾部
    private int size;   //代表链表长度

    //下节内容写这...
}

2.03、初始化各个属性值

/**
 * 单向链表实现代码
 */
public class SinglyLinkedList<E> {
    //省略以上代码...

    public SinglyLinkedList() {
        //头结点用于其他结点的连接，头结点的下标我们定义为-1
        this.head = new Node(null);
        //尾结点初始默认指向头结点，这样我们在添加的时候方便
        this.last = head;
        this.size = 0;
    }

    //下节内容写这...
}

2.04、获取链表当前大小

//获取链表当前大小
public int size() {
    return size;
}

2.05、判断链表是否为空

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

2.06、检查下标是否合法

//检查下标是否合法
public void checkIndex(int index) {
    if (index < 0 || (size - 1) < index) {
        throw new IndexOutOfBoundsException("链表下标越界异常，请检查链表的下标！");
    }
}

2.07、连接链表两个结点

//连接链表两个结点
public void connectNode(Node prevNode, Node nextNode) {
    if (prevNode != null) {
        prevNode.next = nextNode;
    }
}

2.08、释放链表指定结点

//释放链表指定结点
public void releaseNode(Node node) {
    if (node != null) {
        node.data = null;
        node.next = null;
    }
}

2.09、返回链表最后结点

//返回链表最后结点
public Node getLast() {
    //判断链表是否为空
    if (isEmpty()) {
        return null;
    }
    //返回链表最后结点
    return last;
}

2.10、返回链表首个结点

//返回链表首个结点
public Node getFirst() {
    //判断链表是否为空
    if (isEmpty()) {
        return null;
    }
    //返回链表首个结点
    return head.next;
}

2.11、获取指定位置结点

//获取指定位置结点
public Node getIndex(int index) {
    //检查下标是否合法
    checkIndex(index);
    //获取指定位置结点
    Node curNode = head;
    for (int i = 0; i < (index + 1); i++) {
        curNode = curNode.next;
    }
    //返回指定位置结点
    return curNode;
}

2.12、获取位置之前结点

//获取位置之前结点
private Node getIndexPre(int index) {
    //检查下标是否合法
    checkIndex(index);
    //获取位置之前结点
    Node preNode = head;
    for (int i = 0; i < index; i++) {
        preNode = preNode.next;
    }
    //返回位置之前结点
    return preNode;
}

2.13、链表尾后添加数据

默认为空的时候，头指针head和尾指针last均指向头结点。

添加数据的时候，我们直接向last指向结点后追加结点即可。

方法实现：

//链表尾后添加数据（需要考虑last指向问题）
public void addLast(E e) {
    //获取旧的尾结点
    Node oldLast = last;
    //创建新的尾结点
    Node newLast = new Node(e);
    //旧新两结点连接
    connectNode(oldLast, newLast);
    //修改last指向
    last = newLast;
    //使链表长度加一
    size++;
}

方法测试：

public class SinglyLinkedListTest {
    public static void main(String[] args) {
        SinglyLinkedList<String> linkedList = new SinglyLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.getIndex(i));
        }
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：3
链表是否为空：false
==========打印链表所有结点：
Node{data=张三}
Node{data=李四}
Node{data=王五}
==========打印链表首尾结点：
链表的头结点：Node{data=张三}
链表的尾结点：Node{data=王五}

2.14、链表头后添加数据

方法实现：

//链表头后添加数据（不用考虑last指向问题）
public void addFirst(E e) {
    //判断链表是否为空
    if (isEmpty()) {
        addLast(e);
    } else {
        //获取首个结点
        Node firNode = head.next;
        //创建新的结点
        Node newNode = new Node(e);
        //三个结点连接
        connectNode(head, newNode);
        connectNode(newNode, firNode);
        //链表长度加一
        size++;
    }
}

方法测试：

public class SinglyLinkedListTest {
    public static void main(String[] args) {
        SinglyLinkedList<String> linkedList = new SinglyLinkedList<>();

        linkedList.addFirst("张三");
        linkedList.addFirst("李四");
        linkedList.addFirst("王五");

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.getIndex(i));
        }
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：3
链表是否为空：false
==========打印链表所有结点：
Node{data=王五}
Node{data=李四}
Node{data=张三}
==========打印链表首尾结点：
链表的头结点：Node{data=王五}
链表的尾结点：Node{data=张三}

2.15、指定位置添加数据

方法实现：

//指定位置添加数据（不用考虑last指向问题）
public void addIndex(int index, E e) {
    //获取位置之前结点
    Node preNode = getIndexPre(index);
    //获取指定位置结点
    Node curNode = preNode.next;
    //创建一个新的结点
    Node newNode = new Node(e);
    //开始三个结点连接
    connectNode(preNode, newNode);
    connectNode(newNode, curNode);
    //当前链表长度加一
    size++;
}

方法测试：

public class SinglyLinkedListTest {
    public static void main(String[] args) {
        SinglyLinkedList<String> linkedList = new SinglyLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        linkedList.addIndex(0, "张三长辈");
        linkedList.addIndex(linkedList.size() - 1, "王五长辈");

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.getIndex(i));
        }
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：5
链表是否为空：false
==========打印链表所有结点：
Node{data=张三长辈}
Node{data=张三}
Node{data=李四}
Node{data=王五长辈}
Node{data=王五}
==========打印链表首尾结点：
链表的头结点：Node{data=张三长辈}
链表的尾结点：Node{data=王五}

2.16、删除指定位置结点

方法实现：

//删除指定位置结点（需要考虑last指向问题）
public void removeIndex(int index) {
    //获取位置之前结点
    Node preNode = getIndexPre(index);
    //获取指定位置结点
    Node curNode = preNode.next;
    //获取位置之后结点
    Node nexNode = curNode.next;
    //修改last的指向
    if (curNode == last) {
        last = preNode;
    }
    //删除指定位置结点
    connectNode(preNode, nexNode);
    //释放链表指定结点
    releaseNode(curNode);
    //当前链表长度减一
    size--;
}

方法测试：

public class SinglyLinkedListTest {
    public static void main(String[] args) {
        SinglyLinkedList<String> linkedList = new SinglyLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        linkedList.removeIndex(0);
        linkedList.removeIndex(linkedList.size() - 1);

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.getIndex(i));
        }
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：1
链表是否为空：false
==========打印链表所有结点：
Node{data=李四}
==========打印链表首尾结点：
链表的头结点：Node{data=李四}
链表的尾结点：Node{data=李四}

2.17、删除链表首个结点

方法实现：

//删除链表首个结点（不用考虑last指向问题）
public void removeFirst() {
    //判断链表是否为空
    if (isEmpty()) {
        return;
    }
    //删除链表首个结点
    removeIndex(0);
}

方法测试：

public class SinglyLinkedListTest {
    public static void main(String[] args) {
        SinglyLinkedList<String> linkedList = new SinglyLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        linkedList.removeFirst();

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.getIndex(i));
        }
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：2
链表是否为空：false
==========打印链表所有结点：
Node{data=李四}
Node{data=王五}
==========打印链表首尾结点：
链表的头结点：Node{data=李四}
链表的尾结点：Node{data=王五}

2.18、删除链表最后结点

方法实现：

//删除链表最后结点（不用考虑last指向问题）
public void removeLast() {
    //判断链表是否为空
    if (isEmpty()) {
        return;
    }
    //删除链表最后结点
    removeIndex(size - 1);
}

方法测试：

public class SinglyLinkedListTest {
    public static void main(String[] args) {
        SinglyLinkedList<String> linkedList = new SinglyLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        linkedList.removeLast();

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.getIndex(i));
        }
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：2
链表是否为空：false
==========打印链表所有结点：
Node{data=张三}
Node{data=李四}
==========打印链表首尾结点：
链表的头结点：Node{data=张三}
链表的尾结点：Node{data=李四}

2.19、输出链表所有结点

方法实现：

//输出链表所有结点（不用考虑last指向问题）
public void show() {
    //判断链表是否为空
    if (isEmpty()) {
        return;
    }
    //遍历链表所有结点（除头结点）
    Node curNode = head.next;
    while (curNode != null) {
        System.out.println(curNode);
        curNode = curNode.next;
    }
}

方法测试：

public class SinglyLinkedListTest {
    public static void main(String[] args) {
        SinglyLinkedList<String> linkedList = new SinglyLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        linkedList.show();
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：3
链表是否为空：false
==========打印链表所有结点：
Node{data=张三}
Node{data=李四}
Node{data=王五}
==========打印链表首尾结点：
链表的头结点：Node{data=张三}
链表的尾结点：Node{data=王五}

2.20、反转链表所有结点

方法实现：

//反转链表所有结点（需要考虑last指向问题）
public void reverse() {
    //判断链表是否为空
    if (isEmpty()) {
        return;
    }
    //创建一个新头结点
    Node newHead = new Node(null);
    //获取链表的首结点
    Node oldFirst = head.next;
    //遍历链表所有结点（除头结点）
    Node newFirst;
    Node tmpNode;
    Node curNode = oldFirst;
    while (curNode != null) {
        //缓存当前结点下个结点
        tmpNode = curNode.next;
        //获取链表新头首个结点
        newFirst = newHead.next;
        //开始三个结点进行关联
        connectNode(newHead, curNode);
        connectNode(curNode, newFirst);
        //让当前的结点往后移动
        curNode = tmpNode;
    }
    //老头换新头首结点
    head.next = newHead.next;
    //修改last的指向
    last = oldFirst;
    //释放临时新头结点
    releaseNode(newHead);
}

方法测试：

public class SinglyLinkedListTest {
    public static void main(String[] args) {
        SinglyLinkedList<String> linkedList = new SinglyLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        linkedList.reverse();

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        linkedList.show();
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：3
链表是否为空：false
==========打印链表所有结点：
Node{data=王五}
Node{data=李四}
Node{data=张三}
==========打印链表首尾结点：
链表的头结点：Node{data=王五}
链表的尾结点：Node{data=张三}

2.21、清空链表所有结点

方法实现：

//清空链表所有结点（需要考虑last指向问题）
public void clear() {
    //判断链表是否为空
    if (isEmpty()) {
        return;
    }
    //遍历链表所有结点（含头结点）
    Node tmpNode;
    Node curNode = head;
    while (curNode != null) {
        //缓存下个结点
        tmpNode = curNode.next;
        //释放当前结点
        releaseNode(curNode);
        //移动下个结点
        curNode = tmpNode;
    }
    //重置链表基本信息
    head = null;
    last = null;
    size = 0;
}

方法测试：

public class SinglyLinkedListTest {
    public static void main(String[] args) {
        SinglyLinkedList<String> linkedList = new SinglyLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        linkedList.clear();

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        linkedList.show();
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：0
链表是否为空：true
==========打印链表所有结点：
==========打印链表首尾结点：
链表的头结点：null
链表的尾结点：null

2.22、顺序查找数据首次出现位置

方法实现：

//顺序查找数据首次出现位置
public int indexOf(E e) {
    //判断链表是否为空
    if (isEmpty()) {
        return -1;
    }
    //判断对象是否为空
    if (e == null) {
        return -1;
    }
    //获取指定位置结点
    Node curNode = head;
    for (int i = -1; i < size; i++) {
        if (e.equals(curNode.data)) {
            return i;
        }
        curNode = curNode.next;
    }
    //没有找到返回负一
    return -1;
}

方法测试：

public class SinglyLinkedListTest {
    public static void main(String[] args) {
        SinglyLinkedList<String> linkedList = new SinglyLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        System.out.println(linkedList.indexOf("张三"));
        System.out.println(linkedList.indexOf("李四"));
        System.out.println(linkedList.indexOf("王五"));

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        linkedList.show();
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

0
1
2
==========打印链表基本信息：
链表结点个数：3
链表是否为空：false
==========打印链表所有结点：
Node{data=张三}
Node{data=李四}
Node{data=王五}
==========打印链表首尾结点：
链表的头结点：Node{data=张三}
链表的尾结点：Node{data=王五}

2.23、逆序查找数据首次出现位置

方法实现：

//逆序查找数据首次出现位置
public int lastIndexOf(E e) {
    //判断链表是否为空
    if (isEmpty()) {
        return -1;
    }
    //判断对象是否为空
    if (e == null) {
        return -1;
    }
    //反转当前链表结点
    reverse();
    //获取指定位置结点
    int index = indexOf(e);
    //反转当前链表结点
    reverse();
    //返回数据指定位置
    return index;
}

方法测试：

public class SinglyLinkedListTest {
    public static void main(String[] args) {
        SinglyLinkedList<String> linkedList = new SinglyLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        System.out.println(linkedList.lastIndexOf("张三"));
        System.out.println(linkedList.lastIndexOf("李四"));
        System.out.println(linkedList.lastIndexOf("王五"));

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        linkedList.show();
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

2
1
0
==========打印链表基本信息：
链表结点个数：3
链表是否为空：false
==========打印链表所有结点：
Node{data=张三}
Node{data=李四}
Node{data=王五}
==========打印链表首尾结点：
链表的头结点：Node{data=张三}
链表的尾结点：Node{data=王五}

第三章双向链表介绍

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一个真正存储数据结点。

第四章双向链表实现

4.01、且看代码如此多娇

我们已经学过了单向链表的设计和实现了，双向链表只需要在单向链表的基础上添加三行代码就能实现，你看神奇不神奇。

我们需要直接拷贝SinglyLinkedList为DoublyLinkedList，然后拷贝SinglyLinkedListTest为DoublyLinkedListTest，并修改相对应的构造方法名称。

第一处：修改节点类，添加prev指针域。

//定义结点类
public class Node {
    Node prev;  //指向上个结点 +
    E data;     //代表结点数据
    Node next;  //指向下个结点

    public Node(E data) {
        this.data = data;
    }

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

第二处：修改连接处，添加指向上个结点。

//连接链表两个结点
public void connectNode(Node prevNode, Node nextNode) {
    if (prevNode != null) {
        prevNode.next = nextNode;
    }
    if (nextNode != null) {         // +
        nextNode.prev = prevNode;   // +
    }                               // +
}

第三处：修改释放处，添加释放prev指针域。

//释放链表指定结点
public void releaseNode(Node node) {
    if (node != null) {
        node.prev = null;   // +
        node.data = null;
        node.next = null;
    }
}

到此，双向链表的设计和实现就学完了，但是既然存在双向链表，那么肯定还有一些方法可以简化，接下来，我们需要对一些特殊的方法进行优化。

4.02、获取位置之前结点

//获取位置之前结点
private Node getIndexPre(int index) {
    return getIndex(index).prev;
}

4.03、删除链表最后结点

//删除链表最后结点（需要考虑last指向问题）
public void removeLast() {
    //判断链表是否为空
    if (isEmpty()) {
        return;
    }
    //获取链表最后节点
    Node lastNode = last;
    //删除链表最后结点
    Node prevNode = lastNode.prev;
    prevNode.next = null;
    //释放最后节点指向
    releaseNode(lastNode);
    //修改last的指向
    last = prevNode;
    //让链表的长度减一
    size--;
}

4.04、逆序查找数据首次出现位置

//逆序查找数据首次出现位置
public int lastIndexOf(E e) {
    //判断链表是否为空
    if (isEmpty()) {
        return -1;
    }
    //判断对象是否为空
    if (e == null) {
        return -1;
    }
    //获取指定位置结点
    Node curNode = last;
    for (int i = 0; curNode != null; i++) {
        if (e.equals(curNode.data)) {
            return i;
        }
        curNode = curNode.prev;
    }
    //没有找到返回负一
    return -1;
}

第五章单向循环链表介绍

单向循环链表是另一种形式的链式存储结构，它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。

第六章单向循环链表实现

6.01、定义链表的结点类

/**
 * 单向循环链表实现代码
 */
public class SinglyCircularLinkedList<E> {
    //定义结点类
    public class Node {
        E data;     //代表结点数据
        Node next;  //指向下个结点

        public Node(E data) {
            this.data = data;
        }

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

    //下节内容写这...
}

6.02、定义链表的属性值

/**
 * 单向循环链表实现代码
 */
public class SinglyCircularLinkedList<E> {
    //省略以上代码...
    
    private Node head;  //代表链表头部
    private Node last;  //代表链表尾部
    private int size;   //代表链表长度    

    //下节内容写这...
}

6.03、初始化各个属性值

/**
 * 单向链表实现代码
 */
public class SinglyLinkedList<E> {
    //省略以上代码...

    public SinglyCircularLinkedList() {
        //头结点应该指向第一个结点，现在没有，所以为null
        this.head = null;
        //尾结点应该指向最后的结点，现在没有，所以为null
        this.last = null;
        this.size = 0;
    }

    //下节内容写这...
}

6.04、获取链表当前大小

//获取链表当前大小
public int size() {
    return size;
}

6.05、判断链表是否为空

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

6.06、检查下标是否合法

//检查下标是否合法
public void checkIndex(int index) {
    if (index < 0 || (size - 1) < index) {
        throw new IndexOutOfBoundsException("链表下标越界异常，请检查链表的下标！");
    }
}

6.07、连接链表两个结点

//连接链表两个结点
public void connectNode(Node prevNode, Node nextNode) {
    if (prevNode != null) {
        prevNode.next = nextNode;
    }
}

6.08、释放链表指定结点

//释放链表指定结点
public void releaseNode(Node node) {
    if (node != null) {
        node.data = null;
        node.next = null;
    }
}

6.09、返回链表最后结点

//返回链表最后结点
public Node getLast() {
    //判断链表是否为空
    if (isEmpty()) {
        return null;
    }
    //返回链表最后结点
    return last;
}

6.10、返回链表首个结点

//返回链表首个结点
public Node getFirst() {
    //判断链表是否为空
    if (isEmpty()) {
        return null;
    }
    //返回链表首个结点
    return head;
}

6.11、获取指定位置结点

//获取指定位置结点
public Node getIndex(int index) {
    //检查下标是否合法
    checkIndex(index);
    //获取指定位置结点
    Node curNode = head;
    for (int i = 0; i < index; i++) {
        curNode = curNode.next;
    }
    //返回指定位置结点
    return curNode;
}

6.12、获取位置之前结点

//获取位置之前结点
private Node getIndexPre(int index) {
    //检查下标是否合法
    checkIndex(index);
    //获取首结点前结点
    if (index == 0) {
        return last;
    }
    //获取位置之前结点
    Node preNode = head;
    for (int i = 0; i < (index - 1); i++) {
        preNode = preNode.next;
    }
    //返回位置之前结点
    return preNode;
}

6.13、链表尾后添加数据

默认为空的时候，头指针head和尾指针last均指向null。

若是为空的时候，添加完数据应该自己指向自己，自我成环。

非空添加数据，我们直接向last指向结点后追加结点即可。

方法实现：

//链表尾后添加数据
public void addLast(E e) {
    //判断链表是否为空
    if (isEmpty()) {
        //创建新的结点
        Node newNode = new Node(e);
        //修改头尾指向
        head = newNode;
        last = newNode;
        //自己连接自己
        connectNode(newNode, newNode);
    } else {
        //获取last结点
        Node oldLast = last;
        //创建新的结点
        Node newLast = new Node(e);
        //修改last指向
        last = newLast;
        //头尾连接成环
        connectNode(oldLast, newLast);
        connectNode(newLast, head);
    }
    //链表链表长度加一
    size++;
}

方法测试：

public class SinglyCircularLinkedListTest {
    public static void main(String[] args) {
        SinglyCircularLinkedList<String> linkedList = new SinglyCircularLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.getIndex(i));
        }
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：3
链表是否为空：false
==========打印链表所有结点：
Node{data=张三}
Node{data=李四}
Node{data=王五}
==========打印链表首尾结点：
链表的头结点：Node{data=张三}
链表的尾结点：Node{data=王五}

6.14、链表头后添加数据

方法实现：

//链表头后添加数据
public void addFirst(E e) {
    //判断链表是否为空
    if (isEmpty()) {
        addLast(e);
        return;
    } else {
        //获取head结点
        Node oldHead = head;
        //创建新的结点
        Node newHead = new Node(e);
        //修改head指向
        head = newHead;
        //头尾连接成环
        connectNode(last, newHead);
        connectNode(newHead, oldHead);
    }
    //链表链表长度加一
    size++;
}

方法测试：

public class SinglyCircularLinkedListTest {
    public static void main(String[] args) {
        SinglyCircularLinkedList<String> linkedList = new SinglyCircularLinkedList<>();

        linkedList.addFirst("张三");
        linkedList.addFirst("李四");
        linkedList.addFirst("王五");

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.getIndex(i));
        }
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：3
链表是否为空：false
==========打印链表所有结点：
Node{data=王五}
Node{data=李四}
Node{data=张三}
==========打印链表首尾结点：
链表的头结点：Node{data=王五}
链表的尾结点：Node{data=张三}

6.15、指定位置添加数据

方法实现：

//指定位置添加数据
public void addIndex(int index, E e) {
    //获取位置之前结点
    Node preNode = getIndexPre(index);
    //获取指定位置结点
    Node curNode = preNode.next;
    //创建一个新的结点
    Node newNode = new Node(e);
    //开始三个结点连接
    connectNode(preNode, newNode);
    connectNode(newNode, curNode);
    //修改head的指向
    if (curNode == head) {
        head = newNode;
    }
    //当前链表长度加一
    size++;
}

方法测试：

public class SinglyCircularLinkedListTest {
    public static void main(String[] args) {
        SinglyCircularLinkedList<String> linkedList = new SinglyCircularLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        linkedList.addIndex(0, "张三长辈");
        linkedList.addIndex(linkedList.size() - 1, "王五长辈");

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.getIndex(i));
        }
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：5
链表是否为空：false
==========打印链表所有结点：
Node{data=张三长辈}
Node{data=张三}
Node{data=李四}
Node{data=王五长辈}
Node{data=王五}
==========打印链表首尾结点：
链表的头结点：Node{data=张三长辈}
链表的尾结点：Node{data=王五}

6.16、删除指定位置结点

方法实现：

//删除指定位置结点
public void removeIndex(int index) {
    //获取位置之前结点
    Node preNode = getIndexPre(index);
    //获取指定位置结点
    Node curNode = preNode.next;
    //获取位置之后结点
    Node nexNode = curNode.next;
    //如果只有一个结点
    if (size == 1) {
        //修改head的指向
        head = null;
        //修改last的指向
        last = null;
        //释放链表指定结点
        releaseNode(preNode);
        releaseNode(curNode);
        releaseNode(nexNode);
        //当前链表长度减一
        size--;
    } else {
        //修改head的指向
        if (curNode == head) {
            head = nexNode;
        }
        //修改last的指向
        if (curNode == last) {
            last = preNode;
        }
        //删除指定位置结点
        connectNode(preNode, nexNode);
        //释放链表指定结点
        releaseNode(curNode);
        //当前链表长度减一
        size--;
    }
}

方法测试：

public class SinglyCircularLinkedListTest {
    public static void main(String[] args) {
        SinglyCircularLinkedList<String> linkedList = new SinglyCircularLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        linkedList.removeIndex(0);
        linkedList.removeIndex(linkedList.size() - 1);

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.getIndex(i));
        }
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：1
链表是否为空：false
==========打印链表所有结点：
Node{data=李四}
==========打印链表首尾结点：
链表的头结点：Node{data=李四}
链表的尾结点：Node{data=李四}

6.17、删除链表首个结点

方法实现：

//删除链表首个结点
public void removeFirst() {
    //判断链表是否为空
    if (isEmpty()) {
        return;
    }
    //删除链表首个结点
    removeIndex(0);
}

方法测试：

public class SinglyCircularLinkedListTest {
    public static void main(String[] args) {
        SinglyCircularLinkedList<String> linkedList = new SinglyCircularLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        linkedList.removeFirst();

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.getIndex(i));
        }
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：2
链表是否为空：false
==========打印链表所有结点：
Node{data=李四}
Node{data=王五}
==========打印链表首尾结点：
链表的头结点：Node{data=李四}
链表的尾结点：Node{data=王五}

6.18、删除链表最后结点

方法实现：

//删除链表最后结点
public void removeLast() {
    //判断链表是否为空
    if (isEmpty()) {
        return;
    }
    //删除链表最后结点
    removeIndex(size - 1);
}

方法测试：

public class SinglyCircularLinkedListTest {
    public static void main(String[] args) {
        SinglyCircularLinkedList<String> linkedList = new SinglyCircularLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        linkedList.removeLast();

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.getIndex(i));
        }
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：2
链表是否为空：false
==========打印链表所有结点：
Node{data=张三}
Node{data=李四}
==========打印链表首尾结点：
链表的头结点：Node{data=张三}
链表的尾结点：Node{data=李四}

6.19、输出链表所有结点

方法实现：

//输出链表所有结点
public void show() {
    //判断链表是否为空
    if (isEmpty()) {
        return;
    }
    //遍历链表所有结点
    Node curNode = head;
    do {
        System.out.println(curNode);
        curNode = curNode.next;
    } while (curNode != head);
}

方法测试：

public class SinglyCircularLinkedListTest {
    public static void main(String[] args) {
        SinglyCircularLinkedList<String> linkedList = new SinglyCircularLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        linkedList.show();
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：3
链表是否为空：false
==========打印链表所有结点：
Node{data=张三}
Node{data=李四}
Node{data=王五}
==========打印链表首尾结点：
链表的头结点：Node{data=张三}
链表的尾结点：Node{data=王五}

6.20、反转链表所有结点

方法实现：

//反转链表所有结点
public void reverse() {
    //判断链表是否为空
    if (isEmpty()) {
        return;
    }
    //创建一个临时节点
    Node newHead = new Node(null);
    //循环遍历圆环结点
    Node newFirst;
    Node tmpNode;
    Node curNode = head;
    do {
        //缓存当前结点下个结点
        tmpNode = curNode.next;
        //获取临时结点首结点
        newFirst = newHead.next;
        //开始三个结点进行关联
        connectNode(newHead, curNode);
        connectNode(curNode, newFirst);
        //让当前的结点往后移动
        curNode = tmpNode;
    } while (curNode != head);
    //交换旧头尾指向
    tmpNode = head;
    head = last;
    last = tmpNode;
    //首尾相连成圆环
    connectNode(last, newHead.next);
    //释放新建临时节点
    releaseNode(newHead);
}

方法测试：

public class SinglyCircularLinkedListTest {
    public static void main(String[] args) {
        SinglyCircularLinkedList<String> linkedList = new SinglyCircularLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        linkedList.reverse();

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        linkedList.show();
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：3
链表是否为空：false
==========打印链表所有结点：
Node{data=王五}
Node{data=李四}
Node{data=张三}
==========打印链表首尾结点：
链表的头结点：Node{data=王五}
链表的尾结点：Node{data=张三}

6.21、清空链表所有结点

方法实现：

//清空链表所有结点
public void clear() {
    //判断链表是否为空
    if (isEmpty()) {
        return;
    }
    //遍历链表所有结点
    Node tmpNode;
    Node curNode = head;
    do {
        //缓存下个结点
        tmpNode = curNode.next;
        //释放当前结点
        releaseNode(curNode);
        //移动下个结点
        curNode = tmpNode;
    } while (curNode != head);
    //重置链表基本信息
    head = null;
    last = null;
    size = 0;
}

方法测试：

public class SinglyCircularLinkedListTest {
    public static void main(String[] args) {
        SinglyCircularLinkedList<String> linkedList = new SinglyCircularLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        linkedList.clear();

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        linkedList.show();
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

==========打印链表基本信息：
链表结点个数：0
链表是否为空：true
==========打印链表所有结点：
==========打印链表首尾结点：
链表的头结点：null
链表的尾结点：null

6.22、顺序查找数据首次出现位置

方法实现：

//顺序查找数据首次出现位置
public int indexOf(E e) {
    //判断链表是否为空
    if (isEmpty()) {
        return -1;
    }
    //判断对象是否为空
    if (e == null) {
        return -1;
    }
    //获取指定位置结点
    Node curNode = head;
    for (int i = 0; i < size; i++) {
        if (e.equals(curNode.data)) {
            return i;
        }
        curNode = curNode.next;
    }
    //没有找到返回负一
    return -1;
}

方法测试：

public class SinglyCircularLinkedListTest {
    public static void main(String[] args) {
        SinglyCircularLinkedList<String> linkedList = new SinglyCircularLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        System.out.println(linkedList.indexOf("张三"));
        System.out.println(linkedList.indexOf("李四"));
        System.out.println(linkedList.indexOf("王五"));

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        linkedList.show();
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

0
1
2
==========打印链表基本信息：
链表结点个数：3
链表是否为空：false
==========打印链表所有结点：
Node{data=张三}
Node{data=李四}
Node{data=王五}
==========打印链表首尾结点：
链表的头结点：Node{data=张三}
链表的尾结点：Node{data=王五}

6.23、逆序查找数据首次出现位置

方法实现：

//逆序查找数据首次出现位置
public int lastIndexOf(E e) {
    //判断链表是否为空
    if (isEmpty()) {
        return -1;
    }
    //判断对象是否为空
    if (e == null) {
        return -1;
    }
    //反转当前链表结点
    reverse();
    //获取指定位置结点
    int index = indexOf(e);
    //反转当前链表结点
    reverse();
    //返回数据指定位置
    return index;
}

方法测试：

public class SinglyCircularLinkedListTest {
    public static void main(String[] args) {
        SinglyCircularLinkedList<String> linkedList = new SinglyCircularLinkedList<>();

        linkedList.addLast("张三");
        linkedList.addLast("李四");
        linkedList.addLast("王五");

        System.out.println(linkedList.lastIndexOf("张三"));
        System.out.println(linkedList.lastIndexOf("李四"));
        System.out.println(linkedList.lastIndexOf("王五"));

        System.out.println("==========打印链表基本信息：");
        System.out.println("链表结点个数：" + linkedList.size());
        System.out.println("链表是否为空：" + linkedList.isEmpty());
        System.out.println("==========打印链表所有结点：");
        linkedList.show();
        System.out.println("==========打印链表首尾结点：");
        System.out.println("链表的头结点：" + linkedList.getFirst());
        System.out.println("链表的尾结点：" + linkedList.getLast());
    }
}

运行结果：

2
1
0
==========打印链表基本信息：
链表结点个数：3
链表是否为空：false
==========打印链表所有结点：
Node{data=张三}
Node{data=李四}
Node{data=王五}
==========打印链表首尾结点：
链表的头结点：Node{data=张三}
链表的尾结点：Node{data=王五}

第七章双向循环链表介绍

双向循环链表是另一种形式的链式存储结构，它的特点是表中最后一个结点的指针域指向头结点，头结点的指针域指向最后一个结点，整个链表形成一个环。

第八章双向循环链表实现

8.01、再看代码如此多娇

我们已经学过了单向循环链表的设计和实现了，双向循环链表只需要在单向循环链表的基础上添加三行代码就能实现，你看神奇不神奇。

我们需要直接拷贝SinglyCircularLinkedList为DoublyCircularLinkedList，然后拷贝SinglyCircularLinkedListTest为DoublyCircularLinkedListTest，并修改相对应的构造方法名称。

第一处：修改节点类，添加prev指针域。

//定义结点类
public class Node {
    Node prev;  //指向上个结点 +
    E data;     //代表结点数据
    Node next;  //指向下个结点

    public Node(E data) {
        this.data = data;
    }

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

第二处：修改连接处，添加指向上个结点。

//连接链表两个结点
public void connectNode(Node prevNode, Node nextNode) {
    if (prevNode != null) {
        prevNode.next = nextNode;
    }
    if (nextNode != null) {         // +
        nextNode.prev = prevNode;   // +
    }                               // +
}

第三处：修改释放处，添加释放prev指针域。

//释放链表指定结点
public void releaseNode(Node node) {
    if (node != null) {
        node.prev = null;   // +
        node.data = null;
        node.next = null;
    }
}

到此，双向循环链表的设计和实现就学完了，但是既然存在双向循环链表，那么肯定还有一些方法可以简化，接下来，我们需要对一些特殊的方法进行优化。

8.02、获取位置之前结点

//获取位置之前结点
private Node getIndexPre(int index) {
    return getIndex(index).prev;
}

8.03、删除链表最后结点

//删除链表最后结点
public void removeLast() {
    //判断链表是否为空
    if (isEmpty()) {
        return;
    }
    //获取位置之前结点
    Node preNode = last.prev;
    //获取指定位置结点
    Node curNode = last;
    //获取位置之后结点
    Node nexNode = last.next;
    //如果只有一个结点
    if (size == 1) {
        //修改head的指向
        head = null;
        //修改last的指向
        last = null;
        //释放链表指定结点
        releaseNode(preNode);
        releaseNode(curNode);
        releaseNode(nexNode);
        //当前链表长度减一
        size--;
    } else {
        //修改head的指向
        if (curNode == head) {
            head = nexNode;
        }
        //修改last的指向
        if (curNode == last) {
            last = preNode;
        }
        //删除指定位置结点
        connectNode(preNode, nexNode);
        //释放链表指定结点
        releaseNode(curNode);
        //当前链表长度减一
        size--;
    }
}

8.04、逆序查找数据首次出现位置

//逆序查找数据首次出现位置
public int lastIndexOf(E e) {
    //判断链表是否为空
    if (isEmpty()) {
        return -1;
    }
    //判断对象是否为空
    if (e == null) {
        return -1;
    }
    //获取指定位置结点
    Node curNode = last;
    for (int i = 0; i < size; i++) {
        if (e.equals(curNode.data)) {
            return i;
        }
        curNode = curNode.prev;
    }
    //没有找到返回负一
    return -1;
}

你可能感兴趣的:(数据结构)

数组去重好奇的猫猫猫
整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redis bootstrap 数据库
1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
数据结构之哈希表 X同学的开始数据结构数据结构散列表
哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列 C语言
文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
[Python] 数据结构详解及代码 AIAdvocate 算法 python 数据结构链表
今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
4.C_数据结构_队列荣世蓥数据结构数据结构
概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
C++八股 Petrichorzncu 八股总结 c++开发语言
这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
【树一线性代数】005入门 Owlet_woodBird 算法
Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
【数据结构-一维差分】力扣2848. 与车相交的点 hlc@ 数据结构数据结构 leetcode 算法
给你一个下标从0开始的二维整数数组nums表示汽车停放在数轴上的坐标。对于任意下标i，nums[i]=[starti,endi]，其中starti是第i辆车的起点，endi是第i辆车的终点。返回数轴上被车任意部分覆盖的整数点的数目。示例1：输入：nums=[[3,6],[1,5],[4,7]]输出：7解释：从1到7的所有点都至少与一辆车相交，因此答案为7。示例2：输入：nums=[[1,3],[5
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
【高阶数据结构】并查集椿融雪数据结构与算法数据结构并查集
文章目录一、并查集原理二、并查集实现三、并查集应用一、并查集原理在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，
python中文版软件下载-Python中文版编程大乐趣
python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
开发游戏的学习规划杰克逊的日记游戏学习
第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
六、全局锁和表锁：给表加个字段怎么有这么多阻碍 nieniemin
数据库锁设计的初衷是处理并发问题。作为多用户共享的资源，当出现并发访问的时候，数据库需要合理地控制资源的访问规则。而锁就是用来实现这些访问规则的重要数据结构。根据加锁的范围，MySQL里面的锁大致可以分成全局锁、表级锁和行锁三类。6.1全局锁全局锁就是对整个数据库实例加锁。MySQL提供了一个加全局读锁的方法，命令是Flushtableswithreadlock(FTWRL)。当你需要让整个库处于
Golang Channel PandaSkr golang
Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表英雄哪里出来《LeetCode算法全集》算法数据结构链表 c++归并排序
饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述将两个不降序链表合并为一个新的不降
数据结构 1 五花肉村长数据结构算法开发语言 c语言 visualstudio
1.什么是数据结构数据结构（DataStructure）是计算机存储和组织数据的方式，是指相互之间存在的一种或多种特定关系的数据元的集合。2.什么是算法算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《
【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】 NeVeRMoRE_2024 数据结构与算法实践数据结构算法 leetcode b树
数据结构和算法实践-树-LeetCode113-路径总和Ⅱ题目MyThought代码示例JAVA-8题目给你二叉树的根节点root和一个整数目标和targetSum，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。叶子节点是指没有子节点的节点输入：root=[5,4,8,11,null,13,4,7,2,null,null,5,1],targetSum=22输出：[[5,4,11,2],[
【Python】数据结构,链表,算法详解 AIAdvocate python 数据结构链表排序算法广度优先深度优先
今日内容大纲介绍自定义代码-模拟链表删除节点查找节点算法入门-排序类的冒泡排序选择排序插入排序快速排序算法入门-查找类的二分查找-递归版二分查找-非递归版分线性结构-树介绍基本概述特点和分类自定义代码-模拟二叉树1.自定义代码-模拟链表完整版"""案例:自定义代码,模拟链表.背景: 顺序表在存储数据的时候,需要使用到连续的空间,如果空间不够,就会导致扩容失败,针对于这种情况,我们可以通过链表实现
AI教你学Python 第4天：函数和模块凡人的AI工具箱 AI教你学Python python 开发语言人工智能 AIGC
第四天：数据结构一、什么是数据结构？数据结构是计算机科学中用于组织和存储数据的特定方式。良好的数据结构能够提高数据的访问效率、修改频率和管理能力。Python提供了多种内置数据结构，如列表、元组、字典和集合，便于开发者更有效地处理数据。二、Python中的基本数据结构1.列表（List）定义：列表是一个有序的可变集合，允许重复元素。使用方括号[]表示。#示例：定义一个列表fruits=['appl
互联网 Java 工程师面试题（Java 面试题四）苹果酱0567 面试题汇总与解析 java 中间件开发语言 spring boot 后端
下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
C# Tuple、ValueTuple 語衣 C#知识补充 c#
栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
Rust中的所有权和借用规则详解代码云1 rust 开发语言后端
Rust是一种系统编程语言，其设计目标包括内存安全、并发安全以及性能。为了实现这些目标，Rust引入了一系列独特的编程概念，其中最为核心的就是所有权（Ownership）和借用（Borrowing）规则。本文将详细解释Rust中的所有权和借用规则，以及它们如何确保内存安全和并发安全。一、所有权规则在Rust中，每一个值都有一个与之关联的所有者。这个所有者可以是变量、数据结构或者是其他形式的存储。所
二叉树--python 电子海鸥 Python数据结构与算法 python 开发语言数据结构
二叉树一、概述1、介绍是一种非线性数据结构，将数据一分为二，代表根与叶的派生关系，和链表的结构类似，二叉树的基本单元是结点，每个节点包括值和左右子节点引用。每个节点都有两个引用（类似于双向链表），分别指向左子节点和右子节点，该节点被称为这两个子节点的父节点。当给定一个二叉树的结点时，我们将在该节点的左子节点以及其以下结点所形成的树称为左子树，同理，右子节点的部分被称为右子树。在二叉树中，除了叶节点
使用WAF防御网络上的隐蔽威胁之反序列化攻击 baiolkdnhjaio 网络安全
什么是反序列化反序列化是将数据结构或对象状态从某种格式转换回对象的过程。这种格式通常是二进制流或者字符串（如JSON、XML），它是对象序列化（即对象转换为可存储或可传输格式）的逆过程。反序列化的安全风险反序列化的安全风险主要来自于处理不受信任的数据源时的不当反序列化。如果应用程序反序列化了恶意构造的数据，攻击者可能能够执行代码、访问敏感数据、进行拒绝服务攻击等。这是因为反序列化过程中可能会自动触
java 线程池队列封装_java线程池（线程池组---分离任务队列和线程池）爱打怪的小魔女 java 线程池队列封装
线程池本质上所使用的逻辑模型仍然是我们熟悉的“生产者/消费者”模型。生产消费外部线程(生产者)－－－>任务消费者和生产者共享一个数据结构(缓存任务)PriorityQueue；生产者将任务添加到队列中，消费者从队列中取出数据；队列和线程池(线程池内部维护一个线程数组)，完全耦合在一起，当任务特别多，队列就不断的膨胀，增多，拥堵；就向车子过洞子另外一头走不掉，我靠，长龙(世界最长堵车世界纪录在天朝2
Java序列化进阶篇 g21121 java序列化
1.transient 类一旦实现了Serializable 接口即被声明为可序列化，然而某些情况下并不是所有的属性都需要序列化，想要人为的去阻止这些属性被序列化，就需要用到transient 关键字。
escape()、encodeURI()、encodeURIComponent()区别详解 aigo JavaScript Web
原文：http://blog.sina.com.cn/s/blog_4586764e0101khi0.html JavaScript中有三个可以对字符串编码的函数，分别是： escape,encodeURI,encodeURIComponent，相应3个解码函数：,decodeURI,decodeURIComponent 。下面简单介绍一下它们的区别 1 escape()函
ArcgisEngine实现对地图的放大、缩小和平移 Cb123456 添加矢量数据对地图的放大、缩小和平移 Engine
ArcgisEngine实现对地图的放大、缩小和平移: 个人觉得是平移，不过网上的都是漫游，通俗的说就是把一个地图对象从一边拉到另一边而已。就看人说话吧. 具体实现: 一、引入命名空间 using ESRI.ArcGIS.Geometry; using ESRI.ArcGIS.Controls; 二、代码实现.
Java集合框架概述天子之骄 Java集合框架概述
集合框架集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。简单介绍： Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
旗正4.0页面跳转传值问题何必如此 java jsp
跳转和成功提示 a) 成功字段非空forward 成功字段非空forward，不会弹出成功字段，为jsp转发，页面能超链接传值,传输变量时需要拼接。接拼接方式list.jsp?test="+strweightUnit+"或list.jsp?test="+weightUnit+&qu
全网唯一:移动互联网服务器端开发课程 cocos2d-x小菜 web开发移动开发移动端开发移动互联程序员
移动互联网时代来了！ App市场爆发式增长为Web开发程序员带来新一轮机遇，近两年新增创业者，几乎全部选择了移动互联网项目！传统互联网企业中超过98%的门户网站已经或者正在从单一的网站入口转向PC、手机、Pad、智能电视等多端全平台兼容体系。据统计，AppStore中超过85%的App项目都选择了PHP作为后端程
Log4J通用配置|注意问题笔记 7454103 DAO apache tomcat log4j Web
关于日志的等级那些去百度就知道了！这几天要搭个新框架配置了日志记下来！做个备忘！ #这里定义能显示到的最低级别,若定义到INFO级别,则看不到DEBUG级别的信息了~! log4j.rootLogger=INFO,allLog # DAO层 log记录到dao.log 控制台和总日志文件 log4j.logger.DAO=INFO,dao,C
SQLServer TCP/IP 连接失败问题 ---SQL Server Configuration Manager darkranger sql c windows SQL Server XP
当你安装完之后,连接数据库的时候可能会发现你的TCP/IP 没有启动.. 发现需要启动客户端协议 : TCP/IP 需要打开 SQL Server Configuration Manager... 却发现无法打开 SQL Server Configuration Manager..?? 解决方法: C:\WINDOWS\system32目录搜索framedyn.
[置顶] 做有中国特色的程序员 aijuans 程序员
从出版业说起网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有些技术书读得可
document.domain 跨域问题 avords document
document.domain用来得到当前网页的域名。比如在地址栏里输入：javascript:alert(document.domain); //www.315ta.com我们也可以给document.domain属性赋值，不过是有限制的，你只能赋成当前的域名或者基础域名。比如：javascript:alert(document.domain = "315ta.com");
关于管理软件的一些思考 houxinyou 管理
工作好多看年了,一直在做管理软件,不知道是我最开始做的时候产生了一些惯性的思维,还是现在接触的管理软件水平有所下降.换过好多年公司,越来越感觉现在的管理软件做的越来越乱. 在我看来,管理软件不论是以前的结构化编程,还是现在的面向对象编程,不管是CS模式,还是BS模式.模块的划分是很重要的.当然,模块的划分有很多种方式.我只是以我自己的划分方式来说一下. 做为管理软件,就像现在讲究MVC这
NoSQL数据库之Redis数据库管理(String类型和hash类型) bijian1013 redis 数据库 NoSQL
一.Redis的数据类型 1.String类型及操作 String是最简单的类型，一个key对应一个value，string类型是二进制安全的。Redis的string可以包含任何数据，比如jpg图片或者序列化的对象。 Set方法：设置key对应的值为string类型的value
Tomcat 一些技巧征客丶 java tomcat dos
以下操作都是在windows 环境下一、Tomcat 启动时配置 JAVA_HOME 在 tomcat 安装目录，bin 文件夹下的 catalina.bat 或 setclasspath.bat 中添加 set JAVA_HOME=JAVA 安装目录 set JRE_HOME=JAVA 安装目录/jre 即可；二、查看Tomcat 版本在 tomcat 安装目
【Spark七十二】Spark的日志配置 bit1129 spark
在测试Spark Streaming时，大量的日志显示到控制台，影响了Spark Streaming程序代码的输出结果的查看(代码中通过println将输出打印到控制台上)，可以通过修改Spark的日志配置的方式，不让Spark Streaming把它的日志显示在console 在Spark的conf目录下，把log4j.properties.template修改为log4j.p
Haskell版冒泡排序 bookjovi 冒泡排序 haskell
面试的时候问的比较多的算法题要么是binary search，要么是冒泡排序，真的不想用写C写冒泡排序了，贴上个Haskell版的，思维简单，代码简单，下次谁要是再要我用C写冒泡排序，直接上个haskell版的，让他自己去理解吧。 sort [] = [] sort [x] = [x] sort (x:x1:xs) | x>x1 = x1:so
java 路径配置文件读取 bro_feng java
这几天做一个项目，关于路径做如下笔记，有需要供参考。取工程内的文件，一般都要用相对路径，这个自然不用多说。在src统计目录建配置文件目录res,在res中放入配置文件。读取文件使用方式： 1. MyTest.class.getResourceAsStream("/res/xx.properties") 2. properties.load(MyTest.
读《研磨设计模式》-代码笔记-简单工厂模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 个人理解：简单工厂模式就是IOC; * 客户端要用到某一对象，本来是由客户创建的，现在改成由工厂创建，客户直接取就好了 */ interface IProduct {
SVN与JIRA的关联 chenyu19891124 SVN
SVN与JIRA的关联一直都没能装成功，今天凝聚心思花了一天时间整合好了。下面是自己整理的步骤：一、搭建好SVN环境，尤其是要把SVN的服务注册成系统服务二、装好JIRA，自己用是jira-4.3.4破解版三、下载SVN与JIRA的插件并解压，然后拷贝插件包下lib包里的三个jar，放到Atlassian\JIRA 4.3.4\atlassian-jira\WEB-INF\lib下，再
JWFDv0.96 最新设计思路 comsci 数据结构算法工作企业应用公告
随着工作流技术的发展，工作流产品的应用范围也不断的在扩展，开始进入了像金融行业(我已经看到国有四大商业银行的工作流产品招标公告了)，实时生产控制和其它比较重要的工程领域，而
vi 保存复制内容格式粘贴 daizj vi 粘贴复制保存原格式不变形
vi是linux中非常好用的文本编辑工具，功能强大无比，但对于复制带有缩进格式的内容时，粘贴的时候内容错位很严重，不会按照复制时的格式排版，vi能不能在粘贴时，按复制进的格式进行粘贴呢？答案是肯定的，vi有一个很强大的命令可以实现此功能。在命令模式输入:set paste，则进入paste模式，这样再进行粘贴时
shell脚本运行时报错误：/bin/bash^M: bad interpreter 的解决办法 dongwei_6688 shell脚本
出现原因：windows上写的脚本，直接拷贝到linux系统上运行由于格式不兼容导致解决办法： 1. 比如文件名为myshell.sh，vim myshell.sh 2. 执行vim中的命令 : set ff?查看文件格式，如果显示fileformat=dos，证明文件格式有问题 3. 执行vim中的命令 :set fileformat=unix 将文件格式改过来就可以了，然后:w
高一上学期难记忆单词 dcj3sjt126com word english
honest 诚实的；正直的 argue 争论 classical 古典的 hammer 锤子 share 分享；共有 sorrow 悲哀；悲痛 adventure 冒险 error 错误；差错 closet 壁橱；储藏室 pronounce 发音；宣告 repeat 重做；重复 majority 大多数；大半 native 本国的，本地的，本国
hibernate查询返回DTO对象，DTO封装了多个pojo对象的属性 frankco POJO hibernate查询 DTO
DTO-数据传输对象；pojo-最纯粹的java对象与数据库中的表一一对应。简单讲：DTO起到业务数据的传递作用，pojo则与持久层数据库打交道。有时候我们需要查询返回DTO对象，因为DTO
Partition List hcx2013 partition
Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x. You should preserve the original relative order of th
Spring MVC测试框架详解——客户端测试 jinnianshilongnian
上一篇《Spring MVC测试框架详解——服务端测试》已经介绍了服务端测试，接下来再看看如果测试Rest客户端，对于客户端测试以前经常使用的方法是启动一个内嵌的jetty/tomcat容器，然后发送真实的请求到相应的控制器；这种方式的缺点就是速度慢；自Spring 3.2开始提供了对RestTemplate的模拟服务器测试方式，也就是说使用RestTemplate测试时无须启动服务器，而是模拟一
关于推荐个人观点 liyonghui160com 推荐系统关于推荐个人观点
回想起来，我也做推荐了3年多了，最近公司做了调整招聘了很多算法工程师，以为需要多么高大上的算法才能搭建起来的，从实践中走过来，我只想说【不是这样的】第一次接触推荐系统是在四年前入职的时候，那时候，机器学习和大数据都是没有的概念，什么大数据处理开源软件根本不存在，我们用多台计算机web程序记录用户行为，用.net的w
不间断旋转的动画 pangyulei 动画
CABasicAnimation* rotationAnimation; rotationAnimation = [CABasicAnimation animationWithKeyPath:@"transform.rotation.z"]; rotationAnimation.toValue = [NSNumber numberWithFloat: M
自定义annotation sha1064616837 java enum annotation reflect
对象有的属性在页面上可编辑，有的属性在页面只可读，以前都是我们在页面上写死的，时间一久有时候会混乱，此处通过自定义annotation在类属性中定义。越来越发现Java的Annotation真心很强大，可以帮我们省去很多代码，让代码看上去简洁。下面这个例子主要用到了 1.自定义annotation：@interface，以及几个配合着自定义注解使用的几个注解 2.简单的反射 3.枚举
Spring 源码 up2pu spring
1.Spring源代码 https://github.com/SpringSource/spring-framework/branches/3.2.x 注：兼容svn检出 2.运行脚本 import-into-eclipse.bat 注：需要设置JAVA_HOME为jdk 1.7 build.gradle compileJava { sourceCompatibilit
利用word分词来计算文本相似度 yangshangchuan word word分词文本相似度余弦相似度简单共有词
word分词提供了多种文本相似度计算方式：方式一：余弦相似度，通过计算两个向量的夹角余弦值来评估他们的相似度实现类：org.apdplat.word.analysis.CosineTextSimilarity 用法如下： String text1 = "我爱购物"; String text2 = "我爱读书"; String text3 =

线性结构：链表

目录

第一章 单向链表介绍

第二章 单向链表实现

2.01、定义链表的结点类

2.02、定义链表的属性值

2.03、初始化各个属性值

2.04、获取链表当前大小

2.05、判断链表是否为空

2.06、检查下标是否合法

2.07、连接链表两个结点

2.08、释放链表指定结点

2.09、返回链表最后结点

2.10、返回链表首个结点

2.11、获取指定位置结点

2.12、获取位置之前结点

2.13、链表尾后添加数据

2.14、链表头后添加数据

2.15、指定位置添加数据

2.16、删除指定位置结点

2.17、删除链表首个结点

2.18、删除链表最后结点

2.19、输出链表所有结点

2.20、反转链表所有结点

2.21、清空链表所有结点

2.22、顺序查找数据首次出现位置

2.23、逆序查找数据首次出现位置

第三章 双向链表介绍

第四章 双向链表实现

4.01、且看代码如此多娇

4.02、获取位置之前结点

4.03、删除链表最后结点

4.04、逆序查找数据首次出现位置

第五章 单向循环链表介绍

第六章 单向循环链表实现

6.01、定义链表的结点类

6.02、定义链表的属性值

6.03、初始化各个属性值

6.04、获取链表当前大小

6.05、判断链表是否为空

6.06、检查下标是否合法

6.07、连接链表两个结点

6.08、释放链表指定结点

6.09、返回链表最后结点

6.10、返回链表首个结点

6.11、获取指定位置结点

6.12、获取位置之前结点

6.13、链表尾后添加数据

6.14、链表头后添加数据

6.15、指定位置添加数据

6.16、删除指定位置结点

6.17、删除链表首个结点

6.18、删除链表最后结点

6.19、输出链表所有结点

6.20、反转链表所有结点

6.21、清空链表所有结点

6.22、顺序查找数据首次出现位置

6.23、逆序查找数据首次出现位置

第七章 双向循环链表介绍

第八章 双向循环链表实现

8.01、再看代码如此多娇

8.02、获取位置之前结点

8.03、删除链表最后结点

8.04、逆序查找数据首次出现位置

你可能感兴趣的:(数据结构)

第一章单向链表介绍

第二章单向链表实现

第三章双向链表介绍

第四章双向链表实现

第五章单向循环链表介绍

第六章单向循环链表实现

第七章双向循环链表介绍

第八章双向循环链表实现