数组常见算法代码总结

数组排序（优化）

• 通过Arrays工具类的sort()方法 

       Arrays.sort()方法是一种快速排序方法,具体排序可以参考下面的代码。

import java.util.Arrays;  
  
public class Main {  
    public static void main(String[] args) {  
        int[] array = {5, 2, 8, 1, 9};  
        Arrays.sort(array);  
        System.out.println(Arrays.toString(array));    
    }  
}

• 通过冒泡排序

       冒泡排序（Bubble Sort）是一种基础的排序算法，通过重复地遍历待排序的数列，比较每对相邻的元素，如果他们的顺序错误就把他们交换过来。这个过程会一直重复进行，直到没有再需要交换的元素，也就是说数列已经排序完成。具体排序可以参考下面的代码。

import java.util.Arrays;
 
public class MaoPao {
	public static void main(String[] args) {
		int[] array = {3,1,7,9,4,2,12,45,32,6,19,17};//目标数组
		for(int i = 0,n=array.length;  i < n - 1; i++) {
			for(int k = 0; k < n - 1 - i; k++) {
				if(array[k] > array[k+1]) {
					array[k] = array[k] ^ array[k+1];
					array[k+1] = array[k] ^ array[k+1];
					array[k] = array[k] ^ array[k+1];
				}
			}
		}
		System.out.println(Arrays.toString(array));
	}
}

无序数组查找

·使用for循环

        通过for循环，通过下标，分别从数组的头部和尾部遍历该无序数组，将数组中的每个元素与指定元素进行比较，从而查找目标元素。找到返回下标值，未找到返回-1。

import java.util.Scanner;

public class Demo01 {

	public static void main(String[] args) {
		//"无序数组"中指定元素的查找
		int[] array = {28,12,8,36,27,53,65,71,2,6};
		
		try(Scanner input = new Scanner(System.in)) {
			System.out.println("请输入目标元素：");
			int target = input.nextInt();//目标元素
			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);
		}
		
	}
}

·有序数组查找（二分） 

        先使用Arrays工具类的sort()方法对数组进行排序，然后使用二分查找返回目标值下标，未找到目标值则返回-1。

import java.util.Arrays;  
  
public class Main {  
    public static void main(String[] args) {  

        int[] array = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};  
   
        int targetValue = 5;  
   
        Arrays.sort(array);  
  
        // 使用二分查找查找目标值下标  
        int index = binarySearch(array, targetValue);  
   
        if (index != -1) {  
            System.out.println("找到目标值：" + targetValue + "，下标是：" + index);  
        } else {  
            System.out.println("在数组中未找到目标值：" + targetValue);  
        }  
    }  
  
    public static int binarySearch(int[] array, int target) {  
        int left = 0;  
        int right = array.length - 1;  
  
        while (left <= right) {  
            int mid = left + (right - left) / 2;  
  
            if (array[mid] == target) {  
                // 找到目标值，返回下标  
                return mid;  
            } else if (array[mid] < target) {  
                left = mid + 1;  
            } else {  
                right = mid - 1;  
            }  
        }  
  
        // 没有找到目标值，返回-1  
        return -1;  
    }  
}

数组乱序

·使用for循环

使用for循环从数组的最后一个元素开始向前遍历。在每次迭代中，我们生成一个随机数randomIndex，该随机数是从0到当前索引i的范围内的。然后，将当前索引i处的元素与randomIndex处的元素进行交换，一直持续到数组的第一个元素。

import java.util.Random;  
  
public class Main {  
    public static void main(String[] args) {  

        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9};  
  
        // 输出原数组  
        System.out.println("原数组：");  
        for (int value : array) {  
            System.out.print(value + " ");  
        }  
        System.out.println();  
  
        // 使用for循环进行数组乱序  
        Random rand = new Random();  
        for (int i = array.length - 1; i > 0; i--) {  
            // 生成一个随机数，范围从0到i  
            int randomIndex = rand.nextInt(i + 1);  
  
            // 交  
            int temp = array[i];  
            array[i] = array[randomIndex];  
            array[randomIndex] = temp;  
        }  
  
        // 输出乱序后的数组  
        System.out.println("乱序后的数组：");  
        for (int value : array) {  
            System.out.print(value + " ");  
        }  
        System.out.println();  
    }  
}

数组旋转

·使用^运算        

        从数组尾部开始，每次将当前元素与前一个元素进行^异或运算，直到数组开头位置。

import java.util.Arrays;
 
public class Main {
	public static void main(String[] args) {
		int[] numbers= {1,2,3,4,5,6,7,8};
		for(int i=0; i<2;i++) {

			for(int k=numbers.length-1;k>0;k--) {
				numbers[k]=numbers[k]^numbers[k-1];
				numbers[k-1]=numbers[k]^numbers[k-1];
				numbers[k]=numbers[k]^numbers[k-1];
			
			}
				
		}
		System.out.println(Arrays.toString(numbers));
	}
 
}