数据结构与算法05 -- 双向链表

双向链表

使用双向链表可以提升链表的综合性能；其结构如下图所示：

Snip20210402_96.png

size表示链表中已经存储元素的个数；
first指针指向链表的首节点，last指针指向链表的尾节点；
Node是节点模型，element是数据域存储数据元素，prev是指针域，指向当前节点的前面一个节点，next是指针域，指向当前节点的后面一个节点。

双向链表的接口设计与动态数组，单向链表的类似

代码实现如下：

package com.example.linkedlist.list;

/**
 * 双向链表
 */
public class YYLinkedList<E> extends AbstrctList<E> {
    /**
     * 首节点
     */
    private Node<E> first;

    /**
     * 尾节点
     */
    private Node<E> last;

    /**
     * 节点模型内部类
     * @param <E>
     */
    private static class Node<E>{
        /**
         * 数据元素
         */
        E element;

        /**
         * 上一个节点
         */
        Node<E> prev;

        /**
         * 下一个节点
         */
        Node<E> next;

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

        @Override
        public String toString() {
            StringBuffer sb = new StringBuffer();
            if (prev != null){
                sb.append(prev.element);
            }else {
                sb.append("null");
            }

            sb.append("_").append(element).append("_");

            if (next != null){
                sb.append(next.element);
            }else {
                sb.append("null");
            }
            return sb.toString();
        }
    }


    @Override
    public void insertObjectAtIndex(int index, E element) {
        rangeCheckForInsert(index);
        //首先根据index找到当前节点
        if (index == size){//往最后面插入元素
            Node<E> oldLast = last;
            last = new Node<>(element,oldLast,null);
            if (oldLast == null){//这是链表添加的第一个元素
                first = last;
            }else {
                oldLast.next = last;
            }
        }else{
            //往首节点插入元素
            Node<E> node = nodeOfIndex(index);
            Node<E> newNode = new Node<>(element,node.prev,node);
            if (node.prev == null){
                node.prev = newNode;
                first = newNode;
            }else {//往中间插入元素
                newNode.prev.next = newNode;
                node.prev = newNode;
            }
        }
        size++;
    }

    @Override
    public E removeObjectAtIndex(int index) {
        rangeCheck(index);

        Node<E> node = nodeOfIndex(index);
        if (node.prev == null){ //index = 0
            first = node.next;
        }else {
            node.prev.next = node.next;
        }

        if (node.next == null){//index = size - 1
            last = node.prev;
        }else {
            node.next.prev = node.prev;
        }

        size--;
        return node.element;
    }

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

    @Override
    public E setObjectAtIndex(int index, E element) {
        Node<E> node = nodeOfIndex(index);
        E old = node.element;
        node.element = element;
        return old;
    }

    @Override
    public E objectAtIndex(int index) {
        return nodeOfIndex(index).element;
    }

    @Override
    public int indexOfObject(E element) {
        if (element == null){
            Node<E> node = first;
            for (int i = 0;i < size;i++){
                node = node.next;
                if (node.element == null) return I;
            }
        }else {
            Node<E> node = first;
            for (int i = 0;i < size;i++){
                node = node.next;
                if (node.element.equals(element)) return I;
            }
        }
        return ELEMENT_NOT_FOUND;
    }


    /**
     * 根据index索引 返回节点
     * @param index
     * @return
     */
    private Node<E> nodeOfIndex(int index){
        rangeCheck(index);

        //当index小于size的一半,以first首节点为起点,进行查找
        if (index < (size >> 1)){
            Node<E> node = first;
            for (int i = 0;i < index;i++){
                node = node.next;
            }
            return node;
        }else {//当index小于size的一半，以last尾节点为起点,进行查找
            Node<E> node = last;
            for (int i = size - 1;i > index;i--){
                node = node.prev;
            }
            return node;
        }
    }

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

原始的双向链表如下图所示，下面的代码分析都是针对此链表的展开的：

Snip20210402_112.png

public void insertObjectAtIndex(int index, E element)：往链表指定index位置插入元素element；

@Override
    public void insertObjectAtIndex(int index, E element) {
        rangeCheckForInsert(index);
        //首先根据index找到当前节点
        if (index == size){//往最后面插入元素
            Node<E> oldLast = last;
            last = new Node<>(element,oldLast,null);
            if (oldLast == null){//这是链表添加的第一个元素
                first = last;
            }else {
                oldLast.next = last;
            }
        }else{
            //往首节点插入元素
            Node<E> node = nodeOfIndex(index);
            Node<E> newNode = new Node<>(element,node.prev,node);
            if (node.prev == null){
                node.prev = newNode;
                first = newNode;
            }else {//往中间插入元素
                newNode.prev.next = newNode;
                node.prev = newNode;
            }
        }
        size++;
    }

代码逻辑中主要分为四种情形：

1> 往空链表中添加元素，原理如下图所示：

Snip20210402_108.png

2> 往链表的尾节点添加元素，原理如下图所示：

Snip20210402_105.png

3> 往链表的首节点添加元素，原理如下图所示：

Snip20210402_106.png

4> 往链表中间节点index=2添加元素，原理如下图所示：

Snip20210402_107.png

public E removeObjectAtIndex(int index)：移除指定index位置的元素

@Override
    public E removeObjectAtIndex(int index) {
        rangeCheck(index);

        Node<E> node = nodeOfIndex(index);
        if (node.prev == null){ //index = 0
            first = node.next;
        }else {
            node.prev.next = node.next;
        }

        if (node.next == null){//index = size - 1
            last = node.prev;
        }else {
            node.next.prev = node.prev;
        }

        size--;
        return node.element;
    }

代码逻辑中主要分为四种情况：

1> 当链表只有一个节点元素时删除节点，原理如下图所示：

Snip20210403_142.png

2> 移除首节点元素，原理如下图所示：

Snip20210402_110.png

3> 当删除链表的尾节点，原理如下图所示：

Snip20210402_111.png

4> 当删除链表的中间节点index=2，原理如下图所示：

Snip20210402_109.png

public void clear()：清空链表，其实现原理如下图所示：

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

Snip20210402_113.png

首先介绍一下 gc root对象；
被栈指针指向的对象称之为gc root对象；只有当栈指针销毁，对象才会销毁；
如果对象没有被栈指针指向，而是堆指针引用，此对象会释放销毁；
所以中间节点的相互引用都属于堆指针引用，不会形成循环引用，节点都会回收。
private Node<E> nodeOfIndex(int index)：根据index获取节点

private Node<E> nodeOfIndex(int index){
        rangeCheck(index);

        //当index小于size的一半,以first首节点为起点,进行查找
        if (index < (size >> 1)){
            Node<E> node = first;
            for (int i = 0;i < index;i++){
                node = node.next;
            }
            return node;
        }else {//当index大于size的一半，以last尾节点为起点,进行查找
            Node<E> node = last;
            for (int i = size - 1;i > index;i--){
                node = node.prev;
            }
            return node;
        }
    }

为了提高查找效率，查找逻辑如下：

当index小于size的一半,以first首节点为起点,进行查找；
当index大于size的一半，以last尾节点为起点,进行查找。

测试代码如下：

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        YYLinkedList linkedList = new YYLinkedList();
        linkedList.addObject(11);
        linkedList.addObject(22);
        linkedList.addObject(33);
        linkedList.addObject(44);
        linkedList.addObject(55);
        System.out.println(linkedList);

        linkedList.insertObjectAtIndex(1,88);
        System.out.println(linkedList);

        linkedList.removeObjectAtIndex(1);
        System.out.println(linkedList);
    }

调试结果如下：

Snip20210402_114.png

打印中将当前节点的prev节点与next节点的数据元素都打印出来了。

单向链表与双向链表的对比

针对删除的操作数量

单向链表：平均复杂度 = 1+2+3+....+n = n/2+n^2/2，再除以n最后为：1/2+n/2
双向链表：平均复杂度 = (1+2+3+....+n/2)*2=n/2+n^2/4，再除以n最后为：1/2+n/4
可以看出复杂度相同，但双向链表操作数量缩减了一半。

双向链表与动态数组的对比

动态数组：开辟，销毁内存空间的次数相对较少，但可能造成内存空间的浪费(可以通过缩容来解决)
双向链表：开辟，销毁内存空间的次数相对较多，但不会造成内存空间的浪费。
如果频繁的在尾部进行添加，删除操作，动态数组，双向链表均可选择；
如果频繁的在头部进行添加，删除操作，建议使用双向链表；
如果频繁的在任意位置进行添加，删除操作，建议使用使用双向链表；
如果频繁的进行查询操作(随机查询)，建议选择使用动态数组，通过地址直接查询。
在哈希表中会使用到单向链表。

双向循环链表

双向链表尾节点的next指针指向首节点，首节点的prev指针指向尾节点的链表属于双向循环链表；其结构如下图所示：

Snip20210403_129.png

代码实现如下：

/**
 * 双向循环链表
 */
public class YYCircleLinkedList<E> extends AbstrctList<E> {

    /**
     * 首节点
     */
    private Node<E> first;

    /**
     * 尾节点
     */
    private Node<E> last;

    /**
     * 节点模型内部类
     * @param <E>
     */
    private static class Node<E>{
        /**
         * 数据元素
         */
        E element;

        /**
         * 上一个节点
         */
        Node<E> prev;

        /**
         * 下一个节点
         */
        Node<E> next;

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

        @Override
        public String toString() {
            StringBuffer sb = new StringBuffer();
            if (prev != null){
                sb.append(prev.element);
            }else {
                sb.append("null");
            }

            sb.append("_").append(element).append("_");

            if (next != null){
                sb.append(next.element);
            }else {
                sb.append("null");
            }
            return sb.toString();
        }

        @Override
        protected void finalize() throws Throwable {
            super.finalize();
            System.out.println("Node<E> -- finalize");
        }
    }



    @Override
    public void insertObjectAtIndex(int index, E element) {
        rangeCheckForInsert(index);
        //首先根据index找到当前节点
        if (index == size){//往最后面插入元素
            Node<E> oldLast = last;
            last = new Node<>(element,oldLast,first);
            if (oldLast == null){//这是链表添加的第一个元素
                first = last;
                first.next = first;
                first.prev = first;
            }else {
                oldLast.next = last;
                first.prev = last;
            }
        }else{
            //往首节点插入元素
            Node<E> node = nodeOfIndex(index);
            if (index == 0){
                Node<E> newNode = new Node<>(element,last,node);
                node.prev = newNode;
                first = newNode;
                last.next = newNode;
            }else {//往中间插入元素
                Node<E> newNode = new Node<>(element,node.prev,node);
                newNode.prev.next = newNode;
                node.prev = newNode;
            }
        }
        size++;
    }

    @Override
    public E removeObjectAtIndex(int index) {
        rangeCheck(index);
        Node<E> node = first;
        if (size == 1){
            first = null;
            last = null;
        }else {
            node = nodeOfIndex(index);
            node.prev.next = node.next;
            node.next.prev = node.prev;
            if (index == 0){
                first = node.next;
            }
            if (index == size - 1){
                last = node.prev;
            }
        }
        size--;
        return node.element;
    }

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

    @Override
    public E setObjectAtIndex(int index, E element) {
        Node<E> node = nodeOfIndex(index);
        E old = node.element;
        node.element = element;
        return old;
    }

    @Override
    public E objectAtIndex(int index) {
        return nodeOfIndex(index).element;
    }


    @Override
    public int indexOfObject(E element) {
        if (element == null){
            Node<E> node = first;
            for (int i = 0;i < size;i++){
                node = node.next;
                if (node.element == null) return I;
            }
        }else {
            Node<E> node = first;
            for (int i = 0;i < size;i++){
                node = node.next;
                if (node.element.equals(element)) return I;
            }
        }
        return ELEMENT_NOT_FOUND;
    }


    /**
     * 根据index索引 返回节点
     * @param index
     * @return
     */
    private Node<E> nodeOfIndex(int index){
        rangeCheck(index);

        //当index小于size的一半,以first首节点为起点,进行查找
        if (index < (size >> 1)){
            Node<E> node = first;
            for (int i = 0;i < index;i++){
                node = node.next;
            }
            return node;
        }else {//当index小于size的一半，以last尾节点为起点,进行查找
            Node<E> node = last;
            for (int i = size - 1;i > index;i--){
                node = node.prev;
            }
            return node;
        }
    }

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

public void insertObjectAtIndex(int index, E element)：往链表指定index位置插入元素element；

@Override
    public void insertObjectAtIndex(int index, E element) {
        rangeCheckForInsert(index);
        //首先根据index找到当前节点
        if (index == size){//往最后面插入元素
            Node<E> oldLast = last;
            last = new Node<>(element,oldLast,first);
            if (oldLast == null){//这是链表添加的第一个元素
                first = last; 
                first.next = first;
                first.prev = first;
            }else {
                oldLast.next = last;
                first.prev = last;
            }
        }else{
            //往首节点插入元素
            Node<E> node = nodeOfIndex(index);
            if (index == 0){
                Node<E> newNode = new Node<>(element,last,node);
                node.prev = newNode;
                first = newNode;
                last.next = newNode;
            }else {//往中间插入元素
                Node<E> newNode = new Node<>(element,node.prev,node);
                newNode.prev.next = newNode;
                node.prev = newNode;
            }
        }
        size++;
    }

代码逻辑主要分为四种情况：

1> 往空链表中添加元素，原理如下图所示：

Snip20210403_132.png

2> 往链表的尾节点添加元素，原理如下图所示：：

Snip20210403_131.png

3> 往链表的首节点添加元素，原理如下图所示：

Snip20210403_133.png

4> 往链表中间节点index=2添加元素，原理如下图所示：

Snip20210403_135.png

public E removeObjectAtIndex(int index)：移除指定index位置的元素

@Override
    public E removeObjectAtIndex(int index) {
        rangeCheck(index);
        Node<E> node = first;
        if (size == 1){
            first = null;
            last = null;
        }else {
            node = nodeOfIndex(index);
            node.prev.next = node.next;
            node.next.prev = node.prev;
            if (index == 0){
                first = node.next;
            }
            if (index == size - 1){
                last = node.prev;
            }
        }
        size--;
        return node.element;
    }

代码逻辑分为四种情况：

1> 当链表只有一个节点元素时删除节点，原理如下图所示：

Snip20210403_136.png

2> 当删除链表的尾节点，原理如下图所示：

Snip20210403_137.png

3> 当删除链表的首节点，原理如下图所示：

Snip20210403_140.png

4> 当删除链表的中间节点index=2，原理如下图所示：

Snip20210403_138.png

链表的添加与删除逻辑都可以抽象成下面的一般逻辑；

添加元素

1> 往空链表中添加元素；
2> 往链表的尾节点添加元素；
3> 往链表的首节点添加元素；
4> 往链表中间节点index=x添加元素；

删除元素

1> 当链表只有一个节点元素时删除节点；
2> 当删除链表的尾节点；
3> 当删除链表的首节点；
4> 当删除链表的中间节点index=x；

约瑟夫问题

约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3；类似于丢手绢游戏。
在双向循环链表的基础上实现，代码如下所示：

/**
 * 双向循环链表 -- 解决约瑟夫问题(扩展)
 */
public class YYCircleLinkedList2<E> extends AbstrctList<E> {

    /**
     * 首节点
     */
    private Node<E> first;

    /**
     * 尾节点
     */
    private Node<E> last;

    /**
     * 记录当前节点
     */
    private Node<E> current;

    /**
     * 节点模型内部类
     * @param <E>
     */
    private static class Node<E>{
        /**
         * 数据元素
         */
        E element;

        /**
         * 上一个节点
         */
        Node<E> prev;

        /**
         * 下一个节点
         */
        Node<E> next;

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

        @Override
        public String toString() {
            StringBuffer sb = new StringBuffer();
            if (prev != null){
                sb.append(prev.element);
            }else {
                sb.append("null");
            }

            sb.append("_").append(element).append("_");

            if (next != null){
                sb.append(next.element);
            }else {
                sb.append("null");
            }
            return sb.toString();
        }

        @Override
        protected void finalize() throws Throwable {
            super.finalize();
            System.out.println("Node<E> -- finalize");
        }
    }

    public void reset(){
        current = first;
    }

    public E next(){
        if (current == null) return null;
        current = current.next;
        return current.element;
    }

    public E remove(){
        if (current == null) return null;

        Node<E> next = current.next;
        E element = remove(current);
        if (size == 0){
            current = null;
        }else {
            current = next;
        }
        return element;
    }


    @Override
    public void insertObjectAtIndex(int index, E element) {
        rangeCheckForInsert(index);
        //首先根据index找到当前节点
        if (index == size){//往最后面插入元素
            Node<E> oldLast = last;
            last = new Node<>(element,oldLast,first);
            if (oldLast == null){//这是链表添加的第一个元素
                first = last;
                first.next = first;
                first.prev = first;
            }else {
                oldLast.next = last;
                first.prev = last;
            }
        }else{
            //往首节点插入元素
            Node<E> node = nodeOfIndex(index);
            if (index == 0){
                Node<E> newNode = new Node<>(element,last,node);
                node.prev = newNode;
                first = newNode;
                last.next = newNode;
            }else {//往中间插入元素
                Node<E> newNode = new Node<>(element,node.prev,node);
                newNode.prev.next = newNode;
                node.prev = newNode;
            }
        }
        size++;
    }

    @Override
    public E removeObjectAtIndex(int index) {
        rangeCheck(index);
        return remove(nodeOfIndex(index));
    }

    private E remove(Node<E> node){
        if (size == 1){
            first = null;
            last = null;
        }else {
            node.prev.next = node.next;
            node.next.prev = node.prev;
            if (node == first){//删除首节点 index = 0
                first = node.next;
            }
            if (node == last){//删除尾节点 index = size - 1
                last = node.prev;
            }
        }
        size--;
        return node.element;
    }


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

    @Override
    public E setObjectAtIndex(int index, E element) {
        Node<E> node = nodeOfIndex(index);
        E old = node.element;
        node.element = element;
        return old;
    }

    @Override
    public E objectAtIndex(int index) {
        return nodeOfIndex(index).element;
    }


    @Override
    public int indexOfObject(E element) {
        if (element == null){
            Node<E> node = first;
            for (int i = 0;i < size;i++){
                node = node.next;
                if (node.element == null) return I;
            }
        }else {
            Node<E> node = first;
            for (int i = 0;i < size;i++){
                node = node.next;
                if (node.element.equals(element)) return I;
            }
        }
        return ELEMENT_NOT_FOUND;
    }


    /**
     * 根据index索引 返回节点
     * @param index
     * @return
     */
    private Node<E> nodeOfIndex(int index){
        rangeCheck(index);

        //当index小于size的一半,以first首节点为起点,进行查找
        if (index < (size >> 1)){
            Node<E> node = first;
            for (int i = 0;i < index;i++){
                node = node.next;
            }
            return node;
        }else {//当index小于size的一半，以last尾节点为起点,进行查找
            Node<E> node = last;
            for (int i = size - 1;i > index;i--){
                node = node.prev;
            }
            return node;
        }
    }

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

新增了一个属性与三个方法；

current：记录当前节点；
reset：重置当前节点为首节点；
next：将当前节点移动到下一个节点；
remove：删除当前节点，并返回当前节点的数据元素。

代码测试：

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        YYCircleLinkedList2 list = new YYCircleLinkedList2();
        for (int i = 1; i <= 8;i++){
            list.addObject(i);
        }
        System.out.println(list);

        //指向头节点
        list.reset();

        while (!list.isEmpty()){
            list.next();
            list.next();
            System.out.println(list.remove());
        }
    }

测试结果：

Snip20210403_143.png

最后编辑于：2021.04.03 11:48:29

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 212,294评论 6赞 493
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 90,493评论 3赞 385
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 157,790评论 0赞 348
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 56,595评论 1赞 284
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 65,718评论 6赞 386
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,906评论 1赞 290
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,053评论 3赞 410
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,797评论 0赞 268
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,250评论 1赞 303
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,570评论 2赞 327
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,711评论 1赞 341
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,388评论 4赞 332
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,018评论 3赞 316
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,796评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,023评论 1赞 266
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,461评论 2赞 360
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,595评论 2赞 350