文章目录
- 3.数组中的重复数字
- 4.二维数组中的查找
- 5.替换空格
- 6.从尾到头打印链表
- 7.重建二叉树（⭐）
- 8.用两个栈实现队列
- 10.青蛙跳台阶
3.数组中的重复数字
1.用set
HashSet set1=new HashSet();
for(int i=0;i<array.length;i++){
if(set1.contains(array[i])){
System.out.println(array[i]);
break;
}else{
set1.add(array[i]);
}
}
2.用一个数组代替哈希表
int []array={2,3,1,0,2,5,3};
int []hasharray=new int[array.length];
for(int i=0;i<array.length;i++){
if(hasharray[array[i]]>0){
System.out.println(array[i]);
break;
}else{
hasharray[array[i]]++; }
}
4.二维数组中的查找
1.从右上角查找
2.查找的范围是从左下角到目前节点的小矩形，注意边界问题
public class LC04 {
public static void main(String[] args) {
int matrix[][]={{1, 4, 7, 11, 15},{2,5,8,12,19},
{3,6,9,16,22},{10,13,14,17,24},{18,21,23,26,30}};
boolean ans= findNumberIn2DArray(matrix,50);
System.out.println(ans);
}
public static boolean findNumberIn2DArray(int[][] matrix, int target) {
int row=matrix.length;
int column=matrix[0].length;
int temp=matrix[0][column-1]; //右上角的元素
int i=0,j=column-1;
while(i<row&&j>=0){ //判断不越界
if(matrix[i][j]==target){
return true;
}
if(matrix[i][j]>target){
j--;
}else{
i++;
}
}
return false;
}
}
5.替换空格
public class Solution {
public static String replaceSpace(String s) {
StringBuilder sb=new StringBuilder();
for(int i=0;i<s.length();i++){
char c1=s.charAt(i);
//if(" ".equals(c1)){
if(c1==' '){
sb.append("%20");
}else{
sb.append(s.charAt(i));
}
}
return sb.toString();
}
public static void main(String[] args) {
//String s1=replaceSpace("We are happy.");
String s1="We are happy";
String s2=s1.replace(" ","%20");
System.out.println(s2);
}
}
针对于" “.equals(c1)判定失败的问题：
System.out.println(” “.equals(” “)); //true
System.out.println(” ".equals(’ ')); //false
因为c1是字符，所以不行。
replace和replaceAll是JAVA中常用的替换字符的方法
public String replace(char oldChar, char newChar) 在字符串中用newChar字符替代oldChar字符，返回一个新的字符串
public String replaceAll(String regex,String replacement)使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的每个子字符串。
区别：
1)replace的参数是char和CharSequence，即可以支持字符的替换，也支持字符串的替换(CharSequence即字符串序列的意思,说白了也就是字符串)；
2)replaceAll的参数是regex，即基于正则表达式的替换，比如，可以通过replaceAll(“\d”, “*”)把一个字符串所有的数字字符都换成星号;
相同点：
都是全部替换，即把源字符串中的某一字符或字符串全部换成指定的字符或字符串，如果只想替换第一次出现的，可以使用replaceFirst()，这个方法也是基于规则表达式的替换，但与replaceAll()不同的是，只替换第一次出现的字符串；
另外，如果replaceAll()和replaceFirst()所用的参数据不是基于规则表达式的，则与replace()替换字符串的效果是一样的，即这两者也支持字符串的操作；
还有一点注意:：执行了替换操作后,源字符串的内容是没有发生改变的。
6.从尾到头打印链表
因为是反向的输出，所以用栈。递归也可以
public class LC06 {
public static class ListNode {
int val;
ListNode next;
ListNode(int x) {
val = x;
}
}
public static int[] reversePrint(ListNode head) {
LinkedList<Integer> stack=new LinkedList<Integer>();
while(head!=null){
stack.addLast(head.val);
stack.add(head.val);
head=head.next;
}
int []ans=new int[stack.size()];
for(int i=0;i<ans.length;i++){
ans[i]=stack.removeLast();
}
return ans;
}
public static void main(String[] args) {
ListNode node1=new ListNode(1);
ListNode node2=new ListNode(2);
ListNode node3=new ListNode(3);
node1.next=node2;
node2.next=node3;
int[] a=reversePrint(node1);
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
}
7.重建二叉树（⭐）
树
~~~~~~~~
1
~~~~
2
~~~~
3
4
~~
5
~~
6
~~
7
前序 1 2 4 5 3 6 7
中序 4 2 5 1 6 3 7
public class LC07 {
public static class TreeNode{
int val;
TreeNode leftNode;
TreeNode rightNode;
TreeNode(int val){
this.val=val;
}
}
static HashMap<Integer, Integer> map = new HashMap<>();//标记中序遍历
static int []preorder;
public static TreeNode buildTree(int[] preorder, int[] inorder) {
LC07.preorder =preorder;
for (int i = 0; i < inorder.length; i++) {
//中序数组的值 -> 值在中序数组中的位置
map.put(inorder[i], i);
}
//三个索引分别为
//当前根的的索引
//递归树的左边界，即数组左边界
//递归树的右边界，即数组右边界
return recur(0,0,preorder.length-1);
}
static TreeNode recur(int pre_root, int in_left, int in_right){
if(in_left > in_right) return null;// 相等的话就是自己
TreeNode root = new TreeNode(preorder[pre_root]);//获取root节点
int idx = map.get(preorder[pre_root]); //获取在中序遍历中根节点所在索引，以方便获取左子树的数量
root.leftNode=recur(pre_root+1,in_left,idx-1);
//右子树的根的索引为先序中的 当前根位置 + 左子树的数量 + 1
root.rightNode=recur(pre_root+idx-in_left+1,idx+1,in_right);
return root;
}
public static void main(String[] args) {
int[] preorder={3,9,20,15,7};
int[] inorder={9,3,15,20,7};
TreeNode node1=buildTree(preorder,inorder);
bfs(node1);
}
public static void bfs(TreeNode node){
if(node!=null){
System.out.println(node.val);
bfs(node.leftNode);
bfs(node.rightNode);
}
}
}
8.用两个栈实现队列
如果出队列里有值，直接出值。出队列里没值了，再把入队列里的东西全塞进出队列里。
public class LC09 {
static class CQueue {
Stack<Integer> A,B;
public CQueue() {
A=new Stack<>();
B=new Stack<>();
}
public void appendTail(int value) {
A.add(value);
}
public int deleteHead() {
if(!B.isEmpty()){
return B.pop();
}
if(A.isEmpty()) return -1;
while(!A.isEmpty()){
B.push(A.pop());
}
return B.pop();
}
}
public static void main(String[] args) {
CQueue q1=new CQueue();
q1.appendTail(3);
System.out.println(q1.deleteHead());
System.out.println(q1.deleteHead());
System.out.println(q1.deleteHead());
}
}
10.青蛙跳台阶
public class LC10 {
public static int numWays(int n) {
if(n==0 || n==1) return 1;
int a=1,b=2;
int temp=2;
int ans1=b;
while(temp<n){
ans1=(a+b)%1000000007;
a=b;
b=ans1;
temp++;
}
return ans1;
}
public static void main(String[] args) {
System.out.println(numWays(7));
}
}
![[openCV]基于拟合中线的智能车巡线方案V3](https://img-blog.csdnimg.cn/6d6e0e96c2dc49d2b5af82306de736db.png)
