Java笔记4

**

二维数组

**
二维数组，在表现形式上就是一个表格，在操作表格的时候以行列来操作

所谓的二维数组，本质上就是一个一维数组，只不过该一维数组里面的元素是另一个一维数组而已
二维数组的定义

public class Sample {
public static void main(String[] args) {
//数据类型[][] 矩阵名 = new 数据类型[row][col];
int[][] matrix = new int[3][2];
/*
数据类型[][] 矩阵名 = new 数据类型[][] {
{...},
{...},
{...}
};
数据类型[][] 矩阵名 = {
{...},
{...},
{...}
};
*/
int[][] matrix2 = {
{1,2,3},
{4,5,6},
{7,8,9}
};
for (int i = 0; i < matrix2.length; i++) {
for (int j = 0; j < matrix2[i].length; j++) {
System.out.print(matrix2[i][j] + " ");
}
System.out.println();
}
int[][] matrix3 = {
{1},
{1,2,3},
{1,2,3,4},
{7,6,5,4,3,2,1}
};
for (int i = 0; i < matrix3.length; i++) {
for (int j = 0; j < matrix3[i].length; j++) {
System.out.print(matrix3[i][j] + " ");
}
System.out.println();
}
}
}

输入8个点坐标，然后计算这些点中，那两个点的距离是最近的

import java.util.Scanner;
public class Sample {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
double[][] points = new double[8][2];
//1.获取输入的点坐标
for (int i = 0; i < points.length; i++) {
System.out.print("请输入第" + (i + 1) + "个点坐标:");
points[i][0] = input.nextDouble();
points[i][1] = input.nextDouble();
}
double shortestDistance = getDistance(points,0,1);
int p1 = 0;
int p2 = 1;
for (int i = 0; i < points.length - 1; i++) {
for (int j = i + 1; j < points.length; j++) {
double distance = getDistance(points,i,j);
if (distance < shortestDistance) {
shortestDistance = distance;
p1 = i;
p2 = j;
}
}
}
System.out.printf("(%.1f,%.1f)和(%.1f,%.1f)的距离为最短%.1f",points[p1]
[0],points[p1][1],points[p2][0],points[p2][1],shortestDistance);
}
public static double getDistance(double[][] m , int p1 , int p2) {
return Math.hypot(m[p1][0] - m[p2][0] , m[p1][1] - m[p2][1]);
}
}

import java.util.Scanner;
public class Demo82 {
public static void main(String[] args) {
//输入数字1~100
int[] arr = new int[101];//0 1~100
Scanner input = new Scanner(System.in);
System.out.print("Enter numbers:");
while (true) {
int num = input.nextInt();
if (num == 0) {
break;
}
arr[num]++;
}
for (int i = 1; i < arr.length; i++) {
if (arr[i] != 0) {
if (arr[i] == 1) {
System.out.println(i + " occurs " + arr[i] + " time");
} else {
System.out.println(i + " occurs " + arr[i] + " times");
}
}
}
}
}

import java.util.*;
public class Demo83 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Enter 10 numbes:");
/*思路1：动态扩容数组*/
/*
int[] arr = new int[0];
for (int i = 0; i < 10; i++) {
int num = input.nextInt();
if (!contains(arr,num)) {
arr = add(arr,num);
}
}
System.out.println(Arrays.toString(arr));
*/
/*思路2：固定数组长度 用标记表示有效数据 */
int[] arr = new int[10];
int size = 0; //表示有效数据的个数 和新元素进入的角标
for (int i = 0; i < 10; i++) {
int num = input.nextInt();
if (!contains(arr,num,size)) {
arr[size++] = num;
}
}
System.out.println(toString(arr,size));
}
public static String toString(int[] arr,int size) {
if (size == 0) {
return "[]";
}
String s = "[";
for (int i = 0; i < size; i++) {
if (i == size - 1) {
s += arr[i] + "]";
} else {
s += arr[i] + ", ";
}
}
return s;
}
public static boolean contains(int[] arr, int num,int size) {
for (int i = 0; i < size; i++) {
if (arr[i] == num) {
return true;
}
}
return false;
}
public static int[] add(int[] arr, int num) {
int[] newArr = new int[arr.length + 1];
for (int i = 0; i < arr.length; i++) {
newArr[i] = arr[i];
}
newArr[newArr.length - 1] = num;
return newArr;
}
public static boolean contains(int[] arr, int num) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == num) {
return true;
}
}
return false;
}
}

public class Demo85 {
public static void main(String[] args) {
System.out.println(gcd(35,40,55,30,25));
System.out.println(gcd(28,16));
}
public static int gcd(int ... numbers) {
int min = getMin(numbers);
for (int i = min; i >= 1; i--) {
boolean flag = true;
for (int j = 0; j < numbers.length; j++) {
if (numbers[j] % i != 0) {
flag = false;
break;
}
}
if (flag) {
return i;
}
}
return 1;
}
public static int getMin(int[] numbers) {
int min = numbers[0];
for (int i = 1; i < numbers.length; i++) {
if (numbers[i] < min) {
min = numbers[i];
}
}
return min;
}
}

import java.util.*;
public class Demo88 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Random random = new Random();
System.out.print("请输入球的个数：");
int balls = input.nextInt();
System.out.print("请输入槽子的个数：");
int slots = input.nextInt();
int[] temp = new int[slots]; //槽子的数组
//路径的个数
String[] paths = new String[balls];
for (int i = 0; i < paths.length; i++) {
String path = "";
int rCount = 0;
//拼接每一个路径
for (int j = 0; j < slots - 1; j++) {
if (random.nextInt(2) == 0) {
path += "L";
} else {
path += "R";
rCount++;
}
}
paths[i] = path;
System.out.println(path);
temp[rCount]++;
}
System.out.println(Arrays.toString(temp));
}
}

import java.util.*;
public class Demo90 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入数字的个数：");
int len = input.nextInt();
int[] arr = new int[len];
System.out.print("请输入数字：");
for (int i = 0; i < arr.length; i++) {
arr[i] = input.nextInt();
}
for (int i = 0; i < arr.length - 3;) {
int count = 1;
int j = 0;
for ( j = i + 1; j < arr.length; j++) {
if (arr[j] == arr[i]) {
count++;
} else {
break;
}
}
if (count >= 4) {
System.out.println("有！");
return;
} else {
i = j;
}
}
System.out.println("没有！");
}
}

import java.util.*;
public class Demo91 {
public static void main(String[] args) {
int[] arr1 = {1,3,5,7,9};
int[] arr2 = {2,4,6,8,10};
int[] arr3 = merge(arr1,arr2);
System.out.println(Arrays.toString(arr3));
}
public static int[] merge(int[] arr1,int[] arr2) {
int[] arr3 = new int[arr1.length + arr2.length];
int p1 = 0;
int p2 = 0;
int p3 = 0;
while (p1 < arr1.length || p2 < arr2.length) {
if (p1 < arr1.length && p2 >= arr2.length) {
arr3[p3++] = arr1[p1++];
} else if (p1 >= arr1.length && p2 < arr2.length) {
arr3[p3++] = arr2[p2++];
} else if (arr1[p1] < arr2[p2]) {
arr3[p3++] = arr1[p1++];
} else {
arr3[p3++] = arr2[p2++];
}
}
return arr3;
}
}

import java.util.*;
public class Demo92 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Random random = new Random();
String[] words = {"banana","orange","python","apple","computer"};
while (true) {
//1.随机抽取一个单词
String word = words[random.nextInt(words.length)];
//2.创建该单词的状态数组
boolean[] statues = new boolean[word.length()];
int missed = 0; //错误的次数
//开始下一个字母的输入
while (!isOver(statues)) {
//3.按照状态数组获取提示的密文
String password = getPassword(word,statues);
//4.提示用户输入一个字母
System.out.print("Enter a letter " + password + ":" );
String letter = input.nextLine();
//5.判断这个字母是否出现在字符串中
if (word.contains(letter)) {
//6.改变字母的状态
if (!changeStatues(word,letter,statues)) {
System.out.println("\t" + letter + " is alreay in the word");
}
} else {
System.out.println("\t" + letter + " is not in the word");
missed++;
}
}
System.out.println("The word is " + word + ". You missed " + missed);
System.out.print("Do you again?(y/n)");
String choice = input.nextLine();
if (choice.equals("n")) {
break;
}
}
}
public static boolean changeStatues(String word,String letter,boolean[] statues) {
//"a" -> 'a'
char ch = letter.charAt(0);
for (int i = 0; i < word.length(); i++) {
if (word.charAt(i) == ch) {
if (statues[i]) { //如果字符所在的角标i对应的状态已经是true 表示此次没有改变成
功-重复输入的字符
return false;
} else {
statues[i] = true;
}
}
}
return true;
}
public static boolean isOver(boolean[] statues) {
for (int i = 0; i < statues.length; i++) {
if (!statues[i]) {
return false;
}
}
return true;
}
public static String getPassword(String word,boolean[] statues) {
String password = "";
for (int i = 0; i < statues.length; i++) {
if (statues[i]) {
password += word.charAt(i);
} else {
password += "*";
}
}
return password;
}
}

import java.util.Scanner;
public class Demo101 {
//1.创建一个棋盘
public static String[][] board = new String[15][15];
//玩家轮流计数
public static int player = 0;
//黑棋和白棋
public static String BLACK_CHESS = "O";
public static String WHITE_CHESS = "X";
public static Scanner input = new Scanner(System.in);
public static void main(String[] args) {
//2.给棋盘的每一个元素要赋值+
initBoard();
printBoard();
//3.开始下棋
startGame();
}
public static void startGame() {
while (!isGameOver()) {
if (player % 2 == 0) {
//黑方下棋
System.out.println(">>>请黑方下棋");
playChess(BLACK_CHESS);
} else {
//白方下棋
System.out.println(">>>请白方下棋");
playChess(WHITE_CHESS);
}
player++;
}
if (player == 15 * 15) {
System.out.println(">>>和棋，游戏结束！");
} else {
if ((player - 1) % 2 == 0) {
System.out.println(">>>黑胜！游戏结束！");
} else {
System.out.println(">>>白胜！游戏结束！");
}
}
}
public static boolean isGameOver() {
for (int row = 0; row < board.length; row++) {
for (int col = 0; col < board[row].length; col++) {
if (!board[row][col].equals("+")) {
//向右
if (col < 11) {
boolean flag = true;
for (int c = col + 1; c <= col + 4; c++) {
if (!board[row][col].equals(board[row][c])) {
flag = false;
break;
}
}
if (flag) {
return true;
}
}
//向下
if (row < 11) {
boolean flag = true;
for (int r = row + 1; r <= row + 4; r++) {
if (!board[row][col].equals(board[r][col])) {
flag = false;
break;
}
}
if (flag) {
return true;
}
}
//向右上
if (row > 3 && col < 11) {
boolean flag = true;
for (int r = row - 1 , c = col + 1; c <= col + 4; r-- , c++) {
if (!board[row][col].equals(board[r][c])) {
flag = false;
break;
}
}
if (flag) {
return true;
}
}
//向右下
if (row < 11 && col < 11) {
boolean flag = true;
for (int r = row + 1 , c = col + 1; c <= col + 4; r++ , c++) {
if (!board[row][col].equals(board[r][c])) {
flag = false;
break;
}
}
if (flag) {
return true;
}
}
}
}
}
if (player == 15 *15) {
return true;
}
return false;
}
public static void playChess(String chess) {
System.out.print(">>>请输入棋子坐标:");
int x = input.nextInt() - 1;
int y = input.nextInt() - 1;
if (!board[x][y].equals("+")) {
System.out.println(">>>此处已有棋子，请重新下棋！");
player--;
return;
}
board[x][y] = chess;
printBoard();
}
public static void printBoard() {
System.out.print(" ");
for (int i = 1; i <= board[0].length; i++) {
System.out.printf("%-2d",i);
}
System.out.println();
for (int i = 0; i < board.length; i++) {
System.out.printf("%2d ",i + 1);
for (int j = 0; j < board[i].length; j++) {
System.out.print(board[i][j] + " ");
}
System.out.println();
}
}
public static void initBoard() {
for (int i = 0; i < board.length; i++) {
for (int j = 0; j < board[i].length; j++) {
board[i][j] = "+";
}
}
}
}

八皇后问题

public class NQueen{
public static int N = 8;
public static int[][] board = new int[N][N];
public static int count = 0;
public static void main(String[] args) {
nqueen(0);
}
public static void nqueen(int row) {
if (row == N) {
count++;
System.out.printf("这是第%d种解法：\n",count);
for (int i = 0; i < board.length; i++) {
for (int j = 0; j < board[i].length; j++) {
System.out.print(board[i][j] + " ");
}
System.out.println();
}
} else {
for (int col = 0; col < N; col++) {
if (!isDangerous(row,col)) {
for (int c = 0; c < N; c++) {
board[row][c] = 0;
}
board[row][col] = 1;
nqueen(row + 1);
}
}
}
}
public static boolean isDangerous(int row ,int col) {
//向上
for (int r = row - 1;r >= 0; r--) {
if (board[r][col] == 1) {
return true;
}
}
//向左上
for (int r = row - 1,c = col - 1; r >= 0 && c >= 0;r--,c--) {
if (board[r][c] == 1) {
return true;
}
}
//向右上
for (int r = row - 1,c = col + 1; r >= 0 && c < N; r--,c++) {
if (board[r][c] == 1) {
return true;
}
}
return false;
}
}

LeetCode66
给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

import java.util.*;
class Solution {
public int[] plusOne(int[] digits) {
int carry = 1; //最开始的进位 给个位加的
for (int i = digits.length - 1; i >= 0; i--) {
int num = digits[i] + carry;
digits[i] = num % 10;
carry = num / 10;
if (carry == 0) {
break;
}
}
if (carry == 1) {
int[] arr = new int[digits.length + 1];
arr[0] = 1;
return arr;
}
return digits;
}
/* 升级版
[3,7,6]
[4,5,6]
8 3 2
[3,7,6]
[9,5,6]
1 3 3 2
[1,2,3]
[8,9,8,8,7]
9 0 0 1 0
[1,2,3]
[9,9,8,8,7]
1 0 0 0 1 0
*/
public int[] plus(int[] digits1 , int[] digits2) {
if (digits1.length < digits2.length) {
digits1 = kuorong(digits1,digits2.length);
} else if (digits1.length > digits2.length){
digits2 = kuorong(digits2,digits1.length);
}
int carry = 0;
for (int i = digits1.length - 1; i >= 0; i--) {
int num = digits1[i] + digits2[i] + carry;
carry = num / 10;
digits1[i] = num % 10;
}
if (carry == 1) {
int[] digits3 = new int[digits1.length + 1];
digits3[0] = 1;
for (int i = 0; i < digits1.length; i++) {
digits3[i + 1] = digits1[i];
}
return digits3;
}
return digits1;
}
public int[] kuorong(int[] arr, int newLen) {
//arr 1 2 3
// i
//nrr 0 0 1 2 3
// k
int[] newArr = new int[newLen];
int i = arr.length - 1;
int k = newArr.length - 1;
while (i >= 0) {
newArr[k--] = arr[i--];
}
return newArr;
}
public static void main(String[] args) {
Solution s = new Solution();
int[] arr1 = {1,2,3};
int[] arr2 = {9,8,7};
int[] arr3 = s.plus(arr1,arr2);
System.out.println(Arrays.toString(arr3));
}
}

LeetCode283
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

import java.util.*;
class Solution {
public void moveZeroes(int[] nums) {
//思路1：选择排序的思路
/*
for (int i = 0; i < nums.length - 1; i++) {
for (int j = i + 1; j < nums.length; j++) {
if (nums[i] == 0 && nums[j] != 0) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
break;
}
}
}
*/
//思路2：插入排序的思路
/*
for (int i = 1; i < nums.length; i++) {
if (nums[i] == 0) {
continue;
}
for (int j = i; j > 0 && nums[j - 1] == 0 ;j--) {
int temp = nums[j];
nums[j] = nums[j - 1];
nums[j - 1] = temp;
}
}
*/
//思路3：双指针做法 k一直卡着第一个0
int k = 0;
int temp = 0;
for (int i = 0; i < nums.length; i++) {
if (nums[i] != 0) {
temp = nums[i];
nums[i] = nums[k];
nums[k] = temp;
k++;
}
}
}
}

LeetCode169
给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素

import java.util.*;
class Solution {
public int majorityElement(int[] nums) {
//思路1：插入排序做 排序之后中间的位置一定是众数
/*
for (int i = 0; i < nums.length; i++) {
int e = nums[i];
int j = 0;
for (j = i; j > 0 && nums[j - 1] > e; j--) {
nums[j] = nums[j - 1];
}
nums[j] = e;
}
return nums[nums.length / 2];
*/
//思路2：正负相消
int m = nums[0];
int count = 1;
for (int i = 1; i < nums.length; i++) {
if (nums[i] == m) {
count++;
} else {
count--;
if (count == 0) {
m = nums[i];
count = 1;
}
}
}
return m;
}
}

LeetCode905
给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。

import java.util.*;
class Solution {
public int[] sortArrayByParity(int[] A) {
int l = 0;
int r = A.length - 1;
while (l < r) {
//左奇右偶
if (A[l] % 2 == 1 && A[r] % 2 == 0) {
int temp = A[l];
A[l] = A[r];
A[r] = temp;
//左偶右奇
} else if (A[l] % 2 == 0 && A[r] % 2 == 1) {
l++;
r--;
//左奇右奇
} else if (A[l] % 2 == 1 && A[r] % 2 == 1) {
r--;
} else {
l++;
}
}
return A;
}
}

LeetCode1013
给你一个整数数组 A，只有可以将其划分为三个和相等的非空部分时才返回 true，否则返回 false。

形式上，如果可以找出索引 i+1 < j 且满足 A[0] + A[1] + … + A[i] == A[i+1] + A[i+2] + … + A[j-1] == A[j] + A[j-1] + … + A[A.length - 1] 就可以将数组三等分。

class Solution {
public boolean canThreePartsEqualSum(int[] arr) {
int sum = 0;
for (int num : arr) {
sum += num;
}
int key = sum / 3;
int group = 0;
for (int i = 0; i < arr.length; i++) {
key -= arr[i];
if (key == 0) {
group++;
key = sum / 3;
}
}
return group == 3 || sum == 0 && group >= 3;
}
}

LeetCode724
给定一个整数类型的数组 nums，请编写一个能够返回数组 “中心索引” 的方法。

我们是这样定义数组 中心索引 的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。

如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。

class Solution {
public int pivotIndex(int[] nums) {
int sum = 0;
for (int num:nums) {
sum += num;
}
int leftSum = 0;
int rightSum = 0;
for (int i = 0; i < nums.length; i++) {
if (i == 0) {
leftSum = 0;
} else {
leftSum += nums[i - 1];
}
rightSum = sum - leftSum -nums[i];
if (rightSum == leftSum) {
return i;
}
}
return -1;
}
}

LeetCode209
给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

class Solution {
public int minSubArrayLen(int s, int[] nums) {
int len = 0;
int i = 0;
int sum = 0;
for (int j = 0; j < nums.length; j++) {
sum += nums[j];
while (sum >= s) {
len = len == 0 ? (j - i + 1) : Math.min(j - i + 1,len);
sum -= nums[i];
i++;
}
}
return len;
}
}