刷题0901

剑指 Offer 03. 数组中重复的数字

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xzktv1/

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

  • 思路 1 使用库函数申请额外空间
    使用 HashSet 来进行处理，因为 HashSet 本身不允许出现重复元素，所以当添加元素失败或已经包含该数字时，则表示出现了重复元素，将其返回即可。
    时间复杂度：O(n)，空间复杂度：O(n)
var findRepeatNumber = function(nums) {
    var numsSet = new Set();
    for(var num of nums){
        if(numsSet.has(num)){
            return num;
        }else{
            numsSet.add(num)
        }
    }
    return false
};
  • 思路 2 数组本身做哈希表，达到了节省空间的目的
    时间复杂度：O(n)，空间复杂度：O(1)
var findRepeatNumber = function(nums) {
    for(var i = 0; i<nums.length ; i++){
        while(nums[i] != i){
            if(nums[i] == nums[nums[i]]){
                return nums[i]
            } 
            var tmp = nums[i];
            nums[i] =nums[tmp];
            nums[tmp] = tmp;
        }
    }
    return false
};

剑指 Offer 04. 二维数组中的查找

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xz2hh7/

var findNumberIn2DArray = function(matrix, target) {
    let col = matrix.length;
    if(!col) return false
    let row = matrix[0].length;
    let i=col-1, j=0;
    while(i>=0 && j<row){
        if(matrix[i][j] == target){
               return true;
           }else if(matrix[i][j] > target){
              i--;
           }else{
              j++;
         }
    }
    return false;
};

剑指 Offer 05. 替换空格

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xz2cf5/

var replaceSpace = function(s) {
 return s.split(' ').join('%20')
};

//数组
var replaceSpace = function(s) {
    var res ='';
    for(i = 0; i<s.length; i++){
        if(s[i] == " "){
            res += '%20';
        } else{
            res += s[i]
        }
    }
    return res
};

剑指 Offer 06. 从尾到头打印链表

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xs92sh/

  • 方法一：reverse()
var reversePrint = function(head) {
    var stack = [];
    while(head != null){
        stack.push(head.val);
        head = head.next
    }
    //return stack.reverse()
};
  • 方法二：栈（先进后出，push+pop）
var reversePrint = function(head) {
    var stack = [];
    while(head != null){
        stack.push(head.val);
        head = head.next;
    }
    var res = [];
    const len = stack.length; //需要初始stack的长度
    for(var i = 0; i< len; i++){
        res.push(stack.pop()); //stack长度会不断变化
    }
    return res;
};

剑指 Offer 09. 用两个栈实现队列

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xz8cid/

var CQueue = function() {
    this.stack1=[];
    this.stack2 = [];
};

/** 
 * @param {number} value
 * @return {void}
 */
CQueue.prototype.appendTail = function(value) {
    this.stack1.push(value)
};

/**
 * @return {number}
 */
CQueue.prototype.deleteHead = function() {
    if(this.stack2.length==0){
        while(this.stack1.length != 0){
            this.stack2.push(this.stack1.pop())
        }
    }
    if(this.stack2.length==0){
        return -1
    }else {
        return this.stack2.pop()
    }
};

剑指 Offer 10- I. 斐波那契数列

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xslxpr/
写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项。斐波那契数列的定义如下：
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

var fib = function(n) {
    let f0 = 0, f1 = 1, fn;
    if(n<2){
        return n
    }
    for(let i = 2; i<=n ;i++){
        fn = (f0 + f1) % 1000000007;
        f0 = f1;
        f1 = fn;
    }
    return fn
};

剑指 Offer 17. 打印从 1 到最大的 n 位数

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xzvgc2/

var printNumbers = function(n) {
    if(n==0){
        return false;
    }
    let all = Math.pow(10,n);
    // let all=1
    // for(var i=0;i<n;i++){
    //    all = 10*all   
    // }
    let arr = [];
    for(var i=1;i<all;i++){
        arr.push(i)
    }
return arr;
};

剑指 Offer 18. 删除链表的节点

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xz4mp2/
时间复杂度：O(n)，空间复杂度：O(1)

var deleteNode = function(head, val) {
    if(head == null){
        return null;
    }
    if(head.val == val){
        return head.next;
    }
    var left = head;
    var cur = left.next
    while(cur.val != val && cur.next!= null){
        left=cur;
        cur=cur.next;
    }
    if(cur != null){
        left.next=cur.next
    }
    return head
};

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

var exchange = function(nums) {
  var a = [];
    var b = [];
    for(var i=0;i<nums.length;i++){
        if (nums[i]%2==1){
            a.push(nums[i])
        }else{
            b.push(nums[i])
        }
    }
    return a.concat(b)
};

双指针

var exchange = function(nums) {
    let right = nums.length-1;
    let left = 0;
    let tmp;
    while(left<right){
       if(left<right &&(nums[right]%2)  == 0 ){
            right--;
        }
       if(left<right &&(nums[left]%2) == 1){
            left++;
        }
    tmp = nums[left]
    nums[left] = nums[right]
    nums[right] = tmp 
    }
  return nums  
};

剑指 Offer 22. 链表中倒数第 k 个节点

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xzy5ei/
时间复杂度：O(n)，空间复杂度：O(1)

var getKthFromEnd = function(head, k) {
    var cur = head;
    var post= head;
    for(var i=0; i<k; i++){
        cur = cur.next;
    }
    while(cur!=null){
        cur = cur.next;
        post = post.next
    }
    return post
};

剑指 Offer 24. 反转链表

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xzccxg/
时间复杂度：O(n)，空间复杂度：O(1)

var reverseList = function(head) {
    var cur = null;
    var pre = head;
    while(pre!=null){
       var tmp = pre.next;
        pre.next = cur;
        cur = pre;
        pre = tmp;
    }
    return cur
};

剑指 Offer 25. 合并两个排序的链表

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xzjkjj/
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。O(m+n)

var mergeTwoLists = function(l1, l2) {
    if(l2==null){
        return l1
  }
    if(l1==null){
        return l2
  }
    if(l1.val>l2.val){
        l2.next = mergeTwoLists(l1,l2.next);
        return l2
    }else{
        l1.next = mergeTwoLists(l2,l1.next);
        return l1
    }
};

剑指 Offer 27. 二叉树的镜像

例如输入：
      4
  2      7
1   3  6   9

镜像输出：
     4
  7     2
9   6  3   1

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

var mirrorTree = function(root) {
    let res = null;
    if(root != null){
        res =new TreeNode(root.val);
        res.left = mirrorTree(root.right);
        res.right = mirrorTree(root.left);
    }
    return res 
};

剑指 Offer 28. 对称的二叉树

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xsrxq1/

  • 时间复杂度：O(n)
var isSymmetric = function(root) {
    if(root==null){
        return true;
    }
    return dfs(root.left,root.right)
};
var dfs = function(t1, t2){
    if(t1==null && t2==null) {return true}
    if(t1==null|| t2==null) {return false}
    if(t1.val != t2.val){return false}
    return dfs(t1.left,t2.right) && dfs(t1.right,t2.left)
}

剑指 Offer 30. 包含 min 函数的栈

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xzqg03/

/**
 * initialize your data structure here.
 */
var MinStack = function() {
    this.stack1 = [];
    this.stack2 = [];
};

/**
 * @param {number} x
 * @return {void}
 */
MinStack.prototype.push = function(x) {
    this.stack1.push(x);
    if(this.stack2.length == 0 || this.stack2[this.stack2.length - 1] >= x) {
        this.stack2.push(x);
    }
};

/**
 * @return {void}
 */
MinStack.prototype.pop = function() {
    if(this.stack1.pop() == this.stack2[this.stack2.length - 1]) {
        this.stack2.pop();
    }
};

/**
 * @return {number}
 */
MinStack.prototype.top = function() {
    return this.stack1[this.stack1.length - 1];
};

/**
 * @return {number}
 */
MinStack.prototype.min = function() {
    return this.stack2[this.stack2.length - 1];
};

/**
 * Your MinStack object will be instantiated and called as such:
 * var obj = new MinStack()
 * obj.push(x)
 * obj.pop()
 * var param_3 = obj.top()
 * var param_4 = obj.min()
 */

剑指 Offer 32 - I. 从上到下打印二叉树

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xsnu0i/
例如:
给定二叉树: [3,9,20,null,null,15,7],
返回：[3,9,20,15,7]

var levelOrder = function(root) {
    if(root == null){
        return [];
    }
    let queue = [root];
    let res = [];
    while(queue.length != 0){
        let node = queue.shift();
        res.push(node.val);
        if(node.left){
            queue.push(node.left);
        }
        if(node.right){
            queue.push(node.right);
        }
    }
    return res
};

剑指 Offer 32 - II. 从上到下打印二叉树 II

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xswwvg/
从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
给定二叉树: [3,9,20,null,null,15,7],
返回其层次遍历结果：[[3],[9,20], [15,7]]

var levelOrder = function(root) {
  if(root == null){
        return [];
    }
    let queue = [root];
    let res = [];
    while(queue.length != 0){
        let level = [];
        let len = queue.length;
        for(let i = 0; i < len; i++){
            let node = queue.shift();
            level.push(node.val);
            if(node.left){
                queue.push(node.left);
            }
            if(node.right){
                queue.push(node.right);
            }
        }
        res.push(level)
    }
    return res
};

剑指 Offer 32 - III. 从上到下打印二叉树 III

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xs0paj/
请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

例如:
给定二叉树: [3,9,20,null,null,15,7],
返回其层次遍历结果：[[3],[20,9], [15,7]]

var levelOrder = function(root) {
     if(root == null){
        return [];
    }
    let queue = [root];
    let res = [];
    let flag = 1;
    while(queue.length != 0){
        let level = [];
        let len = queue.length;
        for(let i = 0; i < len; i++){
             let node = queue.shift();
            if(flag==1){  
                level.push(node.val);
            }else{
                level.unshift(node.val);
            };
            if(node.left){
                queue.push(node.left);
                }
            if(node.right){
                queue.push(node.right);
                }
        }
        flag = -flag; 
        res.push(level)
    }
    return res
};

BFS 翻转二叉树（附）

var mirrorTree = function(root) {
    if(root == null){
        return []
    }
    let res = [];
    let queue = [root];
    while(queue.length != 0 ){
        let node = queue.shift();
        res.push(node.val);
        if(node.right){
            queue.push(node.right)
        }
        if(node.left){
            queue.push(node.left)
        }
    }
    return res
};

剑指 Offer 39. 数组中出现次数超过一半的数字

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xz7dgg/

方法一：数组排序：首先将 nums 排序，由于该数字超过数组长度的一半，所以数组的中间元素就是答案，时间复杂度为 O(nlogn)

var majorityElement = function(nums) {
    nums.sort((a,b) => a-b)
    return nums[parseInt(nums.length / 2 )]  
}

方法一：哈希计数：遍历 nums 数组，将数字存在 HashMap 中，统计数字出现次数，统计完成后再遍历一次 HashMap，找到超过一半计数的数字，时间复杂度为 O(n)

摩尔投票：遍历 nums 数组，使用 count 进行计数，记录当前出现的数字为 cur，如果遍历到的 num 与 cur 相等，则 count 自增，否则自减，当其减为 0 时则将 cur 修改为当前遍历的 num，通过增减抵消的方式，最终达到剩下的数字是结果的效果，时间复杂度为 O(n)

  • 摩尔投票是最优解法，时间复杂度：O(n)，空间复杂度：O(1)
var majorityElement = function(nums) {
    let cur ,count=0;
    for(let i = 0; i<nums.length; i++){
        if(count == 0){
            cur = nums[i];  
        }
        if(nums[i]  == cur){
            count++;
        }else{
            count--
        }
    }
    return cur
}

剑指 Offer 40. 最小的k个数

  • 题目：输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

解法 1: 直接排序

思路和算法:对原数组从小到大排序后取出前 k个数即可。

var getLeastNumbers = function(arr, k) {
    arr.sort((a,b)=>a-b)
    var min=[]
    for(var i=0;i<k;i++){
        min.push(arr[i]);
    }
    return min
};

https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof/solution/chao-quan-3chong-jie-fa-zhi-jie-pai-xu-zui-da-dui-/

解法 2: 最大堆

解法 3: 基于快速排序的 partition

剑指 Offer 42. 连续子数组的最大和

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xsiyed/
输入一个整型数组，数组里有正数也有负数。数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为O(n)。

var maxSubArray = function(nums) {
    let res = nums[0]
    for(let i = 1; i<nums.length ;i++){
        if(nums[i-1]>0){
            nums[i] += nums[i-1]
        }else{
            nums[i] = nums[i] 
        }
        res = Math.max(res,nums[i])
    }
    return res
};

剑指 Offer 47. 礼物的最大价值

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xstkx3/
在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？

var maxValue = function(grid) {
    let col = grid.length;
    let row = grid[0].length;
     for(let i = 0; i<col ;i++){
        for(let j = 0; j<row ; j++){
            if(i >= 1 && j >= 1){
                grid[i][j] += Math.max(grid[i-1][j],grid[i][j-1]);
            }else if(i >= 1){
                grid[i][j] += grid[i-1][j];
            }else if(j >= 1){
                grid[i][j] += grid[i][j-1];
            }
        }
    }
    return grid[col-1][row-1];
};

var maxValue = function(grid) {
    let col = grid.length;
    let row = grid[0].length;
       for(let i = 0; i<col ;i++){
        for(let j = 0; j<row ; j++){
             if(i == 0 && j==0){
                continue;
            }else if(i == 0){
                grid[i][j] += grid[i][j-1];
            }else if(j==0){
                grid[i][j] += grid[i-1][j];
            }else {
                grid[i][j] += Math.max(grid[i-1][j],grid[i][j-1]);
            }
        }
    }
    return grid[col-1][row-1];
};

剑指 Offer 50. 第一个只出现一次的字符

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xzzd25/

在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。
示例: s = "abaccdeff" ，返回 "b"；
示例: s = "" ， 返回 " "

  • 思路: 首先遍历字符串将每个字符串映射到固定的位置，并且该位置存储字符串的出现次数，然后再遍历一次字符串，找到第一个只出现一次的字符
    时间复杂度：O(n)，空间复杂度：O(1)
var firstUniqChar = function(s) {
    var maps = new Map();
    for(var num of s){
        maps.set(num, maps.has(num))
    }
     for(var num of s){
         if(maps.get(num)==0){
             return num;
         }
     }
    return " "
};

剑指 Offer 52. 两个链表的第一个公共节点

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xshucr/
使用两个指针 node1，node2 分别指向两个链表 headA，headB 的头结点，然后同时分别逐结点遍历，
当 node1 到达链表 headA 的末尾时，重新定位到链表 headB 的头结点；
当 node2 到达链表 headB 的末尾时，重新定位到链表 headA 的头结点。
这样，当它们相遇时，所指向的结点就是第一个公共结点。

  • 时间复杂度：O(M+N)。
  • 空间复杂度：O(1)O(1)。
//（双指针法）
var getIntersectionNode = function(headA, headB) {
    let curA = headA;
    let curB = headB;
    while (curA != curB) {
        curA = curA != null ? curA.next : headB;
        curB = curB != null ? curB.next : headA;
    }
    return curA;
};

剑指 Offer 53 - II. 0～n-1中缺失的数字

解法 1: 遍历

var missingNumber = function(nums) {  
    if(nums[i]==0){
        return 1
    }
    for(var i=0;i<nums.length;i++){
        if(nums[i]!=i){
            return i
        }
    }
    return nums.length
};

解法 2: 二分查找（有序数组都应该想到二分查找）

var missingNumber = function(nums) {
    let i = 0;
    let j = nums.length-1;
    while(i <= j){
        let mid =parseInt((i + j) / 2)
        if(nums[mid] == mid){
            i = mid + 1;
        }else{
            j = mid - 1
        }   
    }
    return i
};

剑指 Offer 54. 二叉搜索树的第 k 大节点

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xspy85/

  • 时间复杂度：O(n)，空间复杂度：O(1)
  • 二叉搜索树：根节点的值大于其左子树中任意一个节点的值，小于其右节点中任意一节点的值，这一规则适用于二叉查找树中的每一个节点。
  • 二叉搜索树的【中序遍历】为 【递增序列】，易得二叉搜索树的 【中序遍历倒序】 为 【递减序列】 。
    因此，求 “二叉搜索树第 k大的节点” 可转化为求 “此树的【中序遍历倒序】的第 k 个节点”。 中序遍历 为 “左、根、右” 顺序，倒序就是“右、根、左” 。
    时间复杂度：O(n)，空间复杂度：O(1)
var nums;
var res;
var kthLargest = function(root, k) {
    nums = k
    dfs(root);
    return res;
};
var dfs = function(root){
    if(root == null){
        return;
    }
    dfs(root.right);
    if(nums == 0){
        return
    }
    nums --;
    if(nums==0){
        res = root.val
    }
    dfs(root.left)
}

剑指 Offer 55 - I. 二叉树的深度

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xsaki2/

  • 时间复杂度：O(n)，空间复杂度：O(1)
var maxDepth = function(root) {
    if(root == null){
        return 0
    }
    return Math.max(maxDepth(root.left),maxDepth(root.right))+1
};

剑指 Offer 57. 和为 s 的两个数字

https://leetcode-cn.com/leetbook/read/illustrate-lcof/xzimqj/
输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。
思路：有序数组，双指针

var twoSum = function(nums, target) {
    var len = nums.length;
    var left = 0;
    var right = len-1;
    var arr = []
    for(var i = 0; i<len ;i++){
        if(nums[left]+nums[right] == target){
            //  arr.push(nums[left]);
            // arr.push(nums[right]) 
            return  [nums[left],nums[right]]
        };
        if(nums[left]+nums[right] > target){
            right--
        }
        if(nums[left]+nums[right] < target){
            left++
        }
    }
};

剑指 Offer 57 - II. 和为s的连续正数序列

  • 题目描述：输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。
    序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。
    示例：输入：target = 9;输出：[[2,3,4],[4,5]]

  • 题解

方法：滑动窗口

var findContinuousSequence = function(target) {
    var i=1;
    var j=1;
    var sum = 0;
    var res =[];
    while(i<=parseInt(target/2)){
        if (sum<target){
           sum+=j;
           j++;
        }else if(sum>target){
            sum -=i;
            i++;
        }else{
            let arr =[];
            for(let k=i;k<j;k++){
                arr.push(k);
            }
            res.push(arr)
            sum -=i;
            i++;
        }
    }
    return res;
};

剑指 Offer 61. 扑克牌中的顺子

  • 题目：从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。2～10为数字本身，A为1，J为11，Q为12，K为13，而大、小王为 0 ，可以看成任意数字。A 不能视为 14。
  • 方法：排序 + 遍历
  • 思路：最大值-最小值<5，且没有重复的数字。
var isStraight = function(nums) {
    nums.sort((a,b) => a-b);
    var len = nums.length;
    var joker = 0;//判断0的个数
    for(var i = 0; i<len ;i++){
        if(nums[i] === 0){
            joker++
        }else if(nums[i] == nums[i+1]){
            return false
        }
    }
    return (nums[len-1]-nums[joker] < 5) ? true :false // 最大值-最小值 <5
 };

剑指 Offer 62. 圆圈中最后剩下的数字

1、递归
递推公式：f(N,M) = ( f(N−1,M) + M ) % N

var lastRemaining = function(n, m) {
    if(n==1){
        return 0;
    }
    var res = lastRemaining(n-1,m)
    return (res+m)%n
};

2、迭代实现
时间复杂度：O(n)，需要求解的函数值有 n 个。
空间复杂度：O(1)，只使用常数个变量。

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