1.鏡像二叉樹
題目描述
操作給定的二叉樹，將其變換為源二叉樹的鏡像。
輸入描述:
二叉樹的鏡像定義：源二叉樹
8
/ \
6 10
/ \ / \
5 7 9 11
鏡像二叉樹
8
/ \
10 6
/ \ / \
11 9 7 5
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public void Mirror(TreeNode root) {
if(root==null)return;
TreeNode temp = root.left;
root.left=root.right;
root.right=temp;
Mirror(root.left);
Mirror(root.right);
}
}
2.順時針打印矩陣
題目描述
輸入一個矩陣，按照從外向里以順時針的順序依次打印出每一個數字，例如，如果輸入如下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.
思路1：
1.普通的循環打印。把矩陣想象成若干個圈。相當于每次從（i,i）開始打印一整圈。
圈數應該是 min(Math.ceil(row/2),Math.ceil(column/2))
2.對于每個圈，打印有四步，圈可能并不完整，要判斷是否有必要進行下一步打印。
特別注意的是，對于從右到左和從下到上的判斷，不僅要判斷行，還要判斷列。
思路2：
旋轉魔方。取出第一行，然后旋轉魔方，重復上述操作。需要額外的輔助空間，時間復雜度也較高。
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printMatrix(int [][] matrix) {
ArrayList<Integer> list = new ArrayList<Integer>();
if(matrix.length==0||matrix[0].length==0)return list;
int row = matrix.length;
int column = matrix[0].length;
int start = 0;
while((start*2<row)&&(start*2<column)){
printCircleMatrix(matrix,start,list);
start++;
}
return list;
}
public void printCircleMatrix(int[][] matrix,int start,ArrayList<Integer> list){
int row = matrix.length;
int column = matrix[0].length;
int endX = column-start-1;
int endY = row-start-1;
for(int j = start;j<=endX;j++){
list.add(matrix[start][j]);
}
if(endY>start){
for(int i= start+1;i<=endY;i++){
list.add(matrix[i][endX]);
}
}
if(endX>start && endY>start){
for(int j = endX-1;j>=start;j--){
list.add(matrix[endY][j]);
}
}
if(endY>start+1 && endX>start){
for(int i = endY-1;i>=start+1;i--){
list.add(matrix[i][start]);
}
}
}
}
3.包含min函數的棧
題目描述
定義棧的數據結構，請在該類型中實現一個能夠得到棧中所含最小元素的min函數（時間復雜度應為O（1））。
注意
1.必須滿足先進先出。才是一個棧
2.要求O（1）復雜度，所以不能每次排序
3.如果只存儲每次的最小值，那么如果最小值出棧了，勢必還要花費大于O（1）的時間復雜度去尋找新的最小值。
綜上，需要采取一個輔助棧
思路
采用一個輔助棧。每次入棧時，輔助棧入棧當前最小值（min(新元素，棧頂元素)）；出棧時，輔助棧也一起出棧。保證輔助棧的棧頂元素就是當前棧內的最小值。輔助棧的含義類似于 加入當前元素時，棧內的最小值.
top/min時如果棧為空，這里會打印異常，并且返回-1值作為異常值（可能不太好）
import java.util.Stack;
public class Solution {
Stack<Integer> stack = new Stack<Integer>();
Stack<Integer> minStack = new Stack<Integer>();
public void push(int node) {
stack.push(node);
if(minStack.empty()||node<minStack.peek()){
minStack.push(node);
}else{
minStack.push(minStack.peek());
}
}
public void pop() {
stack.pop();
minStack.pop();
}
public int top() {
if(stack.empty()){
System.out.println("stack為空");
return -1;
}
return stack.peek();
}
public int min() {
if(minStack.empty()){
System.out.println("stack為空");
return -1;
}
return minStack.peek();
}
}
4.棧的壓入、彈出序列
題目描述
輸入兩個整數序列，第一個序列表示棧的壓入順序，請判斷第二個序列是否可能為該棧的彈出順序。假設壓入棧的所有數字均不相等。例如序列1,2,3,4,5是某棧的壓入順序，序列4,5,3,2,1是該壓棧序列對應的一個彈出序列，但4,3,5,1,2就不可能是該壓棧序列的彈出序列。（注意：這兩個序列的長度是相等的）
思路
(不要看了，并不對)思路一：從規律上考慮。如果序列遞增，對于序列里面的所有數，如果前面的數字都大于或者都小于這個數，那么就是一個彈出序列。否則，則不是。可以用min,max記錄值，然后比較。這里入棧的數字雖然不是遞增，但是下標是遞增的。我們可以用下標值代替。這里需要把出棧序列4,5,3,2,1轉化成它們的下標對應值序列；然后對轉化后的序列進行判斷。
這個思路不對！！！
反例：pushA = {1,2,3,4,5};popA = {3,5,4,2,1};返回應該是true；這里會變成false
正確思路：運用一個輔助棧。對入棧序列依次入棧，每次入棧時判斷棧頂元素是否是彈出序列中的當前值，不是，則不進行出棧，繼續入棧；否則，出棧，接著判斷棧頂元素和彈出序列中的下一個值是否相等。
如果最后棧非空，說明彈出序列不是該壓棧序列的彈出序列。
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 true;
if(pushA==null||popA==null||pushA.length==0||popA.length==0)return false;
Stack<Integer> stack = new Stack<Integer>();
int j=0;
for(int i=0;i<pushA.length;i++){
stack.push(pushA[i]);
while((j<popA.length)&&stack.peek()==popA[j]){
stack.pop();
j++;
}
}
return stack.empty();
}
}
5.從上到下打印二叉樹
題目描述
從上往下打印出二叉樹的每個節點，同層節點從左至右打印。
思路
其實就是層序遍歷。廣度優先遍歷也要使用隊列
使用LinkedList做隊列（實現了Deque方法）
ArrayList不適合做隊列，沒有實現Deque接口，沒有上述提及的pop,poll,peek,offer這些方法。只有add和remove(index)。
import java.util.ArrayList;
import java.util.LinkedList;
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
ArrayList<Integer> result = new ArrayList<Integer>();
LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
if(root==null)return result;
queue.offer(root);
while(!queue.isEmpty()){
TreeNode temp = queue.poll();
result.add(temp.val);
if(temp.left!=null){
queue.offer(temp.left);
}
if(temp.right!=null){
queue.offer(temp.right);
}
}
return result;
}
}
6.二叉搜索樹的后序遍歷序列
題目描述
輸入一個整數數組，判斷該數組是不是某二叉搜索樹的后序遍歷的結果。如果是則輸出Yes,否則輸出No。假設輸入的數組的任意兩個數字都互不相同。
思路
1.首先找規律：二叉搜索樹有：左<根<右；后序遍歷是左右根。觀察一些遍歷序列，發現 根是序列的最后一個值。將前面的數組分為兩部分，一部分是左子樹節點；另一部分是右子樹節點
2.對于左右子樹，也存在上述規律。所以可以使用遞歸來做。遞歸終止條件是，end<=start，這時表示沒有額外的節點需要再進行判斷。所以返回true
3.如果前面的序列已經有大于根的了，說明接下來都是右子樹節點。如果在接下來的序列里發現值小于根的，說明不合題意，返回false
如果輸入的序列為空或null時，不是二叉搜索樹的后序遍歷
public class Solution {
public boolean VerifySquenceOfBST(int [] sequence) {
if(sequence ==null||sequence.length==0)return false;
return verifyCircle(sequence,0,sequence.length-1);
}
public boolean verifyCircle(int[] sub,int start,int end){
if(end-start<=0){
return true;
}
int root = sub[end];
int leftCount =0;
boolean rightflag=false;
for(int i=start;i<end;i++){
if(sub[i]<root&&!rightflag){
leftCount++;
}else if(sub[i]<root&&rightflag){
return false;
}else if(sub[i]>root){
rightflag=true;
}
}
return verifyCircle(sub,start,leftCount-1)&&verifyCircle(sub,leftCount,end-1);
}
}
7.二叉樹中和為某一值的路徑
題目描述
輸入一顆二叉樹的跟節點和一個整數，打印出二叉樹中結點值的和為輸入整數的所有路徑。路徑定義為從樹的根結點開始往下一直到葉結點所經過的結點形成一條路徑。(注意: 在返回值的list中，數組長度大的數組靠前)
思路：
1.求路徑，是從根開始到葉節點。遍歷方式類似于前序遍歷（根左右），只不過，相對于前序遍歷，我們需要記錄下來遍歷的節點值。
2.最后返回的結果是一個ArrayList<ArrayList<Integer>>結構。里層裝的是各種可能路徑，且路徑排序方式是長路徑在前。
(怎么保證長路徑在前呢？目前的方法是先遍歷的子樹路徑在前，難道要每次遍歷前先算一下子樹大小再做么)
3.因為整數有正有負有零，所以只有遍歷到葉節點時，才知道這個路徑是不是符合題意。
4.首先就是要把當前結點（首先是根結點）添加到路徑里，同時target 減去當前結點的值；然后，如果當前結點為葉節點并且和也達到給定值，就把這個路徑添加到列表，否則就一直遍歷下去；最后，遍歷到葉節點之后，返回上層結點之前，一定要把最后一個結點從路徑中刪除
5.遍歷完一個節點后，要返回到上個節點，以便下次遍歷。
import java.util.ArrayList;
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
ArrayList<Integer> path = new ArrayList<Integer>();
public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
if(root==null)return result;
path.add(root.val);
int currentTarget = target-root.val;
if(currentTarget==0&&root.left==null&&root.right==null){
ArrayList<Integer> temp = new ArrayList<Integer>(path);
result.add(temp);
}
//保證長數組先進
if(HeightOfTree(root.left)>=HeightOfTree(root.right)){
FindPath(root.left,currentTarget);
FindPath(root.right,currentTarget);
}else{
FindPath(root.right,currentTarget);
FindPath(root.left,currentTarget);
}
path.remove(path.size()-1);
return result;
}
public int HeightOfTree(TreeNode node){
if(node==null)return 0;
return Math.max(HeightOfTree(node.left)+1,HeightOfTree(node.right)+1);
}
}
這樣時間復雜度要O(n^2)。不知道有沒有更好的方式
8.復雜鏈表的復制
題目描述
輸入一個復雜鏈表（每個節點中有節點值，以及兩個指針，一個指向下一個節點，另一個特殊指針指向任意一個節點），返回結果為復制后復雜鏈表的head。（注意，輸出結果中請不要返回參數中的節點引用，否則判題程序會直接返回空）
思路：
思路1：先按照next指針創建新鏈表；然后再遍歷，給random指針賦值。賦值時需要找到對應的指向節點位置，這里可以重頭遍歷原鏈表，記錄步數s.。然后在新鏈表中也需要走s步找到random指向的位置。時間復雜度O(n^2)
思路2：空間換時間。在第一次遍歷創建新鏈表的時候，用一個hashmap記錄下<OldNode,NewNode>位置；然后賦值random的時候直接根據老節點找到新的節點。時間復雜度O(n)，空間復雜度O(n)
思路3：主要想法是如何快速定位新節點位置。我們把新節點串在老節點的后面。這樣，random直接指向原來random節點的下一個位置。最后把兩個鏈表分離。
分成3步做。
/*
public class RandomListNode {
int label;
RandomListNode next = null;
RandomListNode random = null;
RandomListNode(int label) {
this.label = label;
}
}
*/
public class Solution {
public RandomListNode Clone(RandomListNode pHead)
{
if(pHead==null)return null;
cloneNodes(pHead);
connectedRandom(pHead);
return splitRandomList(pHead);
}
//第一步：復制節點。把新復制的節點接在原有節點后面。
public void cloneNodes(RandomListNode pHead){
RandomListNode temp=pHead;
while(temp!=null){
RandomListNode next = temp.next;
RandomListNode newNode = new RandomListNode(temp.label);
temp.next = newNode;
newNode.next = next;
temp = next;
}
}
//第二步：鏈接特殊指針。原有節點指針指向S，那么復制節點的指針就指向S的下一個節點S'
public void connectedRandom(RandomListNode pHead){
RandomListNode temp=pHead;
while(temp!=null){
RandomListNode newNode = temp.next;
RandomListNode randomNode = temp.random;
//newNode.random = randomNode.next;（如果不按下面寫，會拋NPE）
newNode.random = randomNode==null?null:randomNode.next;
temp = newNode.next;
}
}
//第三部：分開兩個鏈表。
public RandomListNode splitRandomList(RandomListNode head){
RandomListNode newRandomHead = null;
RandomListNode newtemp=null;
RandomListNode temp = head;
if(temp!=null){
newRandomHead = temp.next;
newtemp = temp.next;
if(newtemp==null)return newRandomHead;
temp.next = newtemp.next;
temp = temp.next;
}
while(temp!=null){
newtemp.next = temp.next;
newtemp = newtemp.next;
if(newtemp==null)return newRandomHead;
temp.next = newtemp.next;
temp = temp.next;
}
return newRandomHead;
}
}
9 二叉搜索樹與雙向鏈表
題目描述
輸入一棵二叉搜索樹，將該二叉搜索樹轉換成一個排序的雙向鏈表。要求不能創建任何新的結點，只能調整樹中結點指針的指向。
思路：
看到排序聯想到中序遍歷。二叉搜索樹的中序遍歷就是一個排序的數組。那么按照中序排序的思想，記錄下之前排完序的最后一個節點，然后將這個節點和當前節點連接，按順序依次連接，就能得到排序的雙向鏈表。
注意
1.需要返回雙向鏈表的頭節點。所以用一個全局變量指針leftNode，記錄頭節點（中序遍歷的第一個節點）
2.根節點和右子樹的最小節點的連接，其實是在遍歷右子樹最小節點時就做了。無需額外連接。（lastNode==root，pRootOfTree==右子樹最小節點時。）
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
TreeNode leftNode = null;
TreeNode lastNode = null;
public TreeNode Convert(TreeNode pRootOfTree) {
if(pRootOfTree==null)return leftNode;
Convert(pRootOfTree.left);
if(leftNode==null){
leftNode=pRootOfTree;
lastNode=pRootOfTree;
}else{
lastNode.right = pRootOfTree;
pRootOfTree.left = lastNode;
lastNode=pRootOfTree;
}
Convert(pRootOfTree.right);
return leftNode;
}
}
10.字符串的排列
題目描述
輸入一個字符串,按字典序打印出該字符串中字符的所有排列。例如輸入字符串abc,則打印出由字符a,b,c所能排列出來的所有字符串abc,acb,bac,bca,cab和cba。
輸入描述:
輸入一個字符串,長度不超過9(可能有字符重復),字符只包括大小寫字母。
思路：
遞歸做。字符串可看做兩部分：第一個字符和剩余的字符。我們把第一個字符依次和后面的字符交換位置，然后對剩余的n-1個字符進行全排列。遞歸結束條件是，剩余1個字符時。這時直接把相應的char數組轉化成字符串存入list
注意：
1.要求按字典序返回。對結果進行Collections.sort()
2.交換完，并且調用遞歸排列方法后，還需要再交換回去。不然下一個位置的就亂了。
3.String.toCharArray()是String轉char[]。內部調用arrayCopy生成新的char數組
new String(char[])和String.valueOf(char[])都是char轉String
4.由于可能存在重復字符，需要進行contains判斷。去重
import java.util.ArrayList;
import java.util.Collections;
public class Solution {
ArrayList<String> list = new ArrayList<String>();
public ArrayList<String> Permutation(String str) {
if(str.isEmpty()){
return list;
}
char[] array = str.toCharArray();
PermutationHelper(array,0);
Collections.sort(list);
return list;
}
public void PermutationHelper(char[] array,int start){
if(start==array.length-1){
String val = String.valueOf(array);
if(!list.contains(val)){
list.add(val);
}
return;
}
for(int i=start;i<array.length;i++){
swap(array,start,i);
PermutationHelper(array,start+1);
swap(array,start,i);
}
}
public void swap(char[] array,int i,int j){
char temp = array[i];
array[i]=array[j];
array[j]=temp;
}
}
題目變種：求字符的所有組合
思路：如果輸入n個字符，則這n個字符構成長度為1，2，……，n的組合。當求n個字符的長度為m的組合時，我們把字符分成兩部分：當前字符和剩余的n-1個字符。這樣會出現兩種情況：一是m中包含當前字符，則下一步在剩余的n-1個字符中選擇m-1個字符做組合；二是m中不包含當前字符，則下一步在剩余的n-1個字符中選擇m-1個字符做組合。所以問題轉化成，求n個字符的1，2，3，……，n個長度的組合；而在求這些組合的時候可以采取遞歸來做，遞歸的終止條件是m==0（這時可以把組合加入）或者沒有需要用來添加的字符（這時嘗試失敗）
import java.util.ArrayList;
public class Solution {
ArrayList<String> list = new ArrayList<String>();
public ArrayList<String> Permutation(String str) {
if(str.isEmpty()){
return list;
}
//用來存放一個組合串
StringBuilder sb = new StringBuilder();
for(int i=1;i<=str.length();i++){
PermutationHelper(str,0,i,sb);
}
return list;
}
public void PermutationHelper(String s,int start,int m,StringBuilder sb){
//終止條件1：取0個字符串，這時可以把之前的sb存入到結果集中
if(m==0){
if(!list.contains(sb.toString())){
list.add(sb.toString());
}
return;
}
//終止條件2：沒有可以用來添加的字符了：說明這個組合不合適
if(start==s.length()){
return;
}
//情況1：m個字符中包含Start位置的字符，剩余的字符中取m-1個
sb.append(s.charAt(start));
PermutationHelper(s,start+1,m-1,sb);
//情況2：m個字符中不包含Start位置的字符（把之前添加的去掉），剩余的字符中取m個
sb.deleteCharAt(sb.length()-1);
PermutationHelper(s,start+1,m,sb);
}
public static void main(String[] args){
Solution su = new Solution();
ArrayList<String> list = su.Permutation("abc");
}
}
