JAVA实现三种排序算法+二分查找算法

最新推荐文章于 2023-11-14 22:46:49 发布

忧郁之风

最新推荐文章于 2023-11-14 22:46:49 发布

阅读量267

点赞数

分类专栏： Java 文章标签：算法

Java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

冒泡排序
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
其核心思想是：
对于一组需要排序的数字，依次将个位置上的数字与逐一与其之后的数字进行比较，如果他们的顺序错误就把他们交换过来。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名。

package com.wip.sorting;
import java.util.Arrays;
public class BubbleSort {
/**
* 冒泡排序
* @param arr 需要排序的数组元素
* @param asc 是否升序
*/
public static void sort(int[] arr, boolean asc) {
for (int i = 0; i < arr.length; i++) {
for (int j = i+1; j < arr.length; j++) {
if (asc) {
if (arr[i] > arr[j]) {
swap(arr,i,j);
}
} else {
if (arr[i] < arr[j]) {
swap(arr,i,j);
}
}
}
}
}

/**
* 交换数组中的两个元素的位置
* @param arr // 数组
* @param i // 变量i
* @param j // 变量j
*/
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}

public static void main(String[] args) {
int[] arr = {1,3,2,5,9,10,53,33,55};
System.out.println("排序数组：" + Arrays.toString(arr));
sort(arr,true);
System.out.println("升序排列：" + Arrays.toString(arr));
sort(arr,false);
System.out.println("降序排序：" + Arrays.toString(arr));
}
}
// 输出结果
排序数组：[1, 3, 2, 5, 9, 10, 53, 33, 55]
升序排列：[1, 2, 3, 5, 9, 10, 33, 53, 55]
降序排序：[55, 53, 33, 10, 9, 5, 3, 2, 1]
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
选择排序
选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。

package com.wip.sorting;
import java.util.Arrays;
public class SelectSort {

/**
* 选择排序
* @param arr 排序的数组
* @param asc 是否升序
*/
public static void sort(int[] arr, boolean asc) {
for (int i = 0; i < arr.length; i++) {
int index = i;
for (int j = i + 1; j < arr.length; j++) {
if (asc) {
if (arr[index] > arr[j]) { // 升序，选择无序区最小的元素
index = j;
}
} else {
if (arr[index] < arr[j]) {// 降序，选择无序区最大的元素
index = j;
}
}
}
if (index != i) {
swap(arr,index,i);
}
}

}

public static void main(String[] args) {
int[] arr = {1,3,23,8,10,34,13,56};
System.out.println("排序数组：" + Arrays.toString(arr));
sort(arr, true);
System.out.println("升序排列：" + Arrays.toString(arr));
sort(arr, false);
System.out.println("降序排列：" + Arrays.toString(arr));

}
}

// 输出结果
排序数组：[1, 3, 23, 8, 10, 34, 13, 56]
升序排列：[1, 3, 8, 10, 13, 23, 34, 56]
降序排列：[56, 34, 23, 13, 10, 8, 3, 1]
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
插入排序
插入排序(Insert Sort)将待排序的数组分为2部分：有序区，无序区。其核心思想是每次取出无序区中的第一个元素，插入到有序区中。有序与无序区划分，就是通过一个变量标记当前数组中，前多少个元素已经是局部有序了。

package com.wip.sorting;
import java.util.Arrays;
public class InsertSort {
/**
* 插入排序
* @param arr 排序数组
* @param asc 是否升序
*/
public static void sort(int[] arr, boolean asc) {
// 有序区最后一个元素位置
int orderedLastIndex = 0;//开始排序时，将有序区结束位置设为0 (开始位置总是0)，对应的无序区范围就是 1-arr.length
for (int i = orderedLastIndex + 1; i < arr.length; i++) {//迭代无序区中的每一个元素，依次插入有序区中
int temp = arr[i];//记录无序区中的第一个元素值
int insertIndex = i;//在有序区中插入的索引的位置，刚开始就设置为自己的位置
for (int j = orderedLastIndex; j >= 0; j--) {//从有序区从后往前开始比较
if (asc) {//升序，有序区中比当前无序区中元素大的都右移一个位置
if (arr[j] > temp) {
arr[j+1] = arr[j];
insertIndex --;//有序区每移动一次，将插入位置-1
} else {
break;//有序区当前位置元素<=无序区第一个元素，那么之前的元素都会<=，不需要继续比较
}
} else {//降序，有序区中比当前无序区中元素小的都右移一个位置
if (arr[j] < temp) {
arr[j+1] = arr[j];
insertIndex --;
} else {
break;
}
}
}
arr[insertIndex] = temp;
orderedLastIndex ++;
}
}

public static void main(String[] args) {
int[] arr = {1,8,3,2,10,34,67,93,11};
System.out.println("排序数组：" + Arrays.toString(arr));
sort(arr,true);
System.out.println("升序数组：" + Arrays.toString(arr));
sort(arr,false);
System.out.println("降序数组：" + Arrays.toString(arr));

}
}

// 输出结果
排序数组：[1, 8, 3, 2, 10, 34, 67, 93, 11]
升序数组：[1, 2, 3, 8, 10, 11, 34, 67, 93]
降序数组：[93, 67, 34, 11, 10, 8, 3, 2, 1]
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
高级二分查找
1.二分查找以称折半查找，优点是比较次数少，查找速度快，平均性能好。
2.其缺点是要求待查表为有序表。
3.二分查找的目的是查找元素索引，有个前提是数组元素必须为有序。

package com.wip.sorting;
public class BinarySearch {
/**
* 获取某个数在数组里出现在位置
* @param arr // 数组
* @param num // 要找的数
* @return
*/
public static int getIndex(int[] arr, int num) {
int min = 0;
int max = arr.length - 1;
int mid = (min + max) /2;
System.out.println("min: " + min + " mid: " + mid + " max: " + max);

// 查找的算法
int index = -1; // 如果算到最后，index人值没有改变，代表num在arr中不存在

while (true) {

if (arr[mid] == num) {// 找到查找的数
index = mid;
break;
}

if (arr[mid] > num) {// num 在左边
max = mid - 1;
mid = (min + max) / 2;
}

if (arr[mid] < num) {// num 在右边
min = mid + 1;
mid = (min + max) / 2;
}

if (min > max) { // 不符合逻辑
break;// 退出循环
}
}
return index;
}

public static void main(String[] args) {
int[] arr = {11,22,33,89,34,66};
int num = 33;
if (getIndex(arr, num) == -1) {
System.out.println(num + " 在数组中不存在");
} else {
System.out.println(num + "索引位置: " + getIndex(arr, num)); //33索引位置: 2
}
}
}

---------------------
作者：KyrieCao
来源：CSDN
原文：https://blog.csdn.net/qq_22067469/article/details/82149421
版权声明：本文为博主原创文章，转载请附上博文链接！

忧郁之风

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA实现三种排序算法+二分查找算法

冒泡排序冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。其核心思想是：对于一组需要排序的数字，依次将个位置上的数字与逐一与其之后的数字进行比较，如果他们的顺序错误就把他们交换过来。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名。package com.wip.sorting;import java.util.Arrays;p...
复制链接

扫一扫