用Java实现一些简单算法

for循环,外循环控制的是行数,内循环控制的是每一行的个数。

1
2
3
4
5
6
7
8
9
10
11
*****
*****
*****
*****
for (int x = 0; x < 4; x++){// 外循环控制的是行数
for (int y = 0; y < 5; y++){// 内循环控制的是每一行的个数
System.out.print("*");
}
System.out.println();
}

-————————————–

1
2
3
4
5
6
7
8
9
10
11
12
*****
****
***
**
*
for (int x = 1; x <= 5; x++) {
for (int y = x; y <= 5; y++) {
System.out.print("*");
}
System.out.println();
}

-————————————–

1
2
3
4
5
6
7
8
9
10
11
12
*
**
***
****
*****
for (int x = 1; x <= 5; x++) {
for (int y = 1; y <= x; y++) {
System.out.print("*");
}
System.out.println();
}

-————————————–

54321
5432
543
54
5

1
2
3
4
5
6
for (int x = 1; x <= 5; x++) {
for (int y = 5; y >= x; y--) {
System.out.print(y);
}
System.out.println();
}

-————————————–

1
22
333
4444
55555

1
2
3
4
5
6
for (int x = 1; x <= 5; x++) {
for (int y = 1; y <= x; y++) {
System.out.print(x);
}
System.out.println();
}

-————————————–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
* * * * *
* * * *
* * *
* *
*
for (int x = 1; x <= 5; x++) {//分成左右两边,左边是空格,右边是*加空格
for (int y = 1; y < x; y++) {
System.out.print(" ");
}
for (int z = x; z <= 5; z++) {
System.out.print("* ");
}
System.out.println();
}

-————————————–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
*
* *
* * *
* * * *
* * * * *
for (int x = 1; x <= 5; x++) {
for (int y = x; y < 5; y++) {
System.out.print(" ");
}
for (int z = 1; z <= x; z++) {
System.out.print("* ");
}
System.out.println();
}

-————————————–

九九乘法表

1
2
3
4
5
6
for (int x = 1; x <= 9; x++) {
for (int y = 1; y <= x; y++) {
System.out.print(y + "*" + x + "=" + y * x + "\t");
}
System.out.println();
}

整型数组

遍历数组的功能

1
2
3
4
5
6
7
8
9
10
public static void printArray(int[] arr) {
System.out.print("[");
for (int x = 0; x < arr.length; x++) {
if (x != arr.length - 1) {
System.out.print(arr[x] + ",");
} else {
System.out.println(arr[x] + "]");
}
}
}

-————————————–

获取最大值

1
2
3
4
5
6
7
8
9
public static int getMax(int[] arr) {
int maxElement = arr[0];
for (int x = 0; x < arr.length; x++) {
if (arr[x] > maxElement) {
maxElement = arr[x];
}
}
return maxElement;
}

-————————————–

获取最大值2

1
2
3
4
5
6
7
8
9
public static int getMax_2(int[] arr) {
int maxIndex = 0;
for (int x = 0; x < arr.length; x++) {
if (arr[x] > arr[maxIndex]) {
maxIndex = x;
}
}
return arr[maxIndex];
}

-————————————–

置换

1
2
3
4
5
private static void swap(int[] arr, int a, int b) {
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}

-————————————–

反转

1
2
3
4
5
public static void reverseArray(int[] arr) {
for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
swap(arr, start, end);
}
}

-————————————–

冒泡排序

基本思路:相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处。依次类推

1
2
3
4
5
6
7
8
9
public static void bubbleSort(int[] arr) {
for (int x = 0; x < arr.length - 1; x++) {
for (int y = 0; y < arr.length - 1 - x; y++) {
if (arr[y] > arr[y + 1]) {
swap(arr, y, y + 1);
}
}
}
}

-————————————–

选择排序

基本思路: 把第一个元素依次和后面的所有元素进行比较。 第一次结束后,就会有最小值出现在最面。依次类推

1
2
3
4
5
6
7
8
9
public static void selectSort(int[] arr) {
for (int x = 0; x < arr.length - 1; x++) {
for (int y = x + 1; y < arr.length; y++) {
if (arr[x] > arr[y]) {
swap(arr, x, y);
}
}
}
}

-————————————–

选择排序2,记录索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void selectSort_2(int[] arr) {
for (int x = 0; x < arr.length - 1; x++) {
int num = arr[x];
int index = x;
for (int y = x + 1; y < arr.length; y++) {
if (num > arr[y]) {
num = arr[y];
index = y;
}
}
if (index != x) {
swap(arr, x, index);
}
}
}

-————————————–

二分查找(折半查找),数组必须有序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static int halfSearch(int[] arr, int key) {
int max = arr.length - 1;
int min = 0;
int mid = (max + min) / 2;
while (arr[mid] != key) {
if (key > arr[mid]) {
min = mid + 1;
} else if (key < arr[mid]) {
max = mid - 1;
}
if (max < min) {
return -1;
}
mid = (max + min) / 2;
}
return mid;
}

-————————————–

二分查找2,数组必须有序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static int halfSearch_2(int[] arr, int key) {
int max, min, mid;
min = 0;
max = arr.length - 1;
while (min <= max) {
mid = (min + max) >> 1;
if (key > arr[mid]) {
min = mid + 1;
} else if (key < arr[mid]) {
max = mid - 1;
} else {
return mid;
}
}
return -min - 1;
}

字符串

字符串数组置换

1
2
3
4
5
private static void swap(String[] arr, int a, int b) {
String temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}

给定一个字符串数组。按照字典顺序进行从小到大的排序。

1
2
3
4
5
6
7
8
9
public static void sortString(String[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i].compareTo(arr[j]) > 0) {
swap(arr, i, j);
}
}
}
}

-————————————–

一个子串在整串中出现的次数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//"nbaernbatynbauinbaopnba" “nba"
/* 思路:
* 1,要找的子串是否存在,如果存在获取其出现的位置。这个可以使用indexOf完成。
* 2,如果找到了,那么就记录出现的位置并在剩余的字符串中继续查找该子串,
* 而剩余字符串的起始位是出现位置+子串的长度.
* 3,以此类推,通过循环完成查找,如果找不到就是-1,并对每次找到用计数器记录。
*/
//方法一
public static int getKeyStringCount(String str, String key) {
// 定义计数器
int count = 0;
// 定义变量记录key出现的位置
int index = 0;
while ((index = str.indexOf(key)) != -1) {
str = str.substring(index + key.length());
count++;
}
return count;
}
//方法二
public static int getKeyStringCount_2(String str, String key) {
int count = 0;
int index = 0;
while ((index = str.indexOf(key, index)) != -1) {
index = index + key.length();
count++;
}
return count;
}

-————————————–

两个字符串中最大相同的子串。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/* "qwerabcdtyuiop" "xcabcdvbn"
* 思路: 1,既然取得是最大子串,先看短的那个字符串是否在长的那个字符串中。 如果存在,短的那个字符串就是最大**子串。
* 2,如果不是呢,那么就将短的那个子串进行长度递减的方式去子串,去长串中判断是否存在。 如果存在就已找到,就不*用在找了。
*/
public static String getMaxSubstring(String s1, String s2) {
String max = null, min = null;
max = (s1.length() > s2.length()) ? s1 : s2;
min = max.equals(s1) ? s2 : s1;
System.out.println("max=" + max);
System.out.println("min=" + min);
for (int i = 0; i < min.length(); i++) {
for (int a = 0, b = min.length() - i; b != min.length() + 1; a++, b++) {
String sub = min.substring(a, b);
// System.out.println(sub);
if (max.contains(sub))
return sub;
}
}
return null;
}

-————————————–

在一个字符串中,统计出现的整数的个数,连续的数字为一个整数(不考虑负数),字符串中不包含空格。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/**
* a10b20c30de40fg
* 思路:首先要遍历所有的字符,判断每个字符是不是数字,是数字的话就把它放在一个StringBuilder对象
* 里面并标记,下面一个字符要是数字就加在后面,不是数字的话,就把当前的StringBuilder里面的数字
* 塞到list里面,最后判断list长度即可
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.next();
scanner.close();
if (s != null && s.length() != 0) {
List<Integer> list = new ArrayList<Integer>();
StringBuilder sb = new StringBuilder();
boolean isChar = false;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c >= '0' && c <= '9') {
sb.append(s.charAt(i));
if (i == s.length() - 1) {
list.add(Integer.parseInt(sb.toString()));
sb.setLength(0);
}
isChar = false;
} else {
if (sb.length() > 0 && isChar == false) {
list.add(Integer.parseInt(sb.toString()));
sb.setLength(0);
}
isChar = true;
}
}
System.out.println(list.size());
}
}

如果要是换个问法也是一样的,统计一个字符串中出现整数的和,只需要在下面加入一个遍历list,把所有的数字加一起就好了。

1
2
3
4
5
6
7
if (list.size() > 0) {
int sum = 0;
for (int i = 0; i < list.size(); i++) {
sum = sum + list.get(i);
}
System.out.println(sum);
}