一：二叉搜索樹和雙向鏈表
輸入一棵二叉搜索樹，將該二叉搜索樹轉換成一個排序的雙向鏈表。要求不能創建任何新的結點，只能調整樹中結點指針的指向。
1.要用一個lastNode指針指着最右的節點。
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public TreeNode Convert(TreeNode pRootOfTree) {
TreeNode lastNode = null;
lastNode = ConvertNode(pRootOfTree, lastNode);
while(lastNode != null && lastNode.left != null){
lastNode = lastNode.left;
}
return lastNode;
}
public TreeNode ConvertNode(TreeNode root, TreeNode lastNode){
if(root == null)
return null;
if(root.left != null)
lastNode = ConvertNode(root.left, lastNode);
root.left = lastNode;
if(lastNode != null)
lastNode.right = root;
lastNode = root;
if(root.right != null){
lastNode = ConvertNode(root.right, lastNode);
}
return lastNode;
}
}
二：字符串排列
輸入一個字符串,按字典序打印出該字符串中字符的所有排列。例如輸入字符串abc,則打印出由字符a,b,c所能排列出來的所有字符串abc,acb,bac,bca,cab和cba。
import java.util.ArrayList;
import java.util.*;
public class Solution {
public ArrayList<String> Permutation(String str) {
ArrayList<String> list = new ArrayList<String>();
int index = 0;
Permutation(list, index, str.toCharArray());
Collections.sort(list);
return list;
}
public void Permutation(ArrayList<String> list, int index, char[] str){
if(index == str.length - 1)
list.add(new String(str));
else{
for(int i = index; i < str.length; i++){
if(i == index || str[i] != str[index])
{
swap(str, i, index);
Permutation(list, index+1, str);
swap(str, index, i);
}
}
}
}
public void swap(char[] str, int i, int j){
if(str.length < 2)
return;
char temp = str[i];
str[i] = str[j];
str[j] = temp;
}
}
三：數組中出現次數超過一半的元素
1.先拿第一個數作爲標準num，後面元素相同count+1，不同count-1;當count==0時，num指向新的數，令count=1，再繼續這樣下去，知道後面。
2.用最後得到的num再遍歷一次，看看出現次數是否真的大於array.length/2;
四：最小的K個數
輸入n個整數，找出其中最小的K個數。例如輸入4,5,1,6,2,7,3,8這8個數字，則最小的4個數字是1,2,3,4,。
1.先對前K個數建最大堆。
2.K後面的數依次和堆頂元素比較，小於堆頂的刪除堆頂元素，使該元素進隊，一直維持這個堆爲K個元素。
3.最後那個堆裏的K個數即爲所求元素。
import java.util.*;
public class Solution {
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
ArrayList<Integer> list = new ArrayList<Integer>();
if(input == null || input.length < k || k == 0)
return list;
for(int i = k/2 - 1; i >= 0; i--){
adjustMaxHeap(input, i, k-1);
}
for(int i = k; i < input.length; i++){
if(input[i] < input[0])
{
int temp = input[i];
input[i] = input[0];
input[0] = temp;
adjustMaxHeap(input, 0, k-1);
}
}
for(int i = 0; i < k; i++){
list.add(input[i]);
}
return list;
}
public void adjustMaxHeap(int[] input, int pos, int length){
int child = 0;
int temp;
for(temp = input[pos]; 2*pos+1 <= length; pos = child)
{
child = 2*pos+1;
if(child < length && input[child] < input[child+1])
{
child++;
}
if(input[child] > temp){
input[pos] = input[child];
}
else{
break;
}
}
input[pos] = temp;
}
}
五：把數組排成最小數
1.定義一個Collections的函數使它把list裏的所有組合按組合的大小排序。
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Solution {
public String PrintMinNumber(int [] numbers) {
ArrayList<Integer> list = new ArrayList<Integer>();
int n = numbers.length;
String s = "";
for(int i = 0; i < n; i++)
{
list.add(numbers[i]);
}
Collections.sort(list, new Comparator<Integer>(){
public int compare(Integer s1, Integer s2)
{
String str1 = s1 + "" + s2;
String str2 = s2 + "" + s1;
return str1.compareTo(str2);
}
});
for(int data : list)
{
s += data;
}
return s;
}
}
六：查找第N個醜數（只能被2,3,5整除）
1.建造一個N長度的數組，和p2,p3,p5三個指針。
2.三個指針分別乘上對應的數，比較找到最小的添加在數組的下一個數，這是隻有選中的指針後退，其他的不變。
public class Solution {
public int GetUglyNumber_Solution(int index) {
if(index <= 0)
return 0;
int[] pUgly = new int[index];
pUgly[0] = 1;
int nextUgly = 1;
int p2 = 0;
int p3 = 0;
int p5 = 0;
while(nextUgly < index)
{
int min = Min(2*pUgly[p2], 3*pUgly[p3], 5*pUgly[p5]);
pUgly[nextUgly] = min;
if(2*pUgly[p2] <= pUgly[nextUgly])
p2++;
if(3*pUgly[p3] <= pUgly[nextUgly])
p3++;
if(5*pUgly[p5] <= pUgly[nextUgly])
p5++;
nextUgly++;
}
return pUgly[nextUgly-1];
}
public int Min(int p1, int p2, int p3)
{
return p1 >= p2 ? (p2 > p3 ? p3 : p2) : (p1 > p3 ? p3 : p1);
}
}
七：第一個出現一次的字符
import java.util.*;
public class Solution {
public int FirstNotRepeatingChar(String str) {
Map<Character, Integer> map = new HashMap<Character, Integer>();
char[] ch = str.toCharArray();
for(int i = 0; i < ch.length; i++)
{
if(map.containsKey(ch[i]))
{
map.put(ch[i], map.get(ch[i])+1);
}
else{
map.put(ch[i], 1);
}
}
for(int i = 0; i < ch.length; i++)
{
if(map.get(ch[i]) == 1)
return i;
}
return -1;
}
}
八：數組中的逆序對
1.要用歸併排序解決
public class Solution {
public int InversePairs(int [] array) {
if(array.length <= 1 || array == null)
return 0;
int[] copy = new int[array.length];
for(int i = 0; i < array.length; i++)
copy[i] = array[i];
int count = 0;
count = InverseCorePairs(array, copy, 0, array.length-1)%1000000007;
return count % 1000000007;
}
public int InverseCorePairs(int[] array, int[] copy, int start, int end)
{
if(start == end)
{
return 0;
}
int mid = (start+end)>>1;
int left = InverseCorePairs(array, copy, start, mid)%1000000007;
int right = InverseCorePairs(array, copy, mid+1, end)%1000000007;
int i = mid;
int j = end;
int copyIndex = end;
int count = 0;
while(i >= start && j >= mid+1)
{
if(array[i] > array[j])
{
copy[copyIndex--] = array[i--];
count += j - mid;
if(count >= 1000000007)
count = count % 1000000007;
}
else{
copy[copyIndex--] = array[j--];
}
}
for(;i >= start; i--)
{
copy[copyIndex--] = array[i];
}
for(; j >= mid+1; j--)
{
copy[copyIndex--] = array[j];
}
for(int ii = start; ii <= end; ii++)
array[ii] = copy[ii];
return (left + count + right)%1000000007;
}
}
九：數組中只出現一次的數字
1.將數組中所有的數異或得到結果mayor(相同的全部相消了，剩下的是兩個不同的數)。
2.找到mayor中最後一個爲1的數。
3.根據次數將數組分爲兩組，兩個不同的數分別落在兩組，最後用異或求出最後的數。
//num1,num2分別爲長度爲1的數組。傳出參數
//將num1[0],num2[0]設置爲返回結果
public class Solution {
public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
int mayor = 0;
for(int i = 0; i < array.length; i++)
{
mayor ^= array[i];
}
int flag = 1;
while((flag & mayor) == 0)
flag <<= 1;
for(int i = 0; i < array.length; i++)
{
if((array[i] & flag) == 0)
num1[0] ^= array[i];
else
num2[0] ^= array[i];
}
}
}
十：和爲S的連續整數序列
小明很喜歡數學,有一天他在做數學作業時,要求計算出9~16的和,他馬上就寫出了正確答案是100。但是他並不滿足於此,他在想究竟有多少種連續的正數序列的和爲100(至少包括兩個數)。沒多久,他就得到另一組連續正數和爲100的序列:18,19,20,21,22。現在把問題交給你,你能不能也很快的找出所有和爲S的連續正數序列? Good Luck!
1）由於我們要找的是和爲S的連續正數序列，因此這個序列是個公差爲1的等差數列，而這個序列的中間值代表了平均值的大小。假設序列長度爲n，那麼這個序列的中間值可以通過（S / n）得到，知道序列的中間值和長度，也就不難求出這段序列了。
2）滿足條件的n分兩種情況：
n爲奇數時，序列中間的數正好是序列的平均值，所以條件爲：(n & 1) == 1 && sum % n == 0；
n爲偶數時，序列中間兩個數的平均值是序列的平均值，而這個平均值的小數部分爲0.5，所以條件爲：(sum % n) * 2 == n.
3）由題可知n >= 2，那麼n的最大值是多少呢？我們完全可以將n從2到S全部遍歷一次，但是大部分遍歷是不必要的。爲了讓n儘可能大，我們讓序列從1開始，
根據等差數列的求和公式：S = (1 + n) * n / 2，得到
最後舉一個例子，假設輸入sum = 100，我們只需遍歷n = 13~2的情況（按題意應從大到小遍歷），n = 8時，得到序列[9, 10, 11, 12, 13, 14, 15, 16]；n = 5時，得到序列[18, 19, 20, 21, 22]。
完整代碼：時間複雜度爲
)
import java.util.ArrayList;
public class Solution {
public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
for(int n = (int)Math.sqrt(2*sum); n>=2; n--)
{
if(((n&1)==1 && sum%n == 0) || ((sum%n)*2 == n))
{
ArrayList l = new ArrayList<Integer>();
for(int j = 0, k = sum/n - (n-1)/2; j < n; j++)
{
l.add(k++);
}
list.add(l);
}
}
return list;
}
}
十一：孩子們的遊戲（圓圈中最後一個數字）
每年六一兒童節,牛客都會準備一些小禮物去看望孤兒院的小朋友,今年亦是如此。HF作爲牛客的資深元老,自然也準備了一些小遊戲。其中,有個遊戲是這樣的:首先,讓小朋友們圍成一個大圈。然後,他隨機指定一個數m,讓編號爲0的小朋友開始報數。每次喊到m-1的那個小朋友要出列唱首歌,然後可以在禮品箱中任意的挑選禮物,並且不再回到圈中,從他的下一個小朋友開始,繼續0...m-1報數....這樣下去....直到剩下最後一個小朋友,可以不用表演,並且拿到牛客名貴的“名偵探柯南”典藏版(名額有限哦!!^_^)。請你試着想下,哪個小朋友會得到這份禮品呢？(注：小朋友的編號是從0到n-1)
1.用一個數組arr[]從1到n記錄，若蹲下了記爲0；
2.index記錄走過的人數，dunNumbers記錄走過的但是卻是蹲下的人數，duns記錄蹲下的人數。
public class Solution {
public int LastRemaining_Solution(int n, int m) {
if(n < 1 || m < 1)
return -1;
int[] arr = new int[n];
for(int i = 0; i < n; i++)
arr[i] = i+1;
int index = 0;
int duns = 0;
int dunNumbers = 0;
while(duns != n-1)
{
if(arr[index%n] == 0)
{
dunNumbers++;
index++;
}
else{
if((index+1-dunNumbers)%m==0)
{
arr[index%n] = 0;
index++;
duns++;
}
else{
index++;
}
}
}
for(int i = 0; i < arr.length; i++)
if(arr[i] != 0)
return arr[i]-1;
return -1;
}
}