1.二维数组中查找
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
public static boolean search_mat(int[][] list, int target) {
boolean res = false;
int col = list[0].length-1;
int row = 0;
while (col >= 0 && row< list.length) {
if (list[row][col] == target) {
res = true;
break;
} else {
if (list[row][col] < target) {
row++;
} else {
col--;
}
}
}
return res;
}
2.替换空格
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
思路
如果是在原字符串操作，从前往后遍历则会出现，后面的字符移动多次的情况。从后往前则每个字符只移动一次。
如果是在新字符串操作，则无所谓。
public static String tihuan(StringBuffer s) {
if(s==null||s.length()==0)
return null;
int len = s.length();
int count=0;
for(int i=0;i<len;i++) {
if(s.charAt(i)==' ')
count++;
}
int newLen = len+count*2;
int index = newLen-1;
s.setLength(newLen);
for(int i=len-1;i>=0;i--) {
if(s.charAt(i)==' ') {
s.setCharAt(index--, '0');
s.setCharAt(index--, '2');
s.setCharAt(index--, '%');
}else {
s.setCharAt(index--, s.charAt(i));
}
}
return s.toString();
}
public static String tihuana(StringBuffer s) {
if(s==null||s.length()==0)
return null;
int len = s.length();
int count=0;
for(int i=0;i<len;i++) {
if(s.charAt(i)==' ')
count++;
}
int newLen = len+count*2;
char [] cs = new char[newLen];
int index = newLen-1;
for(int i=len-1;i>=0;i--) {
if(s.charAt(i)==' ') {
cs[index--]='0';
cs[index--]='2';
cs[index--]='%';
}else {
cs[index--]=s.charAt(i);
}
}
return new String(cs);
}
3.从尾到头打印链表
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
Stack <ListNode> s=new Stack<>();
while(listNode!=null){
s.push(listNode);
listNode=listNode.next;
}
ArrayList<Integer> list=new ArrayList<>();
while(!s.empty()){
list.add(s.pop().val);
}
return list;
}
}
4.重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
遍历递归
因为前序的第一个元素会把中序分割成左子树和右子树
/**
* Definition for binary tree public class TreeNode { int val; TreeNode left;
* TreeNode right; TreeNode(int x) { val = x; } }
*/
public class Solution {
private TreeNode reBuildTree(int[] pre, int startPre, int endPre, int[] in, int startIn, int endIn) {
if (startPre > endPre || startIn > endIn)
return null;
TreeNode root = new TreeNode(pre[startPre]);
for (int i = startIn; i <= endIn; i++) {
if (in[i] == pre[startPre]) {
root.left = reBuildTree(pre, startPre + 1, startPre + i - startIn, in, startIn, i - 1);
root.right = reBuildTree(pre, startPre + i - startIn + 1, endPre, in, i + 1, endIn);
}
}
return root;
}
public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
TreeNode root = reBuildTree(pre, 0, pre.length - 1, in, 0, in.length - 1);
return root;
}
}
5.两个栈实现队列
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
import java.util.Stack;
public class Solution {
Stack<Integer> stack1 = new Stack<Integer>();
Stack<Integer> stack2 = new Stack<Integer>();
public void push(int node) {
stack1.push(node);
}
public int pop() {
if (stack2.empty()) {
while (!stack1.empty()) {
stack2.push(stack1.pop());
}
}
return stack2.pop();
}
}
6.旋转数组的最小数字
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
import java.util.ArrayList;
public class Solution {
public int minNumberInRotateArray(int [] array) {
if(array.length==0)
return 0;
int left =0;
int right =array.length-1;
int mid;
while(left<right){
mid = (left+right)/2;
if(array[mid]>array[right]){
left = mid+1;
}else if(array[mid]==array[right])
right=right-1;
else right = mid;
}
return array[left];
}
}
7.斐波那契数列
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39
public class Solution {
public int Fibonacci(int n) {
int f1 = 1;
int f2 = 1;
int res =0;
if(n<=0)
return 0;
if(n==1||n==2)
return 1;
for(int i=3;i<=n;i++) {
res = f1+f2;
f1=f2;
f2=res;
}
return res;
}
}
8.跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
public class Solution {
public int JumpFloor(int target) {
int f1 = 1;
int f2 = 2;
int res =0;
if(target<=0)
return 0;
if(target<3)
return target;
for(int i=3;i<=target;i++) {
res = f1+f2;
f1=f2;
f2=res;
}
return res;
}
}
9.变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
因为n级台阶，第一步有n种跳法：跳1级、跳2级、到跳n级
跳1级，剩下n-1级，则剩下跳法是f(n-1)
跳2级，剩下n-2级，则剩下跳法是f(n-2)
所以f(n)=f(n-1)+f(n-2)+…+f(1)
因为f(n-1)=f(n-2)+f(n-3)+…+f(1)
所以f(n)=2*f(n-1)
public class Solution {
public int JumpFloorII(int target) {
int res =1;
if(target<=0)
return 0;
for(int i=1;i<target;i++){
res = res*2;
}
return res;
}
}
10.矩形覆盖
我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
class Solution {
public:
int rectCover(int number) {
int f1 = 1;
int f2 = 2;
int res =0;
if(number<=0)
return 0;
if(number<3)
return number;
for(int i=3;i<=number;i++){
res = f1+f2;
f1=f2;
f2=res;
}
return res;
}
};
11.二进制中1的个数
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
public class Solution {
public int NumberOf1(int n) {
int count=0;
while(n!=0){
n=n&(n-1);
count++;
}
return count;
}
}
12.
13.调整数组顺序使奇数位于偶数前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
public class Solution {
public void reOrderArray(int [] array) {
int len = array.length-1;
for(int i=0;i<len;i++){
for(int j =0;j<len-i;j++){
if(array[j]%2==0 && array[j+1]%2==1) {
int tmp = array[j];
array[j]=array[j+1];
array[j+1]=tmp;
}
}
}
}
}
快排part思想：顺序改变；
首尾指针分别向中间靠拢，如果尾指针遇到偶数则向中间靠拢，如果遇到基数则首指针指向元素改为当前元素，同理首指针遍历直到遇到偶数元素，尾指针改为当前元素。
public static void sw(int[] arr) {
int len = arr.length;
int left=0,right=len-1;
int index = arr[left];
while(left<right) {
while(left<right&&arr[right]%2==0)
right--;
arr[left]=arr[right];
while(left<right&&arr[left]%2==1)
left++;
arr[right]=arr[left];
}
arr[left]=index;
}
14.链表中倒数第k个结点
输入一个链表，输出该链表中倒数第k个结点。
public class Solution {
public ListNode FindKthToTail(ListNode head,int k) {
if(head==null||k<=0)
return null;
ListNode pre=head;
for(int i=0;i<k;i++){
if(pre==null)
return null;
pre=pre.next;
}
ListNode last=head;
while(pre!=null){
pre=pre.next;
last=last.next;
}
return last;
}
}
15.反转链表
public class Solution {
public ListNode ReverseList(ListNode head) {
if(head == null)
return null;
ListNode pre = head;
ListNode cur = null;
while(pre!=null) {
ListNode next = pre.next;
pre.next=cur;
cur=pre;
pre=next;
}
return cur;
}
}
16.合并两个排序的链表
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
思路：最简单方式，先考虑两个链表都不为空，迭代判断两个链表，新链表每个节点指向小的；
当一个链表为空时，新链表指向另个链表即可
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode res = new ListNode(-1);
ListNode cur = res;
while (l1 != null && l2 != null) {
// cur.next = l1.val>=l2.val ? l2:l1;
if (l1.val >= l2.val) {
cur.next = l2;
l2 = l2.next;
} else {
cur.next = l1;
l1 = l1.next;
}
cur = cur.next;
}
cur.next = l1==null?l2:l1;
return res.next;
}
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
if(list1 == null)
return list2;
if(list2 == null)
return list1;
ListNode node = null;
if(list1.val<list2.val) {
node = list1;
node.next = Merge(list1.next,list2);
}
else {
node = list2;
node.next = Merge(list1,list2.next);
}
return node;
}
}
public ListNode Merge(ListNode list1,ListNode list2) {
if(list1 == null)
return list2;
if(list2 == null)
return list1;
ListNode node = null;
if(list1.val<list2.val) {
node.next=list1;
list1=list1.next;
}else {
node.next=list2;
list2=list2.next;
}
while(list1!=null&&list2!=null) {
if(list1.val<list2.val) {
node.next=list1;
list1=list1.next;
node = node.next;
}else {
node.next=list2;
list2=list2.next;
node = node.next;
}
}
}
17.树的子结构
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
设计递归结构：
外递归: 找到与root2值相同的节点，目的是找到进行比较的节点；
递归跳出条件：某个根节点递归到叶子；
如果两个根节点值相同，则进入内递归判断是否为子结构；
如果不是，则对root1递归，找到与root2值相同的节点；
内递归：对两颗树，每个节点进行递归比较，主要判断找到的节点为根与第二颗树是否相同；
递归跳出条件：1.root2为null，说明是相同结构，返回true；2.root1为null，说明树1中没有树2结构，返回false；3.root1 val！=root2 val，说明结构不相同，返回false；
public class Solution {
public boolean HasSubtree(TreeNode root1,TreeNode root2) {
boolean res=false;
if(root1==null || root2 == null)
return false;
if(root1.val==root2.val)
res = hasTree(root1,root2);
if(!res)
res = HasSubtree(root1.left,root2);
if(!res)
res = HasSubtree(root1.right,root2);
return res;
}
public static boolean hasTree(TreeNode root1,TreeNode root2) {
if(root2==null)
return true;
if(root1==null)
return false;
if(root1.val!=root2.val)
return false;
return hasTree(root1.left,root2.left)&&hasTree(root1.right,root2.right);
}
}
18.二叉树的镜像
设计递归：
递归跳出条件:1.root为null；2.root为叶子节点；
递归 ：交换root的左子和右子；
如果左子不为空，向左遍历；
右子同理；
public class Solution {
public void Mirror(TreeNode root) {
if (root == null)
return;
if (root.left == null && root.right==null) {
return;
}
TreeNode tmp = root.left;
root.left = root.right;
root.right = tmp;
if(root.left!=null)
Mirror(root.left);
if(root.right!=null)
Mirror(root.right);
}
}
import java.util.Stack;
public class Solution {
public void Mirror(TreeNode root) {
if (root == null)
return;
Stack <TreeNode> st = new Stack<>();
st.push(root);
while(!st.empty()) {
TreeNode cur = st.pop();
TreeNode tmp = cur.left;
cur.left = cur.right;
cur.right = tmp;
if(cur.left!=null)
st.push(cur.left);
if(cur.right!=null)
st.push(cur.right);
}
}
}
19.顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 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.
20.包含min函数的栈
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
21.栈的压入、弹出序列
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
public boolean IsPopOrder(int [] pushA,int [] popA) {
if(pushA==null||popA==null||pushA.length<=0||popA.length<=0)
return false;
int index=0;
Stack <Integer> s=new Stack<>();
for(int i=0;i<pushA.length;i++){
s.push(pushA[i]);
while(!s.empty()){
if(s.peek()!=popA[index])
break;
s.pop();
index++;
}
}
return s.isEmpty();
}
}
22.从上往下打印二叉树
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
思路：二叉树的层序遍历，用队列实现
public class Solution {
public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
Queue<TreeNode> qu = new LinkedList<>();
ArrayList<Integer> res = new ArrayList<>();
if(root == null)
return res;
qu.offer(root);
while(qu.size()!=0){
TreeNode cur = qu.poll();
res.add(cur.val);
if(cur.left!=null)
qu.offer(cur.left);
if(cur.right!=null)
qu.offer(cur.right);
}
return res;
}
}
23.二叉搜索树的后序遍历序列
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
思路：二叉搜索树的左分支比根小，右分支比根大。
如果是后序遍历，根节点在最后，则数组前部分为比根小，后部分比根大。
从后往前遍历，是否都满足该规则，不满足则false。
public class Solution {
public boolean VerifySquenceOfBST(int [] sequence) {
if(sequence==null||sequence.length<=0)
return false;
int len = sequence.length;
while(--len>0){
int i=0;
while(sequence[i]<sequence[len])
i++;
while(sequence[i]>sequence[len])
i++;
if(i!=len)
return false;
}
return true;
}
}
24.二叉树中和为某一值的路径
输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)
思路：递归实现。对树进行遍历，如果满足条件则加入结果。
递归返回条件为叶子节点。
递归设计：dfs
跳出条件：节点为空；
public class Solution {
private ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
private ArrayList<Integer> list = new ArrayList<>();
public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
if(root == null)
return res;
list.add(root.val);
target-=root.val;
if(target==0 && root.left==null&&root.right==null)
res.add(new ArrayList(list));
if(root.left!=null)
FindPath(root.left,target);
if(root.right!=null)
FindPath(root.right,target);
list.remove(list.size()-1);
return res;
}
}
25.复杂链表的复制
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
思路：三步：
1.原链表每个节点都复制一个接在原节点的后面；
2.复制每个节点的random指针；
3.拆成两个链表
public class Solution {
public RandomListNode Clone(RandomListNode pHead)
{
if(pHead == null)
return null;
RandomListNode cur = pHead;
while(cur!=null) {
RandomListNode clone = new RandomListNode(cur.label);
RandomListNode next = cur.next;
cur.next = clone;
clone.next = next;
cur = next;
}
cur = pHead;
while(cur!=null) {
cur.next.random = cur.random == null ? null:cur.random.next;
cur = cur.next.next;
}
cur = pHead;
RandomListNode newHead = pHead.next;
while(cur!=null) {
RandomListNode clone = cur.next;
cur.next = clone.next;
clone.next = clone.next==null ? null:clone.next.next;
cur = cur.next;
}
return newHead;
}
}
26.二叉搜索树与双向链表
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
27.字符串的排列
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
思路：!!!
递归+回溯 实现
递归就是某一个状态遇到return结束了之后，会回到被调用的地方继续执行
设计递归：
跳出条件：如果begin为最后一个元素；
回溯思想：首先swap00；
然后swap11，此时，begin+1为2，则跳出递归，return后跳回4状态，向下执行swap11,返回1状态；
i+1,此时begin=1，i为2，swap1,2，产生acb，进入递归，begin+1=2，则跳出递归，跳出后执行swap1,2，状态回到1；
public static ArrayList<String> pL(String s)
{
ArrayList<String> res = new ArrayList<String>();
char [] ch = s.toCharArray();
paLie(ch,0,res);
Collections.sort(res);
for(String i : res)
System.out.println(i);
return res;
}
public static void paLie(char[] ch,int begin, ArrayList<String> res) {
int len = ch.length;
if(begin==len-1) {
String str = new String(ch);
if(!res.contains(str)) {
res.add(str);
}
return;
}
for(int i=begin;i<len;i++) {
swap(ch,begin,i);
paLie(ch,begin+1,res);
swap(ch,begin,i);
}
}
public static void swap(char[] ch, int begin, int end) {
char tmp = ch[begin];
ch[begin] = ch[end];
ch[end] = tmp;
}
public class Solution {
public ArrayList<String> Permutation(String str) {
ArrayList<String> res = new ArrayList<String>();
if(str!=null&&str.length()>0){
PerHeaper(str.toCharArray(),0,res);
Collections.sort(res);
}
return res;
}
private void PerHeaper(char[] chars,int i,ArrayList<String> res){
if(i==chars.length){
res.add(String.valueOf(chars));
return;
}
Set<Character> charSet= new HashSet<Character>();
for(int j=i;j<chars.length;++j){
if(!charSet.contains(chars[j])){
charSet.add(chars[j]);
swap(chars,i,j);
PerHeaper(chars,i+1,res);
swap(chars,i,j);
}
}
}
public void swap(char[] cs,int i,int j){
char temp=cs[i];
cs[i]=cs[j];
cs[j]=temp;
}
}
28.数组中出现次数超过一半的数字
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
思路一：
出现超过一半的数一定在数组排序后的一半位置出现。
因此，先快排len/2次，找到目标数；
然后遍历一遍数组，计数是否大于一半。
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
int len=array.length;
if(len<=0)
return 0;
int mid=len/2;
int low=0;int high=len-1;
int index=part(array,low,high);
while(index!=mid){
if(index>mid){
high=index-1;
index=part(array,low,high);
}else{
low=index+1;
index=part(array,low,high);
}
}
int num=0;
int res=array[mid];
for(int i=0;i<len;i++){
if(array[i]==res)
num++;
}
if(num>mid)
return res;
else
return 0;
}
public static int part(int [] arr,int low,int high){
int index=arr[low];
while(low<high){
while(low<high&&arr[high]>=index)
high--;
arr[low]=arr[high];
while(low<high&&arr[low]<=index)
low++;
arr[high]=arr[low];
}
arr[low]=index;
return low;
}
}
思路二：
数组出现中超过一半的数，它的个数一定比其他数字加起来都多。
因此，遍历时记两个变量，一个是当前数字，一个是次数。
如果遍历到下一个数字时，数字与上一个数字相同的计数加1，否则减1.
如果计数为0，则取当前数字重新计数1.
这样最后的存储数字有两种可能，如果原数组中存在大于一半的数字，则结果一定是目标数字，如果不存在，则不一定。
因此再遍历一遍数组，计数。
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
if(array.length<=0){
return 0;
}
int result = array[0];
int times = 1;
for(int i=0;i<array.length;i++){
if(times==0){
result = array[i];
times =1;
}else if(array[i]==result)
times++;
else
times--;
}
int time = 0;
for(int i=0;i<array.length;++i){
if(array[i] == result)
time++;
}
if(time*2<array.length){
System.out.println(time);
return 0;
}else{
return result;
}
}
}
思路三：HashMap，空间换时间
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
for(int i=0;i<array.length;i++){
if(!map.containsKey(array[i])){
map.put(array[i],1);
}else{
int count = map.get(array[i]);
map.put(array[i],++count);
}
}
Iterator<Map.Entry> iter = map.entrySet().iterator();
while(iter.hasNext()){
Map.Entry entry = iter.next();
Integer key =(Integer)entry.getKey();
Integer val = (Integer)entry.getValue();
if(val>array.length/2){
return key;
}
}
return 0;
}
遍历map:
for(Map.Entry<Integer, Integer> entry:map.entrySet()) {
entry.getKey();
entry.getValue();
}
Iterator<Map.Entry<Integer,Integer>> iter = map.entrySet().iterator();
while(iter.hasNext()){
Map.Entry<Integer,Integer> entry = iter.next();
Integer key = entry.getKey();
Integer val = entry.getValue();
}
int转Integer
Java代码
int i = 0;
Integer a = new Integer(i);
Integer转int
Java代码
Integer b = new Integer(0);
int i = b.intValue();
29.最小的K个数
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
思路：快排k次
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
ArrayList<Integer> res=new ArrayList<Integer>();
int len=input.length;
if(len<=0||k<=0||k>len)
return res;
int low = 0;
int high = input.length-1;
int index = part(input,low,high);
while(index!=k-1) {
if(index>k-1) {
high=index-1;
index = part(input,low,high);
}
else {
low=index+1;
index = part(input,low,high);
}
}
for(int i=0;i<k;i++) {
res.add(input[i]);
}
return res;
}
public static int part(int [] arr, int left,int right) {
int key = arr[left];
while(left<right) {
while(left<right&&arr[right]>=key)
right--;
arr[left]=arr[right];
while(left<right&&arr[left]<=key)
left++;
arr[right]=arr[left];
}
arr[left]=key;
return left;
}
}
30.连续子数组的最大和
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
思路：动态规划。
记，sum和max两个变量
sum为每次遍历的求和结果；
max为当前遍历的最大和。
public class Solution {
public int FindGreatestSumOfSubArray(int[] array) {
if (array == null || array.length <= 0)
return 0;
int sum = 0;
int max = array[0];
for (int i = 0; i < array.length; i++) {
if (sum < 0) {
sum = array[i];
} else {
sum += array[i];
}
if (sum > max)
max = sum;
}
return max;
}
}
31.整数中1出现的次数（从1到n整数中1出现的次数）
求出113的整数中1出现的次数,并算出1001300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
思路：遍历
对每个数计算出现1的个数
public class Solution {
public int NumberOf1Between1AndN_Solution(int n) {
if(n<=0)
return 0;
int count=0;
for(int i=1;i<=n;i++) {
count+=one(i);
}
return count;
}
public static int one(int n) {
int count = 0;
while(n>0) {
if(n%10==1)
count++;
n=n/10;
}
return count;
}
}
32.把数组排成最小的数
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
思路：重写sort的比较方法。
定义 ‘332’与‘323’的比较大小。
排序后的顺序即为拼接后的最小数
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
public class Solution {
public String PrintMinNumber(int [] numbers) {
if (numbers == null || numbers.length == 0)
return "";
int len = numbers.length;
String[] str = new String[len];
StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; i++) {
str[i] = String.valueOf(numbers[i]);
}
// comparator 外部比较器
Arrays.sort(str, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
String c1 = s1 + s2;
String c2 = s2 + s1;
return c1.compareTo(c2);
}
});
for (int i = 0; i < len; i++) {
sb.append(str[i]);
}
return sb.toString();
}
}
思路二：
与思路一相似，拼接两个字符串后冒泡，把小的冒泡上去。
33.丑数
把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
思路：模拟直观的算数方式。
比如，第一个数为1，则第二个数一定是1 和 2 3 5 的乘积。
2 3 5 中2 最小，则第二个数为2；
第三个数，一定是从2x2,1x3,1x5中；
记i2 i3 i5 表示2 3 5 倍数的次数；
每次找到最小数。
import java.util.*;
public class Solution {
public int GetUglyNumber_Solution(int index) {
if(index==0)
return 0;
ArrayList<Integer> res=new ArrayList<>();
res.add(1);
int i2=0,i3=0,i5=0;
while(res.size()<index){
int m2=res.get(i2)*2;
int m3=res.get(i3)*3;
int m5=res.get(i5)*5;
int min=Math.min(m2,Math.min(m3,m5));
res.add(min);
if(min==m2) i2++;
if(min==m3) i3++;
if(min==m5) i5++;
}
return res.get(index-1);
}
}
34.第一个只出现一次的字符
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.
思路：LinkedHashMap
import java.util.LinkedHashMap;
public class Solution {
public int FirstNotRepeatingChar(String str) {
if(str==null||str.length()<=0)
return -1;
LinkedHashMap <Character,Integer> map = new LinkedHashMap <Character,Integer>();
for(int i=0;i<str.length();i++) {
if(!map.containsKey(str.charAt(i))){
map.put(str.charAt(i), 1);
}else {
int count = map.get(str.charAt(i));
map.put(str.charAt(i), ++count);
}
}
for(int i=0;i<str.length();i++) {
if(map.get(str.charAt(i))==1)
return i;
}
return -1;
}
}
35.数组中的逆序对
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
36.两个链表的第一个公共结点
输入两个链表，找出它们的第一个公共结点。
思路：公共节点表示，链表自公共节点之后的部分全部相同。
因此，先分别求两个链表的长度；
长的链表，先走，然后逐一比较两个链表的节点即可。
public class Solution {
public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
ListNode p1 = pHead1;
ListNode p2 = pHead2;
int c1=0;
int c2=0;
while(p1!=null) {
c1++;
p1=p1.next;
}
while(p2!=null) {
c2++;
p2=p2.next;
}
p1=pHead1;
p2=pHead2;
if(c1>c2) {
int tmp = c1-c2;
for(int i = 0;i<tmp;i++) {
p1=p1.next;
}
}
if(c1<c2) {
int tmp = c2-c1;
for(int i = 0;i<tmp;i++) {
p2=p2.next;
}
}
while(p1!=null&&p2!=null) {
if(p1==p2)
return p1;
p1=p1.next;
p2=p2.next;
}
return null;
}
}
37.数字在排序数组中出现的次数
统计一个数字在排序数组中出现的次数。
思路：用二分法，先找打数字第一次出现的位置，再找最后一次出现的位置；
相减即为结果。
public class Solution {
public int GetNumberOfK(int [] array , int k) {
int low=findFirst(array,k);
int high=findLast(array,k);
if(low>-1&&high>-1)
return high-low+1;
return 0;
}
public int findFirst(int [] arr,int k){
int low=0;
int high=arr.length-1;
int mid;
while(low<=high){
mid=(low+high)/2;
if(arr[mid]==k){
if(mid==low||arr[mid-1]!=k)
return mid;
else
high=mid-1;
}else if(arr[mid]>k){
high=mid-1;
}else{
low=mid+1;
}
}
return -1;
}
public int findLast(int [] arr,int k){
int low=0;
int high=arr.length-1;
int mid;
while(low<=high){
mid=(low+high)/2;
if(arr[mid]==k){
if(mid==high||arr[mid+1]!=k)
return mid;
else
low=mid+1;
}else if(arr[mid]>k){
high=mid-1;
}else{
low=mid+1;
}
}
return -1;
}
}
38.二叉树的深度
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
思路：利用二叉树的层序遍历思想；
利用队列，遍历每层时记层数加一；
然后，在当前层把所有的子节点加入队列；
遍历完即为结果。
import java.util.*;
public class Solution {
public int TreeDepth(TreeNode root) {
if (root ==null)
return 0;
Queue<TreeNode> qu = new LinkedList<TreeNode>();
qu.add(root);
int depth = 0;
while(qu.size()!=0) {
depth++;
int len = qu.size();
while(len--!=0) {
TreeNode top = qu.poll();
if(top.left!=null)
qu.add(top.left);
if(top.right!=null)
qu.add(top.right);
}
}
return depth;
}
}
39.平衡二叉树
输入一棵二叉树，判断该二叉树是否是平衡二叉树。
40.数组中只出现一次的数字
一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。
思路：两两异或
public class Solution {
public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
int num=0;
for(int i=0;i<array.length;i++){
num^=array[i];//所有数异或，结果为不同的两个数字的异或
}
int count=0;//标志位，记录num中的第一个1出现的位置
for(;count<array.length;count++){
if((num&(1<<count))!=0){
break;
}
}
num1[0]=0;
num2[0]=0;
for(int i=0;i<array.length;i++){
if((array[i]&(1<<count))==0){//标志位为0的为一组，异或后必得到一个数字（这里注意==的优先级高于&，需在前面加（））
num1[0]^=array[i];
}else{
num2[0]^=array[i];//标志位为1的为一组
}
}
}
}
41.和为S的连续正数序列
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
输出描述:
输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序
思路：双指针，滑动窗口；
初始窗口左指针low为1，右指针high为2；
如果窗口内的和小于目标值，则右指针加一；
大于，左指针加一；
如果相等则把序列加入结果，窗口整体右移；
直到左指针到达(sum+1)/2位置。
import java.util.ArrayList;
public class Solution {
public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
ArrayList<ArrayList<Integer> >res = new ArrayList<ArrayList<Integer> >();
if(sum<3)
return res;
int low=1;int high=2;
int cur=3;
while(low<(sum+1)/2){
if(cur<sum){
high++;
cur=cur+high;
}
if(cur>sum){
low++;
cur=cur-low+1;
}
if(cur==sum){
ArrayList<Integer> list=new ArrayList<Integer>();
for(int i=low;i<=high;i++){
list.add(i);
}
res.add(list);
cur=cur+high-low+1;
low++;
high++;
}
}
return res;
}
}
42.和为S的两个数字
输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
输出描述:
对应每个测试案例，输出两个数，小的先输出。
思路：距离最远的两个数，积最小；
因此两指针，分别指向数组的首尾，找和为s的两个数字；
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
ArrayList <Integer> res=new ArrayList<Integer>();
if(array==null || array.length<=0)
return res;
int low = 0,high = array.length-1;
while(low<high) {
if(array[low]+array[high]==sum) {
res.add(array[low]);
res.add(array[high]);
return res;
}
if(array[low]+array[high]<sum) {
low++;
}
if(array[low]+array[high]>sum) {
high--;
}
}
return res;
}
}
43.左旋转字符串
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！
思路一：反转三次；
先把前k个字符反转；
再把剩下的反转；
然后整体反转。
public class Solution {
public String LeftRotateString(String str,int n) {
if(str==null || n<=0||str.length()<=0||n>str.length())
return str;
int len = str.length();
char [] ch = str.toCharArray();
reverse(ch,0,n-1);
reverse(ch,n,len-1);
reverse(ch,0,len-1);
return String.valueOf(ch);
}
public static void reverse(char[] ch,int i,int j) {
while(i<j) {
char tmp =ch[i];
ch[i] = ch [j];
ch[j]=tmp;
i++;
j--;
}
}
}
思路二：拼接字符串，然后截取n+1处；
比如abcd 反转2，应为cdab；
先拼接：abcdabcd；
取n+1，cdab；
public static String LeftRotateString(String str, int n) {
if (str == null || n <= 0 || str.length() <= 0 || n > str.length())
return str;
int len = str.length();
String newStr = str + str;
String res = newStr.substring(n, n + len);
return res;
}
44.翻转单词顺序列
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？
思路一：经典思路，反转两次；
先反转每个单词，然后整体反转。
public class Solution {
public String ReverseSentence(String str) {
if(str.length()==0||str.trim().length()==0)
return str;
char[] chars = str.toCharArray();
int mark=0;
for(int i=0;i<chars.length;i++) {
if(chars[i]==' ') {
swapStr(chars,mark,i-1);
mark=i+1;
}
}
swapStr(chars,mark,chars.length-1);
swapStr(chars,0,chars.length-1);
return new String(chars);
}
public static void swapStr(char[] chars,int begin,int end) {
while(begin<end) {
char tmp = chars[begin];
chars[begin]=chars[end];
chars[end]=tmp;
begin++;
end--;
}
}
}
思路二：借助容器
public class Solution {
public String ReverseSentence(String str) {
if(str.length()==0||str.trim().length()==0)
return str;
String [] strs=str.split(" ");
StringBuffer sb= new StringBuffer();
for(int i=strs.length-1;i>=0;i--){
sb.append(strs[i]);
if(i>0)
sb.append(" ");
}
return sb.toString();
}
}
45.扑克牌顺子
LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张_)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。
46.孩子们的游戏(圆圈中最后剩下的数)
每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!_)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)
思路一：约瑟夫环问题；
递推公式：f(n,m)={f(n-1,m)+m}%n；
让f[i]为i个人玩游戏报m退出最后的胜利者的编号，最后的结果自然是f[n]；
f[1] = 0;
f[i] = (f[i - 1] + m) mod i;
public static int LastRemaining(int n,int m) {
if(n <= 0 && m <= 0) return -1;
int p = 0;
for(int i=2;i<=n;i++) {
p=(p+m)%i;
}
return p+1;
}
思路二：循环链表
public class Solution {
// 构造循环链表结构
public static class Node {
private int value;
private Node pre;
private Node next;
public Node(int value) {
this.value = value;
this.pre = null;
this.next = null;
}
}
public int LastRemaining_Solution(int n, int m) {
if (m == 0 && n == 0) {
return -1;
}
Node head = new Node(0);
Node cur = head;
Node last = null;
for(int i = 1; i < n; i++) {
last = new Node(i);
last.pre = cur;
cur.next = last;
cur = last;
}
cur = head;
last.next = head;
head.pre = last;
int count = n;
while (count != 1) {
for (int i = 0; i < m - 1; i++) {
cur = cur.next;
}
cur.pre.next = cur.next;
cur.next.pre = cur.pre;
cur = cur.next;
count--;
}
return cur.value;
}
}
import java.util.*;
public class Solution {
public int LastRemaining_Solution(int n, int m) {
ArrayList<Integer> list = new ArrayList<>();
int index=0;
for(int i=0;i<n;i++)
list.add(i);
while(list.size()>1){
index=(index+m-1)%list.size();
list.remove(index);
}
return list.size()==1? list.get(0):-1;
}
}