本文介绍了Java中数组排序（包括冒泡排序和Arrays工具类排序）、无序数组查找（遍历查找和双指针查找）、有序数组查找（二分查找）以及数组乱序（Fisher-Yates洗牌）和旋转的基本概念和实现方法。
目录
数组排序
冒泡排序
对数组进行排序是程序中非常基本的需求。常用的排序算法有冒泡排序、插入排序和快速排序等。在后续的算法课程中，我们会详细学习其它排序算法。在基础语法阶段，我们首先掌握如何使用冒泡排序算法对一个整型数组从小到大进行排序：
实现步骤
1.比较相邻的元素。如果第一个比第二个大，就交换位置。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个元素。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
冒泡排序的特点是，每一轮循环后，最大的一个数被交换到末尾，因此，下一轮循环就可以“排除”最后的数，每一轮循环都比上一轮循环的结束位置靠前一位。
N个数字来排序
俩俩比较小靠前
总共比较N-1轮
每轮比较N-1-i次
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] ns = { 5, 2, 6, 7, 8, 3, 1, 9, 4 };
// 排序前
System.out.println("排序前:" + Arrays.toString(ns));
for (int i = 0 ,n = ns.length; i < n - 1; i++) {
for (int k = 0; k < n - 1 - i ; k++) {
if (ns[k] > ns[k+1]) {
// 交换ns[k]和ns[k+1]:
int tmp = ns[k];
ns[k] = ns[k+1];
ns[k+1] = tmp;
}
}
}
// 排序后
System.out.println("排序后:" + Arrays.toString(ns));
}
}使用Arrays工具类排序
实际上，Java的标准库已经内置了排序功能，我们只需要调用Arrays.sort()就可以排序：
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
// 排序前
System.out.println("排序前:" + Arrays.toString(ns));
// 排序
Arrays.sort(ns);
// 排序后
System.out.println("排序后:" + Arrays.toString(ns));
}
}无序数组查找
无序数组查找元素
在一个无序数组中，如果需要进行指定元素的查找，可以通过循环遍历或Arrays工具类两种方式进行查找。
遍历查找
遍历的方式进行查找：可以通过对该无序数组进行遍历，将数组中的每个元素与指定元素进行比较，从而确定该数组中是否存在指定元素。
整型数组
int[] array = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
int target = 36; // 目标元素
int index = -1; // 目标元素下标，默认为-1，代表不存在
// 遍历查找
for (int i = 0; i < array.length; i++) {
if(array[i] == target) {
index = i;
break;
}
}
System.out.printf("目标值%d在数组中的下标为：%d",target,index);字符串数组
String[] singerArray = { "李荣浩", "盘尼西林", "王菲", "王贰浪", "鹿先森乐队", "孙燕姿", "G.E.M.邓紫棋", "方大同", "品冠儿子" };
Scanner input = new Scanner(System.in);
String target = "方大同";
int index = -1;
// 遍历查找
for (int i = 0; i < singerArray.length; i++) {
// 字符串等值判断使用equals()方法
if(target.equals(singerArray[i])) {
index = i;
break;
}
}双指针遍历查找
双指针遍历的方式进行查找：通过两个下标，分别从数组头部和尾部，同时对该无序数组进行遍历，将数组中的每个元素与指定元素进行比较，从而确定该数组中是否存在指定元素。
整型数组
int[] array = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
int target = 7; // 目标元素
int index = -1; // 目标元素下标，默认为-1，代表不存在
// 双指针查找
for (int i = 0, k = array.length - 1; i <= k; i++, k--) {
if (array[i] == target) {
index = i;
break;
}
if (array[k] == target) {
index = k;
break;
}
}
System.out.printf("目标值%d在数组中的下标为：%d", target, index);字符串数组
String[] singerArray = { "李荣浩", "盘尼西林", "王菲", "王贰浪", "鹿先森乐队", "孙燕姿", "G.E.M.邓紫棋", "方大同", "品冠儿子" };
String target = "方大同";
int index = -1;
// 双指针查找
for (int i = 0, k = singerArray.length - 1; i <= k; i++, k--) {
// 字符串等值判断使用equals()方法
if(target.equals(singerArray[i])) {
index = i;
break;
}
// 字符串等值判断使用equals()方法
if(target.equals(singerArray[k])) {
index = k;
break;
}
}Arrays工具类的binarySearch()方法
除了遍历查找，还可以通过调用Arrays.binarySearch()的方法，进行查找：由于该方法是基于二分查找法实现，数组必须处于有序状态。所以，需要先对数组进行排序，然后再通过Arrays.binarySearch()进行查找。
public class Main {
public static void main(String[] args) {
int[] array = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
int target = 36; // 目标元素
// 先排序
Arrays.sort(array);
// 再查找
int index = Arrays.binarySearch(array, target);
System.out.printf("目标值%d在数组中的下标为：%d",target,index);
}
}有序数组查找（二分）
二分查找元素
1.判断搜索数组的“中位元素”与要查找的“目标元素”是否相等。
a.如果相等，代表查找成功，退出算法；
b.如果不相等，继续比较“中位元素”与要查找的“目标元素”的大小关系；
ⅰ.如果“中位元素”大于“目标元素”，当前数组的前半部分作为新的搜索数组，因为后半部分的所有元素都大于“目标元素”，它们全都被排除了。
ⅱ.如果“中位元素”小于“目标元素”，当前数组的后半部分作为新的搜索数组，因为前半部分的所有元素都小于“目标元素”，它们全都被排除了。
2.在新的搜索数组上，重新开始第1步的工作。
public class Main {
public static void main(String[] args) {
int[] array = { 1,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59 };
int target = 37; // 目标元素
int index = -1; // 目标元素的下标，默认为-1，代表不存在
// low和high分别代表搜索数组的开始下标与结束下标
// 默认搜索数组是整个数组
int low = 0, high = array.length - 1;
while (low <= high) {
// 计算"中位元素"的下标
int mid = (high + low) / 2;
if (array[mid] == target) {
// 如果"中位元素"等于"目标元素"，查找成功，退出
index = mid;
break;
} else if (array[mid] < target) {
// 如果"中位元素"小于"目标元素"，当前数组的后半部分作为新的搜索数组
low = mid + 1;
} else if (array[mid] > target) {
// 如果"中位元素"大于"目标元素"，当前数组的前半部分作为新的搜索数组
high = mid - 1;
}
}
System.out.printf("目标值%d在数组中的下标为：%d",target,index);
}
}数组乱序
数组乱序，也被称为数组洗牌，实现算法中有一个非常著名的洗牌算法Fisher-Yates算法，是由 Ronald A.Fisher和Frank Yates于1938年发明的，后来被Knuth在自己的著作《The Art of Computer Programming》中介绍，很多人直接称Knuth洗牌算法。
实现步骤
1假设有一组等待乱序的数组P
2从P中随机选取一个未乱序的元素
3将该元素与数组P中最后一个未乱序的元素交换
4重复2-3的步骤，直到数组P中元素全部完成乱序
int[] p = { 1, 2, 3, 4, 5, 6, 7 };
for (int i = p.length - 1; i > 0; i--) {
int index = (int) (Math.random() * i);
int temp = p[index];
p[index] = p[i];
p[i] = temp;
}
System.out.println(Arrays.toString(p));数组旋转
数组旋转是指将数组中的元素循环移动一定位置的操作。例如，将数组 [1, 2, 3, 4, 5, 6, 7] 旋转 2 个元素，得到的新数组为 [3, 4, 5, 6, 7, 1, 2]。
向右旋转
public void right(int w,int[]array){
for (int i = 1;i <= w;i++)
for (int k = array.lenth-1;k > 0;k--){
array[k] = array[k]^array[k-1];
array[k-1] = array[k]^array[k-1];
array[k] = array[k]^array[k-1];
}
}
}向左旋转
public void left(int w,int[]array){
for (int i = 1;i <= w;i++)
for (int k = 0;k < array.lenth-1;k++){
array[k] = array[k]^array[k+1];
array[k+1] = array[k]^array[k+1];
array[k] = array[k]^array[k+1];
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
