算法 on cubegao

Swift.数字在排序数组中出现的次数

Fri, 06 Oct 2017 11:03:00 +0800

题目描述：统计一个数字在排序数组中出现的次数。例如输入排序数组{1,2,3,3,3,3,4,5}和数字3，由于3在这个数组中出现了4次，因此输出4。

算法思想：如果不考虑数字会重复，那就错了。实际上就是topK的变种题，而且这个K要自己来求，实际解法是FirstK+LastK。

Swift.数组中只出现一次的数字

Tue, 02 May 2017 12:43:00 +0800

题目描述：求数组中只出现一次的数字

算法思想：这是假设数组中只出现一次的数字只有一个，那就直接异或，最后的这个数就是结果。如果只出现一次的数字有两个呢？那就先异或，得出两个数的异或结果，然后从低位向高位找第一个为1的位。然后根据这一位为1和0把数组分成两组，然后两组数分别异或，就得出最后的结果了。因为异或，不同才为1。所以找不为1的那位，也就证明两个数在那一位肯定不同，所以能把两个数分到不同的数组。

Swift.翻转单词顺序VS左旋转字符串

Sun, 12 Feb 2017 15:43:00 +0800

题目描述：题目一：输入一个英文句子，翻转句子中单词的顺序，但单词内字啊的顺序不变。为简单起见，标点符号和普通字母一样处理。题目二：字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。

算法思想：题目一：第一次整体翻转，第二次单个翻转。题目二：第一次翻转前面一段，第二次翻转后面一段，然后全部翻转。

Swift.二叉树的深度

Sun, 01 May 2016 14:28:00 +0800

题目描述：求二叉树的深度。

算法思想：递归求，每次+1，利用栈的特性。

Swift.和为S的两个数字VS和为S的连续正数序列

Wed, 06 Apr 2016 18:45:00 +0800

题目描述：题目一：输入一个递增排序的数组和一个数字 s，在数组中查找两个数，得它们的和正好是 s。如果有多对数字的和等于 s，输出任意一对即可。题目二：输入一个正数 s，打印出所有和为 s 的连续正数序列（至少两个数）。

算法思想：题目一：我们先在数组中选择两个数字，如果它们的和等于输入的 s，我们就找到了要找的两个数字。如果和小于 s 呢？我们希望两个数字的和再大一点。由于数组已经排好序了，我们可以考虑选择较小的数字后面的数字。因为排在后面的数字要大一些，那么两个数字的和也要大一些，就有可能等于输入的数字 s 了。同样，当两个数字的和大于输入的数字的时候，我们可以选择较大数字前面的数字，因为排在数组前面的数字要小一些。题目二：考虑用两个数 small 和 big 分别表示序列的最小值和最大值。首先把 small 初始化为 1，big 初始化为 2。如果从 small 到 big 的序列的和大于 s，我们可以从序列中去掉较小的值，也就是增大 small 的值。如果从 small 到 big 的序列的和小于 s，我们可以增大 big，让这个序列包含更多的数字。因为这个序列至少要有两个数字，我们一直增加 small 到(1+s)/2 为止。

Swift.两个链表的第一个公共结点

Tue, 05 Apr 2016 18:03:00 +0800

题目描述：输入两个链表，找出它们的第一个公共结点。

算法思想：先算出两个链表的长度，假如差为K，长的链表先走K步，然后两个指针一起走，如果相遇就是第一个公共节点。如果没有相遇就没有公共节点。

Swift.数组中的逆序对

Mon, 04 Apr 2016 20:29:00 +0800

题目描述：在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。即输出P%1000000007 输入描述: 题目保证输入的数组中没有的相同的数字

算法思想：很容易想到的方法就是遍历每一个元素，让其与后面的元素对比，如果大于则count++，但是这样的时间复杂度是O(n2)，因此，我们可以用归并排序思路。

Swift.第一个只出现一次的字符

Sat, 02 Apr 2016 19:59:00 +0800

题目描述：在字符串中找出第一个只出现一次的字符。如输入“abaccdeff”，则输出‘b’。

算法思想：用hashmap存，然后按顺序遍历一次，第一个等于1的就是结果。

Swift.丑数

Fri, 01 Apr 2016 14:33:00 +0800

题目描述：把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

算法思想：最简单的方法就是先通过将一个数不断除以2，3，5来判定该数是不是丑数，而后在从1开始，依次往后判断每个数是不是丑数，并记下丑数的个数，这样当计算的个数为给定值时，便是需要求的第n个丑数，这种方法的时间复杂度为O（k），这里的k为第n个丑数的大小，比如第1500个丑数的大小为859963392，那么就需要判断859963392次，时间效率非常低。直观的优化措施就是看能不能将时间复杂度降低到O（n），即只在丑数上花时间，而不在非丑数上浪费时间。剑指offer上给的思路很好，用O（n）的辅助空间来得到O(n)的时间复杂度。其核心思想是：每一个丑数必然是由之前的某个丑数与2，3或5的乘积得到的，这样下一个丑数就用之前的丑数分别乘以2，3，5，找出这三这种最小的并且大于当前最大丑数的值，即为下一个要求的丑数。

Swift.把数组排成最小的数

Fri, 11 Mar 2016 12:43:00 +0800

题目描述：输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

算法思路：数组中所有的数拼接后有可能会超过整数的范围，因此本题必须要使用字符串来处理。要对3，32 ，321 排序，不能直接比较32，3的大小，应该比较323，332的大小，即，3，32的大小应该有323，332的大小来确定。因此3比32大，3应该在32后面，32和321比较时，32321>32132,因此32>321,32在321后面，3，32，321由小到大排序为，321，32，3，组成的最小数为：321323

Swift.从1到N整数中1出现的次数

Wed, 02 Mar 2016 12:55:00 +0800

题目描述：求出1 ~ 13的整数中1出现的次数,并算出100 ~ 1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数。

算法思想：1.常规思路（暴力解决），一个数一个数的计数 2.寻找数学规律

Swift.连续子数组的最大和

Tue, 01 Mar 2016 18:22:00 +0800

题目描述：HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。你会不会被他忽悠住？(子向量的长度至少是1)

算法思想：第一种解法比较常规，第二种解法比较巧妙。每次比较当前和之前的值大小，然后存最大的值。

Swift.数组中出现次数超过一半的数字

Mon, 01 Feb 2016 12:55:00 +0800

题目描述：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

算法思想：某个数字出现的次数大于数组长度的一半，意思就是它出现的次数比其他所有数字出现的次数和还要多。因此我们可以在遍历数组的时候记录两个值：1. 数组中的数字;2. 次数。遍历下一个数字时，若它与之前保存的数字相同，则次数加1，否则次数减1；若次数为0，则保存下一个数字，并将次数置为1。遍历结束后，所保存的数字即为所求。最后再判断它是否符合条件。

Swift.字符串的排序

Fri, 22 Jan 2016 13:33:00 +0800

题目描述：输入一个字符串,按字典序打印出该字符串中字符的所有排列例如输入字符串abc, 则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。结果请按字母顺序输出。

算法思想：首先，求所有可能出现在第一个位置的字符，其次，把第一个字符和其后面的字符一一交换。如下图所示，分别把第一个字符a和后面的b、c等字符交换的情形。接着，固定第一个字符，求后面所有字符的排列。这个时候我们仍把后面的所有字符分成两部分：后面字符的第一个字符，以及这个字符之后的所有字符。然后把第一个字符逐一和它后面的字符交换

Swift.二叉搜索树与双向链表

Fri, 11 Dec 2015 12:11:00 +0800

题目描述：输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

算法思想：在二叉搜索树中，左子结点的值总是小于父结点的值，右子节点的值总是大于父结点的值。因此我们在转换成排序双向链表时，原先指向左子结点的指针调整为链表中指向前一个结点的指针，原先指向右子节点的指针调整为链表中指向后一个结点的指针。因为中序遍历是按照从小到大的顺序遍历二叉搜索树，所以我们用中序遍历树中的每一个节点得到的正好是要求的排好序的。遍历过程如下：每次遍历节点的左孩子、右孩子，把左孩子指向转换链表的尾节点，并把末尾指针的右孩子指向自己。右孩子指向节点的右孩子。如果没有右孩子就返回。这一过程可以用递归实现。

Swift.复杂链表的复制

Sun, 11 Oct 2015 13:44:00 +0800

题目描述：输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点）。要求编写函数复制这个复杂链表。

算法思想：思想是在原来的链表每个节点后面都复制了一个同样的节点，再修改其指针，最后把偶数节点都抽出来，作为新的复杂链表。

Swift.二叉树中和为某一值的路径

Wed, 07 Oct 2015 12:33:00 +0800

题目描述：输入一棵二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

算法思想：由于路径是从根结点出发到叶结点，也就是说路径总是以根结点为起始点，因此我们首先需要遍历根结点。在树的前序、中序、后序三种遍历方式中，只有前序遍历是首先访问根结点的。

Swift.不用加减乘除做加法

Wed, 05 Aug 2015 13:59:00 +0800

题目描述：写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。

算法思想：位运算模拟加法。

Swift.二叉搜索树的后序遍历序列

Tue, 14 Jul 2015 21:02:00 +0800

题目描述：输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回true，否则返回false。假设输入的数组的任意两个数字都互不相同。

算法思想：通过举例子分析，寻找规律，先判断根结点的整颗树是否满足二叉搜索树左小右大的规律，再判断各个子树是否同样满足这种规律。子问题和问题本身是等价的，所以使用递归即可实现子树的判断。

Swift.从上往下打印二叉树

Mon, 13 Jul 2015 19:22:00 +0800

题目描述：从上往下打印出二叉树的每个节点，同层节点从左至右打印。

算法思想：题目实际上就是二叉树的层序遍历，如上图，我们借助队列来存储节点来实现层序遍历的效果，具体操作：

Swift.栈的压入、弹出序列

Sun, 12 Jul 2015 23:44:00 +0800

题目描述：输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

算法思想：如果第二个序列中当前要判断的元素刚好与栈顶元素相等，则直接pop出来，如果不等，则将第一个序列的后面还没有入栈的元素入栈，直到将与之相等的元素入栈为止，如果第一个序列的所有的元素都入栈了，还没有找到与之相等的元素，则说明第二个序列不是第一个序列的弹出序列，

Swift.包含min函数的栈

Sun, 12 Jul 2015 23:00:00 +0800

题目描述：定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

算法思想：利用数组模拟一个栈。

Swift.顺时针打印矩阵

Sat, 11 Jul 2015 22:35:00 +0800

题目描述：输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

算法思想：先得到矩阵的行和列数，然后依次旋转打印数据，一次旋转打印结束后，往对角分别前进和后退一个单位。

Swift.二叉树的镜像

Fri, 10 Jul 2015 18:59:00 +0800

题目描述：操作给定的二叉树，将其变换为源二叉树的镜像。

算法思想：递归，利用栈结构。交换左右孩子，然后递归访问左右孩子。

Swift.树的子结构

Fri, 10 Jul 2015 11:23:00 +0800

题目描述：输入两颗二叉树A，B，判断B是不是A的子结构。

算法思想：遍历到最后，节点为空那就是子结构，相反不是。

Swift.合并两个排序的链表

Thu, 09 Jul 2015 16:44:00 +0800

题目描述：

算法思想：有点类似合并两个排序数组。递归的话，相对好理解一点。

Swift.链表中倒数第K个节点

Wed, 08 Jul 2015 22:11:00 +0800

题目描述：链表中倒数第 K 个结点。

算法思想：设链表的长度为 N。设置两个指针 P1 和 P2，先让 P1 移动 K 个节点，则还有 N - K 个节点可以移动。此时让 P1 和 P2 同时移动，可以知道当 P1 移动到链表结尾时，P2 移动到第 N - K 个节点处，该位置就是倒数第 K 个节点。

Swift.反转链表

Wed, 08 Jul 2015 22:01:00 +0800

题目描述：1->2->3->4，4->3->2->1

算法思想：迭代的话，使用使用头插法。

Swift.调整数组顺序使奇数位于偶数前面

Wed, 08 Jul 2015 16:15:00 +0800

题目描述：调整数组顺序使奇数位于偶数前面。

算法思想：两个指针一个从头一个尾，然后奇数偶数交换位置。

Swift.在0(1)时间删除链表节点

Tue, 07 Jul 2015 18:12:00 +0800

题目描述：在 O(1) 时间内删除链表节点

算法思想：① 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 O(1)。 ② 否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向 null，时间复杂度为 O(N)。

Swift.打印1到最大的n位数

Tue, 07 Jul 2015 12:33:00 +0800

题目描述：输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数即 999。

算法思想：由于 n 可能会非常大，因此不能直接用 int 表示数字，而是用 char 数组进行存储。使用回溯法得到所有的数。

Swift.数值的整数次方

Tue, 07 Jul 2015 12:13:00 +0800

题目描述：给定一个 double 类型的浮点数 base 和 int 类型的整数 exponent，求 base 的 exponent 次方。

算法思想： /**

Swift.求1+2+...+n

Mon, 06 Jul 2015 23:43:00 +0800

题目描述：求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

算法思想：累加不能用循环的话，那就试试递归吧。

Swift.二进制中1的个数

Sun, 05 Jul 2015 21:00:00 +0800

题目描述：输入一个整数，输出该数二进制表示中 1 的个数。

算法思想：n&(n-1),该位运算去除 n 的位级表示中最低的那一位。

Swift.斐波那契额数列

Sat, 04 Jul 2015 20:11:00 +0800

题目描述：求斐波那契数列的第 n 项。

算法思想：如果使用递归求解，会重复计算一些子问题。例如，计算 f(4) 需要计算 f(3) 和 f(2)，计算 f(3) 需要计算 f(2) 和 f(1)，可以看到 f(2) 被重复计算了。递归是将一个问题划分成多个子问题求解，动态规划也是如此，但是动态规划会把子问题的解缓存起来，从而避免重复求解子问题。

Swift.旋转数组的最小数字

Fri, 03 Jul 2015 18:33:00 +0800

题目描述：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。

算法思想：将旋转数组对半分可以得到一个包含最小元素的新旋转数组，以及一个非递减排序的数组。新的旋转数组的数组元素是原数组的一半，从而将问题规模减少了一半，这种折半性质的算法的时间复杂度为 O(logN) 此时问题的关键在于确定对半分得到的两个数组哪一个是旋转数组，哪一个是非递减数组。我们很容易知道非递减数组的第一个元素一定小于等于最后一个元素。

Swift.重建二叉树

Thu, 02 Jul 2015 14:20:00 +0800

题目描述：根据二叉树的前序遍历和中序遍历的结果，重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

算法思想：前序遍历的第一个值为根节点的值，使用这个值将中序遍历结果分成两部分，左部分为树的左子树中序遍历结果，右部分为树的右子树中序遍历的结果。然后分别对左右子树递归地求解。

Swift.从尾到头打印链表

Wed, 01 Jul 2015 19:22:00 +0800

题目描述：输入一个链表，从尾到头打印链表每个节点的值。

算法思想：采用递归的解法，利用栈的原理。

Swift.n个骰子的点数

Wed, 24 Jun 2015 21:59:00 +0800

题目描述：把 n 个骰子扔在地上，所有骰子朝上一面的点数之和为 s。输入 n，打印出 s 的所有可能的值出现的概率。

算法思想：动态规划求解，每次都算出可能存在的所有点数。

Swift.树中两个节点的最低公共祖先

Mon, 08 Jun 2015 18:34:00 +0800

题目描述：求树中两个结点的最低公共祖先，此树不是二叉树，并且没有指向父节点的指针。

算法思想：假设是二叉树做的。还要优化。

Swift.扑克牌的顺子

Mon, 08 Jun 2015 12:32:00 +0800

题目描述：从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。2～10为数字本身， A为1。 J为11、Q为12、为13。小王可以看成任意数字。

算法思想：首先把数组排序，再统计数组中0 的个数，最后统计排序之后的数组中相邻数字之间的空缺总数。如果空缺的总数小于或者等于0 的个数，那么这个数组就是连续的：反之则不连续。

Swift.把字符串转换成整数

Thu, 04 Jun 2015 13:56:00 +0800

题目描述：将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。

github地址：https://github.com/cubegao/LeetCode

Swift.二叉树的中序遍历

Sun, 24 May 2015 19:18:00 +0800

算法思想：中序遍历：左子树—> 根结点 —> 右子树

Swift.二叉树的前序遍历

Sun, 24 May 2015 12:23:00 +0800

算法思想：前序遍历：根结点 —> 左子树 —> 右子树

Swift.选择排序

Sat, 23 May 2015 19:22:00 +0800

算法思想：每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止，简单选择排序是不稳定排序。

Swift.快速排序

Fri, 22 May 2015 19:19:00 +0800

算法思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。