- 博客(27)
- 收藏
- 关注
RSS订阅原创 5.买卖股票的最佳时机
5.买卖股票的最佳时机 题目描述： 给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。 注意，不能在买入股票前卖出股票。 示例： 输入：[7，1，5，3，6，4] 输出：5 解释：在第2天（股票价格 = 1） 的时候买入，在第5天（股票价格 = 6）的时候卖出，最大利润 = 6-1=5。 注意：利润不能是 7-1=6，因为卖出价格需要大于买入价格；同时，不能在买入前卖出股票。 解法一：暴力求解。首先
2021-01-26 20:12:57
166
原创 4.搜索插入位置
4.搜索插入位置 题目描述： 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。可以假设数组中无重复数。 示例： 输入：[1，3，5，6]，5 输出：2 解法一：遍历数组，比较是否在数组中存在目标值，如果存在，返回当前下标，否则比较目标值与当前值的大小，判断插入的位置。 public static int returnLocation(int[] nums, int target) { int len =
2021-01-26 19:44:52
253
原创 3.移除元素
3.移除元素 题目描述： 给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于val的元素，并返回移除后数组的新长度。 示例： 给定 nums = [0，1，2，2，3，0，4，2]，val = 2 函数应该返回新的长度 5，并且 nums 中的前五个元素为 0，1，3，0，4 注意这五个元素可为任意顺序，不需要考虑数组中超出新长度后面的元素 解法一：暴力法。将数据从前往后扫描，如果出现该位置的元素值与给定的值相等，就将下一位置的元素覆盖该位置元素，向前移一位。 public
2021-01-26 19:35:30
158
原创 2.删除排序数组中的重复项
2.删除排序数组中的重复项 **题目描述：**给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。 示例： 给定数组 nums = [0，0，1，1，1，2，2，3，3，4] 函数应该返回新的长度 5，并且原数组 nums 的前5个元素被修改为 0，1，2，3，4 不需要考虑数组中超出新长度后面的元素 解法一：暴力法。将数据从前往后扫，如果下一个元素的值与当前元素值相等，将下一个元素之后的所有元素整体向前挪一位，否则取下一个元素为当前元素。 //
2021-01-26 19:23:14
239
原创 1.两数之和
1.两数之和 题目描述：给定一个整数数组 nums 和一个整数目标值 target ，请你在该数组中找出 和为目标值 的那 两个整数，并返回他们的数组下标。 可以假设每种输入只会对应一个答案，但是数组中同一个元素不能使用两遍。可以按任意顺序返回答案。 解法一：暴力解决。使用枚举法，两次循环遍历数组。时间复杂度为O(n^2)，空间复杂度为O(1) public static int[] getResult(int[] nums , int target) { int len = nums.
2021-01-19 19:28:16
116
原创 设计模式---工厂模式
2、工厂模式 1.简单工厂模式 //1、创建一个抽象产品类 abstract class Product { public abstract void product(); public void method(){ } } //2、具体实现产品A class ProductA extends Product{ public ProductA(){ System.out.println("产品A初始化!"); } @Override
2021-01-02 09:11:35
133
原创 设计模式---单例模式
1、单例模式 一个类只能有一个实例。使用场景：创建一个对象消耗太多的资源或者在一个系统中不适合创建多个对象实例的情况下，可以采用单例模式。 优点： 可以保证内存中只有一个实例，减少了内存开销 可以避免对资源的多重占用 单例模式设置全局访问点，可以优化和共享资源的访问 缺点： 单例模式一般没有接口，扩展困难，如果要扩展，必须要修改原来的代码 单例模式的功能代码一般写在一个类中，如果设计不合理，很容易违背单一职责原则 单例模式的实现： 1.懒汉式： 第一次调用方法时实例化—双重检测锁
2021-01-02 09:05:17
128
1
原创 设计模式---六大原则
设计模式的六大原则： 单一职责原则：类或接口要实现职责单一 单一职责规定了一个类应该只有一个发生变化的原因。如果一个类承担了多个职责，会导致多个职责耦合在一起，部分职责发生变化的时候可能会导致其余职责跟着受到影响。程序耦合性太强，不利于变化。 优点： 降低了类的复杂度，每一个类都有清晰明确的职责。 程序的可读性和可维护性都提高了 降低业务逻辑变化导致的风险，一个接口的修改只对相应的实现类有影响，对其他接口无影响。 里氏替换原则：使用子类代替父类，做出通用的编程 是指所有父类可以出现的地方，子类都
2021-01-02 09:03:11
154
原创 队列与栈
3.如何用栈实现队列的功能 实现思想： 两个栈，一个栈A用作队列的入口，负责插入新元素，另一个栈B用作队列的出口，负责移除元素 先对栈A进行入栈操作，顺序为1，2，3，然后出栈，顺序为3，2，1 再按照出栈的顺序3，2，1向栈B入栈，然后出栈，出队操作是从栈B中弹出元素 private Stack<Integer> stackA = new Stack<Integer>(); private Stack<Integer> stackB = new St
2021-01-02 08:57:22
124
原创 队列与栈
2.包含min函数的栈 //实现定义栈的数据结构，在该类型中实现一个能够得到栈最小元素的min函数 class DataStack{ Stack<Integer> dataStack = new Stack<Integer>();//数据栈 Stack<Integer> minStack = new Stack<Integer>();//辅助栈 Integer temp; public void push(int node) {
2021-01-02 08:55:07
128
原创 队列与栈
1.用队列实现栈 算法描述：入栈顺序：a,b,c,d 出栈顺序：d,c,b,a 设置两个队列，首先让所有元素入队A，从A队列中出队A.length-1个元素，进入到队列B，，此时A队列中剩下d，将d出栈； 然后将B队列中B.length-1个元素出队，进入到队列A，此时B队列中剩下c，将c出栈…以此类推，就可得到出栈顺序为d,c,b,a ...
2021-01-02 08:54:14
174
原创 二叉树--后序遍历
后序遍历：左右根，从叶子结点开始 //递归 public static void postOrder(TreeNode root){ if(root != null){ postOrder(root.lchild); postOrder(root.rchild); System.out.println(root.data + " "); } } //后序遍历---非递归 public List<TreeNode> postOrder(TreeNode..
2021-01-02 08:47:34
200
原创 二叉树--中序遍历
中序遍历：左根右，从与主根邻近的左树开始 //递归 public static void inOrder(TreeNode root){ if(root != null){ inOrder(root.lchild); System.out.println(root.data + " "); inOrder(root.rchild); } } //中序遍历 Stack<TreeNode> stack = new Stack<>(); Li..
2020-12-31 17:34:49
117
原创 二叉树--前序排列
前序排列：根左右，从主根开始 //递归 public static void preOrder(TreeNode root){ if(root != null){ Sysout.out.println(root.data + ""); preOrder(root.lchild); preOrder(root.rchild); } } //前序遍历---非递归 Stack<TreeNode> stack = new Stack<&
2020-12-31 17:31:56
374
原创 链表--如何在单向链表中找出第k个元素？
3.如何在单向链表中找出第k个元素？ 方法1：先把链表遍历一遍，得到链表的总长度 getLength()，得到size后，从链表的第一个开始遍历 （size-index）个，就可以得到（遍历两次） public static Node findNode(Node head,int index){ if(head.next == null){//判空 return null; } int size = getLengt
2020-12-31 17:29:52
2658
原创 链表--合并两个有序单链表
2.合并两个有序单链表 步骤：首先通过比较确定新链表的头节点，然后移动链表1或者链表2的头指针，然后通过递归来得到新的链表头节点的next指针。 public static Node mergeList(Node list1 , Node list2){ if(list1==null) return list2; if(list2==null) return list1; Node resultNode; if(list1.val&
2020-12-31 17:28:55
586
原创 链表---单链表反转
1.单链表反转 反转步骤：从头到尾遍历一遍链表，每遍历一个结点，将其放在新链表的最前端。注意链表为空和只有一个结点的情况。 public static Node reverseNode(Node head){ // 如果链表为空或只有一个节点，无需反转，直接返回原链表表头 if(head == null || head.next == null) return head; Node reHead = null; Node cur
2020-12-31 17:27:52
109
原创 二分查找算法
二分查找算法 实现步骤： 假设表中元素是按照升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功。 否则利用中间位置将表分为两部分，如果中间记录的关键字大于查找关键字，则在前面的表中进行查找，否则在后面的表中进行查找 重复上述过程，直到找到满足条件的记录，如果找不到，则查找失败。 算法前提：必须采用顺序存储结构，按照关键字大小有序排列。适用于不经常变动查找频繁的表。 实现方式：递归实现、非递归实现 /** * 二分查找算法：递归实现 * @param
2020-12-31 17:26:54
185
原创 插入排序
4.插入排序 算法描述：—先向后移，在插入，O(n^2)，稳定 从第一个元素开始，该元素可以被认为已经排序 取出下一个元素，在已经排序的元素序列中从后向前扫描 如果该元素（已排序）大于新元素，将该元素移到下一个位置 重复步骤3，直到找到已排序的元素小于或等于新元素的位置 将元素插入到该位置后，重复2~5 //插入排序 public static int[] insertSort(int[] arr) { for (int i = 1; i < arr.length
2020-12-31 17:25:06
111
原创 选择排序
3.选择排序 算法描述：O(n^2)，不稳定 初始状态：无序区为R[1…n]，有序区为空。 第i趟排序（i=1，2，3…n-1）开始时，当前有序区和无序区分别是R[1,…I-1]和R[i,…n]。该趟排序从当前无序区中选出关键字最小的记录R[K]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n]分别变为记录个数增加1个的新有序区和记录个数减少一个的新无序区 //选择排序 public static int[] selectSort(int[] arr) {
2020-12-31 17:23:42
142
原创 快速排序
2.快速排序 算法描述：O(nlog2n)，不稳定 从数列中挑出一个元素，称为 “基准” ，每趟从数据序列的两端开始交替执行 分区操作：重新排列数列，比基准小的放在基准前面，比基准大的，放在基准后面，相等的则可以到任一边 递归的将小于基准元素的子数列和大于基准元素的子数列排序 //快速排序 /* 1.设置两个变量i，j，排序开始的时候i=0；j=6； 2.以第一个数组元素作为关键数据，赋值给key，即key=a[0]； 3.从j开始向前搜索，即由后开始向前搜索（
2020-12-31 17:21:59
99
原创 冒泡排序
1.冒泡排序 [外链图片 算法描述：------稳定，O(n^2) 外层控制冒泡轮数，内层进行比较 比较相邻的元素。如果第一个比第二个大，就交换它们 对每一对相邻元素做同样的操作，从最开始到最后一对，这样在元素最后应该是最大的 public static int[] getResult(int[] arr) { for (int i = 0; i < arr.length-1; i++) { int temp; boole
2020-12-31 17:19:28
108
原创 Spring的基于AspectJ的AOP开发
Spring的基于AspectJ的AOP开发 1、AspectJ简介 AspectJ是一个基于Java语言的AOP框架 使用AspectJ需要导入Spring AOP和AspectJ相关jar包 spring-aop-4.2.4.RELEASE.jar com.springsource.org.aopalliance-1.0.0.jar spring-aspects-4.2.4.RELEASE.jar com.springsource.org.aspectj.weaver-1.6.8.RELEASE.j
2020-09-29 21:23:22
190
原创 初识 Spring AOP
Spring AOP（传统AOP） 1. 什么是AOP AOP (Aspect Oriented Programing) ：面向切面编程 AOP采取横向抽取机制，取代了传统的纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存） Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期，通过代理方式向目标类织入增强代码 2. AOP相关术语 Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连
2020-09-29 21:21:51
145
原创 MyBatis进阶
MyBatis二级缓存 1. 一级缓存与二级缓存 一级缓存默认开启，缓存范围：SqlSession 会话 （范围小） 二级缓存手动开启，缓存范围：Mapper Namespace （范围大） SqlSession 生命周期短，销毁后一级缓存中的内容不存在 任意一个一级缓存需要数据时都可以在二级缓存中调用 2. 二级缓存配置 （在goods.xml中写，即书写sql语句的xml文件中） <!--开启了二级缓存 eviction是缓存的清除策略,当缓存对象数量达到上限后,自动触发对应算法对
2020-09-29 21:17:53
347
原创 Spring IOC的快速入门
Spring IOC的快速入门 开发步骤： 引入Spring的jar包 在pom.xml中 <!--引入Spring 的jar包--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>4.2.4.RELEASE</v
2020-09-22 16:57:02
165
原创 Mybatis简单开发流程
Mybatis项目顺序 1. Mybatis开发流程 1. 搭建环境，搭建数据库 先创建数据库和数据表，然后进行连接 2. 引入Mybatis依赖 在pom.xml中添加三个依赖 <dependencies> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId>
2020-09-13 16:00:53
618
1
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人