java 有序数组 频率,高频算法题解 java

替换空格

public void replaceSpace(){

String s="abc de f ";

String t= s.replace(" ","%20");

System.out.println(t);

}

顺时针打印矩阵

import java.util.ArrayList;

import java.util.List;

public class SpiralMatrix {

public List spiralOrder(int[][] matrix) {

List list=new ArrayList<>();

int row=0;int col=0;

int rowlen=matrix.length-1;int collen=matrix[0].length-1;

while(row<=rowlen&&col<=collen) {

for (int j = col; j <= collen; j++) {

list.add(matrix[row][j]);

}

for(int i=row+1;i<=rowlen;i++){

list.add(matrix[i][rowlen]);

}

if(rowlen>row&&collen>col){

for(int j=collen-1;j>col;j--){

list.add(matrix[rowlen][j]);

}

for(int i=rowlen;i>row;i--){

list.add(matrix[i][row]);

}

}

row++;col++;rowlen--;collen--;

}

return list;

}

}

Ip的组成有几种

import java.util.ArrayList;

public class IpAddress {

public static void main(String[] args) {

String s = "25525511135";

System.out.println(restoreIpAddresses(s));

}

public static ArrayList restoreIpAddresses(String s) {

ArrayList res = new ArrayList();

if (s.length() < 4) return res;

for (int i = 1; i < 4 && i < s.length() - 2; i++) {

for (int j = i + 1; j < i + 4 && j < s.length() - 1; j++) {

for (int k = j + 1; k < j + 4 && k < s.length(); k++) {

String s1 = s.substring(0, i);

String s2 = s.substring(i, j);

String s3 = s.substring(j, k);

String s4 = s.substring(k, s.length());

if (isValid(s1) && isValid(s2) && isValid(s3) && isValid(s4)) {

res.add(s1 + "." + s2 + "." + s3 + "." + s4);

}

}

}

}

return res;

}

private static boolean isValid(String s) {

if (s.length() == 0 || s.length() > 3 || (s.charAt(0) == '0' && s.length() > 1) || Integer.parseInt(s) > 255)

return false;

return true;

}

}

二维字符矩阵找单词

import java.util.Scanner;

public class WordSearch {

public static void main(String[] args) {

Scanner sc=new Scanner(System.in);

int m=sc.nextInt();

int n=sc.nextInt();

char[][] board=new char[m][n];

for (int i = 0; i < m; i++) {

board[i] = sc.next().toCharArray();

}

String word = sc.next();

boolean res=exist(board,word);

System.out.println(res);

}

public static boolean exist(char[][] board, String word) {

int m = board.length;

int n = board[0].length;

boolean[][] visited = new boolean[m][n];

for (int i = 0; i < m; i++) {

for (int j = 0; j < n; j++) {

if (dfs(board, word, 0, i, j, visited))

return true;

}

}

return false;

}

public static boolean dfs(char[][] board, String word, int index, int rowindex, int colindex, boolean[][] visited) {

if (index == word.length())

return true;

if (rowindex < 0 || colindex < 0 || rowindex >=board.length || colindex >= board[0].length)

return false;

if (visited[rowindex][colindex])

return false;

if (board[rowindex][colindex] != word.charAt(index))

return false;

visited[rowindex][colindex] = true;

boolean res = dfs(board, word, index + 1, rowindex - 1, colindex,

visited)

|| dfs(board, word, index + 1, rowindex + 1, colindex, visited)

|| dfs(board, word, index + 1, rowindex, colindex + 1, visited)

|| dfs(board, word, index + 1, rowindex, colindex - 1, visited);

visited[rowindex][colindex] = false;

return res;

}

}

二十六进制加法

import java.util.ArrayList;

import java.util.Scanner;

public class Twentysix {

//全局变量进位

private static int jinWei = 0;

public static void main(String args[]) {

Scanner sc = new Scanner(System.in);

while (sc.hasNext()) {

System.out.println(hexPlus26(sc.next(), sc.next()));

}

}

private static String hexPlus26(String str1, String str2) {

ArrayList arr;

StringBuffer sbResult = new StringBuffer();

//将两个字符串用'a'从最高位补全，并为可能出现最长字符串最高位进一的情况，在最高位补一个a

if (str1.length() >= str2.length()) {

arr = completeStr(str1, str2);

} else {

arr = completeStr(str2, str1);

}

StringBuffer sb1 = arr.get(0);

StringBuffer sb2 = arr.get(1);

for (int i = sb1.length() - 1; i >= 0; i--) {

int plusResult = (int) sb1.charAt(i) - 97 + (int) sb2.charAt(i) - 97 + jinWei;

//如果发生进位，将全局变量jinWei改成1，并在下一次循环中加上，否则为0

if (plusResult > 25) {

sbResult.append(Character.toString((char) (plusResult - 26 + 97)));

jinWei = 1;

} else {

sbResult.append((char) (plusResult + 97));

jinWei = 0;

}

}

//如果最后没发生进位，去掉之前加的a

if (sbResult.charAt(sbResult.length() - 1) == 'a') {

sbResult.deleteCharAt(sbResult.length() - 1);

}

return sbResult.reverse().toString();

}

private static ArrayList completeStr(String str1, String str2) {

StringBuffer sb1 = new StringBuffer();

StringBuffer sb2 = new StringBuffer();

ArrayList arr = new ArrayList();

int lengthDiff = str1.length() - str2.length();

//为可能出现最长字符串最高位进一的情况，在最高位先补一个a(代表0)

sb1.append("a");

sb2.append("a");

//将两个字符串长度用a补齐

for (int i = 0; i < lengthDiff; i++) {

sb2.append("a");

}

//将原字符串加到最后边

sb1.append(str1);

sb2.append(str2);

arr.add(sb1);

arr.add(sb2);

return arr;

}

}

包围的区域

输入：

4

X X X X

X O O X

X X O X

X O X X

输出:

X X X X

X X X X

X X X X

X O X X

import java.util.Scanner;

public class SurroundedRegions {

public static void main(String[] args) {

Scanner sc =new Scanner(System.in);

int n=sc.nextInt();

char[][] board=new char[n][n];

for (int i=0;i

board[i]=sc.next().toCharArray();

}

if (board==null||board.length==0) return;

int row = board.length;

int col = board[0].length;

for(int j=0;j

dfs(board,0,j);

dfs(board,row-1,j); //第一行和最后一行

}

for(int i=1;i

dfs(board,i,0);

dfs(board,i,col-1); //第一列和最后一列抛去和上一个循环相交的格子

}

for(int i=0;i

for(int j=0;j

if (board[i][j]=='D') board[i][j] = 'O';

else if (board[i][j]=='O') board[i][j] = 'X';

}

for(int i=0;i

for(int j=0;j

System.out.print(board[i][j]);

}

System.out.println();

}

}

public static void dfs(char[][] board, int x, int y){

if (x<0||x>=board.length||y<0||y>=board[0].length||board[x][y]!='O') return;

board[x][y] = 'D';

dfs(board,x-1,y);

dfs(board,x+1,y);

dfs(board,x,y-1);

dfs(board,x,y+1);

}

}

完成数独

public class Solution {

public void solveSudoku(char[][] board) {

ArrayList empty = new ArrayList();

for(int i=0;i<9;i++)

for(int j=0;j<9;j++)

if(board[i][j]=='.'){

empty.add(i*9+j);

}

int len = empty.size();

dfs(empty,board,0,len);

}

public boolean dfs(ArrayList empty, char[][] board, int cur, int len){

if(cur==len) return true;

int index = empty.get(cur);

int row = index/9;

int col = index%9;

for(int v=1;v<=9;v++){

if(isValid(v,row,col,board)){

board[row][col] = (char)(v+'0');

if(dfs(empty,board,cur+1,len))

return true;

board[row][col] = '.';

}

}

return false;

}

public boolean isValid(int v, int row, int col, char[][] board){

for(int i=0;i<9;i++){

if(board[row][i] - '0'==v) return false;

if(board[i][col] - '0'==v) return false;

int row_s = 3*(row/3) + i/3;

int col_s = 3*(col/3) + i%3;

if(board[row_s][col_s] - '0'==v) return false;

}

return true;

}

}

N皇后问题

public class Solution {

public ArrayList solveNQueens(int n) {

ArrayList res = new ArrayList();

int[] loc = new int[n];

dfs(res,loc,0,n);

return res;

}

public void dfs(ArrayList res, int[] loc, int cur, int n){

if(cur==n)

printboard(res,loc,n);

else{

for(int i=0;i

loc[cur] = i;

if(isValid(loc,cur))

dfs(res,loc,cur+1,n);

}

}

}

public boolean isValid(int[] loc, int cur){

for(int i=0;i

if(loc[i]==loc[cur]||Math.abs(loc[i]-loc[cur])==(cur-i))

return false;

}

return true;

}

public void printboard(ArrayList res, int[] loc, int n){

String[] ans = new String[n];

for(int i=0;i

String row = new String();

for(int j=0;j

if(j==loc[i]) row += "Q";

else row += ".";

}

ans[i] = row;

}

res.add(ans);

}

}

验证一个字符串是否为回文

只看字母(忽略其它字符)，不分大小写。如“A man, a plan, a canal: Panama”就是一个回文

class Solution {

public boolean isPalindrome(String s) {

if(s.isEmpty()) return true;

String str = s.replaceAll("\\W", ""); // 使用正则去除非字符数字的字符

str = str.toLowerCase();

for(int i = 0; i < str.length(); i++) {

if(str.charAt(i) != str.charAt(str.length() - i -1)) {

return false;

}

}

return true;

}

}

二叉树的镜像

public boolean isSymmetric(TreeNode root) {

if (root == null) return true;

return isSymmetric(root.left, root.right);

}

private boolean isSymmetric(TreeNode t1, TreeNode t2) {

if (t1 == null && t2 == null) return true;

if (t1 == null || t2 == null) return false;

if (t1.val != t2.val) return false;

return isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left);

}

二叉树和为某一值的路径

public void findPath(BinaryTreeNode root,int k){

if(root == null)

return;

Stack stack = new Stack();

findPath(root,k,stack);

}

public void findPath(BinaryTreeNode root,int k,Stack path){

if(root == null)

return;

if(root.leftNode == null && root.rightNode == null){

if(root.value == k){

System.out.println("路径开始");

for(int i :path)

System.out.print(i+",");

System.out.print(root.value);

}

}

else{

path.push(root.value);

findPath(root.leftNode,k-root.value,path);

findPath(root.rightNode,k-root.value,path);

path.pop();

}

}

二叉树的最大深度

public static int maxDepth(TreeNode root) {

if(root==null){

return 0;

}

if(root.left==null){

return maxDepth(root.right)+1;

}

if(root.right==null){

return maxDepth(root.left)+1;

}

return max(maxDepth(root.left),maxDepth(root.right))+1;

}

有序数组去除重复数字

package array;

public class RemoveDuplicates {

public static void main(String[] args) throws Exception {

int[] nums = {1,1,2,3,3,4};

int N = new RemoveDuplicates().removeDuplicates(nums);

for (int i = 0; i < N; i++)

System.out.print(nums[i] + " ");

}

public int removeDuplicates(int[] nums) {

if (nums.length == 1) return 1;

int size = 1;

for (int j = 0, i = 1; i < nums.length; i++) {

if (nums[i] != nums[i - 1]) {

size++;

j++;

nums[j] = nums[i];

}

}

return size;

}

}

搜索旋转有序数组

package binarySearch;

// 时间复杂度 O(log n)，空间复杂度 O(1)

public class SearchRotated { public static void main(String[] args) throws Exception {

int[] A = {11,12,13,15,17,22,28,30,2,4,5,6,9};

System.out.println(new SearchRotated().search(A, 17));

}

public int search(int[] A, int target) {

if(A==null || A.length==0)

return -1;

int l = 0;

int r = A.length-1;

while(l<=r)

{

int m = (l+r)/2;

if(target == A[m])

return m;

if(A[m]

{

if(target>A[m] && target<=A[r])

l = m+1;

else

r = m-1;

}

else

{

if(target>=A[l] && target