shassd的博客

插入排序： 插入排序最好时间复杂度是 O(n)，即当数组刚好是完全顺序时，每次只用比较一次就能找到正确的位置。这个过程重复 n 次，就可以清空未排序区间。 插入排序最坏时间复杂度则需要 O(nn)。即当数组刚好是完全逆序时，每次都要比较 n 次才能找到正确位置。这个过程重复 n 次，就可以清空未排序区间，所以最坏时间复杂度为 O(nn)。 插入排序的平均时间复杂度是 O(nn)。这是因为往数组中插入一个元素的平均时间复杂度为 O(n)，而插入排序可以理解为重复 n 次的数组插入操作，所以平均时间复杂度为 O

例 2，假设有一个在线系统，可以实时接收用户提交的字符串型关键字，并实时返回给用户累积至今这个关键字被提交的次数。 例如，用户输入"abc"，系统返回 1。用户再输入"jk"，系统返回 1。用户再输入"xyz"，系统返回 1。用户再输入"abc"，系统返回 2。用户再输入"abc"，系统返回 3。 一种解决方法是，用一个数组保存用户提交过的所有关键字。当接收到一个新的关键字后，插入到数组中，并且统计这个关键字出现的次数。 根据数组的知识可以计算出，插入到最后的动作，时间复杂度是 O(1)。但统计出现次数必须

子串查找（字符串匹配） package com.company; public class Character { public static void main(String[] args){ String s1="gooleChrome"; String s2="goole"; int result=choose(s1,s2); } /** * 字串查找 * 首先判断主串的第一个字符是否与字串

题目：给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 示例 1: 输入: prices = [7,1,5,3,6,4] 输出: 7 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 随后，在第 4 天（

广度优先遍历BFS和深度优先遍历DFS 1.DFS和BFS的特点比较 2.BFS的适用场景 3.如何用BFS进行层序遍历 4.如何用BFS求解最短路径问题 DFS遍历使用递归 void dfs(TreeNode root){ if (root==null){ return; } dfs(root.left); dfs(root.right); } BFS 遍历使用队列数据结构 void bfs(TreeNode root){ Queue<Tre

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。 你可以假设数组是非空的，并且给定的数组总是存在多数元素。 示例 1： 输入：[3,2,3] 输出：3 示例 2： 输入：[2,2,1,1,1,2,2] 输出：2 思路：1哈希表 1、统计出每个元素出现的次数 2、遍历找出元素最多的 class Solution { private Map<Integer, Integer> countNums(int[] nums) {

问题：实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。不得使用库函数，同时不需要考虑大数问题。 思路： 递归是比较好理解的 如果n == 0，返回1 如果n < 0 如果n为奇数 如果n为偶数 class Solution { public double myPow(double x, int n) { //递归的思想递归分治的思想是比较好理解的 if(n == 0){ return 1; }else if

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” 输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出：3 解释：节点 5 和节点 1 的最近公共祖先是节点 3 。 输入：root = [3,5,1,6,2,0,8,null,null,7,4],

给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例 1: 输入: 2 / \ 1 3 输出: true 示例 2: 输入: 5 / \ 1 4 / \ 3 6 输出: false 解释: 输入为: [5,1,4,null,null,3,6]。 根节点的值为 5 ，但是其右

题目描述： 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。 思路： 明确栈先进后出的特点，队列先进先出的特点， 先把元素存放在一个栈内，然后再依次出栈存放到另一个栈内，最后再依次出栈，即实现队列的先进先出特点。 import java.util.Stack; public class Solution { Stack<Integer> stack1 = new Stack<Integer>(); Stack<Integer

题目描述 有一个整数数组，请你根据快速排序的思路，找出数组中第K大的数。 给定一个整数数组a,同时给定它的大小n和要找的K(K在1到n之间)，请返回第K大的数，保证答案存在。 示例1 输入 [1,3,5,2,2],5,3 返回值 2 import java.util.*; public class Finder { public int findKth(int[] a, int n, int K) { // write code here //思想：快排+二分法利

题目描述 给出一个仅包含字符'(',')','{','}','['和']',的字符串，判断给出的字符串是否是合法的括号序列 括号必须以正确的顺序关闭，"()"和"()[]{}"都是合法的括号序列，但"(]"和"([)]"不合法。 示例1 输入"[" 返回值 false 示例2 输入"[]" 返回值true **import java.util.*; public class Solution { /** * * @param s string字符串 * @r

题目描述 对于一个给定的链表，返回环的入口节点，如果没有环，返回null 拓展： 你能给出不利用额外空间的解法么？ 说明：本题目包含复杂数据结构ListNode，点此查看相关信息 https://blog.nowcoder.net/n/954373f213e14eeab0a69ed0e9ef1b6e class ListNode{ int val; ListNode next; ListNode(int x){ val=x; next=null } } /** * Definitio

题目描述 实现函数 int sqrt(int x). 计算并返回x的平方根 import java.util.*; public class Solution { /** * * @param x int整型 * @return int整型 */ public int sqrt (int x) { // write code here //思想： 如果一个数i,i*i小于n 并且（i+1）*(i+1)>n那么这个数

题目描述: 写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000） 示例1 输入"abcd" 返回值"dcba" import java.util.*; public class Solution { /** * 反转字符串 * @param str string字符串 * @return string字符串 */ public String solve (String str) { // wri

题目描述 将两个有序的链表合并为一个新链表，要求新的链表是通过拼接两个链表的节点来生成的。 示例1 输入{1},{} 返回值{1} 示例2 输入{1},{1} 返回值{1,1} import java.util.*; /* * public class ListNode { * int val; * ListNode next = null; * } */ public class Solution { /** * * @param l1 ListNod

递归是一种非常重要的算法思想，无论你是前端开发，还是后端开发，都需要掌握它。在日常工作中，统计文件夹大小，解析xml文件等等，都需要用到递归算法。它太基础太重要了，这也是为什么面试的时候，面试官经常让我们手写递归算法。本文呢，将跟大家一起深入挖掘一下递归算法~ ◦什么是递归？ ◦递归的特点 ◦递归与栈的关系 ◦递归应用场景 ◦递归解题思路 ◦leetcode案例分析 ◦递归可能存在的问题以及解决方案 什么是递归？ 递归，在计算机科学中是指一种通过重复将问题分解为同类的子问题而解决问题的方法。简单来说，递归表

题目描述 一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。 示例1: 输入1 返回值1 示例2: 输入4 返回值5 思想： 经典递归问题 思路：跳n级台阶相当于n-1和n-2级台阶的和 原因：n级台阶就相当于n-1级再跳一次一阶的和n-2级再跳一次2阶的 public class Solution { public int JumpFloor(int n) { if (n == 1) return 1;

1.基本思想： 归并排序（Merging Sort）就是利用归并的思想实现的排序算法，他的原理是假设初始序列含有 n个记录，则可以看成n个有序的子序列，每个子序列的长度为1 然后两两归并，得到【n/2】个长度为2或者1的子序列； 再两两归并，…，如此重复，直至得到一个长度为n的有序序列为止 2.图形演示 3.代码 /*将SR[s...t]归并排序为TR1[s..t]*/ void MSort(int SR[],int TR1[],int s,int t) { int m; int

1.基本思想： 堆排序（Head sort）就是利用堆（假设利用大顶堆）进行排序的方法。他的基本思想如下： 将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根结点，将他移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩余的n-1 个序列重新够造成一个堆，这样就会得到n个元素中的值，如此反复便会得到一个有序序列。 问题： 1、如何由一个无序序列构建一个大顶堆？ 2、如果在输出堆顶元素后，调整剩余元素成为一个新的堆。 2、代码演示 /*对顺序表L进行堆排序*/ voi

1、简介： 希尔排序（Shell Sort）:希尔排序是D.L.Shell于1959年提出来的一种排序算法，在这之前的排序算法的时间复杂度都是O(n2)的，希尔排序是突破这个时间复杂度的第一批算法之一。 2、基本思想： 采取跳跃分割的策略，将相距某个“”增量“”的记录组成一个子序列，这样才能保证在子序列内分别进行直接插入排序后得到的结果是基本有序的而不是局部有序 3、图像演示： 4.代码： void shellSort(int arr[],int n) {

一：快速排序思想： 通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录进行排序，已达到整个序列有序的目的 首先会在序列中随机选择一个基准值（pivot），然后将除了基准值以外的数分 为“比基准值小的数”和“比基准值大的数”这两个类别 [ 比基准值小的数 ] 基准值 [ 比基准值大的数 ] 二：代码： void quickSort(int arr[],int low,int high) { int temp;

题目描述 给出两个有序的整数数组A 和B ，请将数组 B合并到数组 A中，变成一个有序的数组 注意： 可以假设 A数组有足够的空间存放B 数组的元素， A和 B中初始的元素数目分别为m 和 n public class Solution{ public void merge(int A[],int m, int B[], int n ){ //思想： 采用归并的思路 int[] result=new int[m+n]; int t=0; int i=0, j=

题目描述 给定一个链表，删除链表的倒数第n个节点并返回链表的头指针 例如， 给出的链表为:1->2->3->4->5, n= 2. 删除了链表的倒数第n个节点之后,链表变为1->2->3->5. 备注： 题目保证n一定是有效的 请给出请给出时间复杂度为\ O(n) O(n)的算法 示例1 输入 复制 {1,2},2 输出 复制 {2} import java.util.*; /* * public class ListNode { * int val;

折半查找是从中间分，也就是说每一次查找总是一分为二，无论数据大小，很多时候这并不是最合理的做法。 斐波那契查找（Fibonacci Search）,利用黄金分割的思想 #include<stdio.h> int Fibonacci_search(int *a,int n,int key ) { int low ,high, i,k; low=1;//定义最低下标为首位 high=n;//定义最高下标为记录末位 k=0; while(n>F[k]-1)//计算

题目描述 分别按照二叉树先序，中序和后序打印所有的节点。 示例1 输入 {1,2,3} 输出 [[1,2,3],[2,1,3],[2,3,1]] Java代码实现 public class TreeNode { int data=0; //结点数据 TreeNode left=null;//结点左子树 TreeNode right=null;//结点右子树 } public class TestOrder { //建三个ArrayList分别存储三种遍历的结果

二叉树的遍历： 一：最常见的遍历种类 先序遍历 中序遍历 后序遍历 层次遍历 二：遍历的递归代码实现分别给出Java 代码和C代码实现 //Java代码实现 //二叉树的定义 * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } * //前序遍历 public void preOrder(TreeNode root){ if (r

题目描述 判断给定的链表中是否有环 扩展： 你能给出空间复杂度的解法么？ 解题思路： 此题主要考察快慢指针， 快指针走两步，慢指针走一步，若链表存在环，则指针必相遇 终止条件null; 下面分别给出java 和C代码 /** * Definition for singly-linked list. * class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x;

题目：输入一个链表，反转链表后，输出新链表的表头。 思想： 1. 题目中所给的是单链表，想一想 反转后的样子：最后一个结点指向倒数第二个，倒数第二个指向倒数第三个，…第一个指向Null 2.知道了反转后各个结点指向哪之后，就需要开始调整每个结点的next 指针 3.这就需要把结点挨个从链表上摘下来，做调整； 4.需要两个指针 pre 记录其前一个结点的位置，好让该节点的next指针指向前一个结点，但是在指向前一个结点前 需要用一个指针P记录后一个结点的位置， 注意 null； /*public cla

二分查找 算法 题目： 请实现有重复数字的有序数组的二分查找。 输出在数组中第一个大于等于查找值的位置，如果数组中不存在这样的数，则输出数组长度加一。 示例1 输入 5,4,[1,2,4,4,5] 输出 3 思想：二分查找法 首先要 定义 两个指针 标记左右，然后用mid所指的位置与关键字比较。若小于关键字，则在其右侧继续二分查找，若大于等于关键字，且其左临元素也大于等于改关键字，则继续在mid的左侧二分查找，否则输出mid+1,若遍历后不存在这样的值，输出n+1。 public class Soluti