版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/caoxiaohong1005/article/details/83025128
常用算法 ［进制转换＋最小正整数＋树的非递归算法］
问题一 ：8和10进制转换
public class Main {
public static void main(String[] args) {
//Scanner scanner = new Scanner(System.in);
// 十进制和十六进制转化
String s1 = tenToSixteen("22");
System.out.println(s1);
int s2 = sixteenToTen("22");
System.out.println(s2);
}
/**
* 10进制转为16进制
*/
private static String tenToSixteen(String num) {
int number = Integer.parseInt(num);
StringBuilder sb = new StringBuilder();
while (number / 16 != 0) {
int high = number / 16;
if (high < 10) {
sb.append(high);
} else if (high == 10) {
sb.append("A");
} else if (high == 11) {
sb.append("B");
} else if (high == 12) {
sb.append("C");
} else if (high == 13) {
sb.append("D");
} else if (high == 14) {
sb.append("E");
} else {
sb.append("F");
}
number -= 16 * high;
}
if (number != 0) {
if (number < 10) {
sb.append(number);
} else if (number == 10) {
sb.append("A");
} else if (number == 11) {
sb.append("B");
} else if (number == 12) {
sb.append("C");
} else if (number == 13) {
sb.append("D");
} else if (number == 14) {
sb.append("E");
} else {
sb.append("F");
}
}
return sb.toString();
}
/**
* 16进制转为10进制
*/
private static int sixteenToTen(String num) {
if (num == null || num.isEmpty()) {
return 0;
}
int sum = 0;
int len = num.length();
int pow = 0;
for (int i = len - 1; i >= 0; i--) {
char number = num.charAt(i);
double tmp;
if (number <= '9') {
tmp = (num.charAt(i) - '0') * Math.pow(16, pow);
} else if (number == 'A') {
tmp = 10 * Math.pow(16, pow);
} else if (number == 'B') {
tmp = 11 * Math.pow(16, pow);
} else if (number == 'C') {
tmp = 12 * Math.pow(16, pow);
} else if (number == 'D') {
tmp = 13 * Math.pow(16, pow);
} else if (number == 'E') {
tmp = 14 * Math.pow(16, pow);
} else {
tmp = 15 * Math.pow(16, pow);
}
int in = doubleToInt(tmp);
sum += in;
pow++;
}
return sum;
}
private static int doubleToInt(double d) {
return new Double(d).intValue();
}
}
问题2： 判断一个数组中没有出现的最小的正整数
public class Main {
public static void main(String[] args) {
//Scanner scanner = new Scanner(System.in);
int[] a = {3,4,5,9,1,-3};
System.out.println(getMin(a,a.length));
}
private static int getMin(int[] array, int len) {
for (int i = 0; i < len; i++) {
if (array[i] >= 1 && array[i] < len) {
int tmp = array[i];
array[i] = array[tmp-1];
array[tmp-1] = tmp;
}
}
for(int i = 0; i < len; i++) {
if (array[i] != i+1) {
return i+1;
}
}
return -1;
}
}
- 方法思路：使用数组下标，通过交换，保证数组下标为i的元素值为i+1，即arr[i]=i+1，然后从前往后，不满足此条件的数即为所求
- 每次遍历时
- 交换的两个数字要么是同一个数字自己交换且这个数字已经在正确位置上；
- 交换的两个数字只有一个放到了正确位置上；
- 交换的两个数字两个都被放到了正确位置上。
问题3: 镜像二叉树非递归算法
import java.util.Stack;
public class Main {
public static void main(String[] args) {
//Scanner scanner = new Scanner(System.in);
}
private static void toMirrorTree(TreeNode root) {
if (root == null) {
return;
}
Stack<TreeNode> stack = new Stack<>();
stack.add(root);
while (!stack.isEmpty()) {
TreeNode tmp = stack.pop();
if (tmp.left != null || tmp.right != null) {
TreeNode t = tmp.left;
tmp.left = tmp.right;
tmp.right = t;
}
if (tmp.left != null) {
stack.add(tmp.left);
}
if (tmp.right != null) {
stack.add(tmp.right);
}
}
}
}
class TreeNode {
TreeNode left = null;
TreeNode right = null;
int val;
TreeNode(int val) {
this.val = val;
}
}
问题4：树的先序遍历非递归算法
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class Main {
public static void main(String[] args) {
//Scanner scanner = new Scanner(System.in);
TreeNode root = new TreeNode(1);
TreeNode c1 = new TreeNode(2);
TreeNode c2 = new TreeNode(3);
TreeNode c3 = new TreeNode(4);
root.left = c1;
root.right = c2;
c1.left = c3;
// 输出先序结果
List<Integer> preList = preInorder(root);
preList.forEach(i -> System.out.print(i + ","));
}
// 先序非递归
private static List<Integer> preInorder(TreeNode root) {
List<Integer> res = new ArrayList<>();
if (root == null) {
return res;
}
Stack<TreeNode> stack = new Stack<>();
while (root != null || !stack.isEmpty()) {
while (root != null) {
res.add(root.val);
stack.push(root);
root = root.left;
}
if (!stack.isEmpty()) {
root = stack.pop();
root = root.right;
}
}
return res;
}
}
class TreeNode {
TreeNode left = null;
TreeNode right = null;
int val;
TreeNode(int val) {
this.val = val;
}
}
问题5：树的中序遍历非递归算法
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class Main {
public static void main(String[] args) {
//Scanner scanner = new Scanner(System.in);
TreeNode root = new TreeNode(1);
TreeNode c1 = new TreeNode(2);
TreeNode c2 = new TreeNode(3);
TreeNode c3 = new TreeNode(4);
root.left = c1;
root.right = c2;
c1.left = c3;
// 输出先序结果
List<Integer> preList = preInorder(root);
preList.forEach(i -> System.out.print(i + ","));
}
// 中序非递归
private static List<Integer> preInorder(TreeNode root) {
List<Integer> res = new ArrayList<>();
if (root == null) {
return res;
}
Stack<TreeNode> stack = new Stack<>();
while (root != null || !stack.isEmpty()) {
while (root != null) {
stack.push(root);
root = root.left;
}
if (!stack.isEmpty()) {
root = stack.pop();
res.add(root.val);
root = root.right;
}
}
return res;
}
}
class TreeNode {
TreeNode left = null;
TreeNode right = null;
int val;
TreeNode(int val) {
this.val = val;
}
}
问题6：树的后序非递归算法[2个辅助栈，1个用于记录当前根节点是否可以被访问]
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class Main {
public static void main(String[] args) {
//Scanner scanner = new Scanner(System.in);
TreeNode root = new TreeNode(1);
TreeNode c1 = new TreeNode(2);
TreeNode c2 = new TreeNode(3);
TreeNode c3 = new TreeNode(4);
root.left = c1;
root.right = c2;
c1.left = c3;
// 输出先序结果
List<Integer> preList = preInorder(root);
preList.forEach(i -> System.out.print(i + ","));
}
// 后序非递归
private static List<Integer> preInorder(TreeNode root) {
List<Integer> res = new ArrayList<>();
if (root == null) {
return res;
}
Stack<TreeNode> stack = new Stack<>();
/**
* visited的值为1,表示stack的顶点可以被访问;为0不能被访问
*/
Stack<Integer> visited = new Stack<>();
final int canVis = 1;
final int cannotVis = 0;
while (root != null || !stack.isEmpty()) {
while (root != null) {
stack.push(root);
visited.push(cannotVis);
root = root.left;
}
while (!stack.isEmpty() && visited.peek() == canVis) {
TreeNode node = stack.pop();
visited.pop();
res.add(node.val);
}
if (!stack.isEmpty()) {
visited.pop();
visited.push(canVis);
root = stack.peek();
root = root.right;
}
}
return res;
}
}
class TreeNode {
TreeNode left = null;
TreeNode right = null;
int val;
TreeNode(int val) {
this.val = val;
}
}