数组中的常见算法

查找

1、二分查找

package package1_Array;
/**
 * 二分查找
 * 前提：有序数组
 * 时间复杂度：O(log(n))
 */
public class array_exe8 {
    public static void main(String[] args) {
        int[] arr = new int[]{-99,-54,-2,0,2,33,43,256,999};////arr必须有序
        System.out.println(BinarySearch(arr,-2));

    }
    public static int BinarySearch(int[] arr,int num){//在有序数组中查找num的索引
        boolean Flag = false;
        int low = 0,high = arr.length-1;
        while(low <= high){
            int mid = (high + low)/2;
            if(arr[mid] < num){
                low = mid+1;
            }else if(arr[mid] > num){
                high = mid-1;
            }else{
                return mid;
            }
        }
        return -1;//找不到指定的元素则返回-1
    }
}

排序

基本概念

稳定与不稳定；内部排序（待排序的序列完全放在内存中进行排序）和外部排序（排序过程需访问外存）；

排序算法的选择

1. 若n较小(如n≤50)，可采用 直接插入或 直接选择排序。
2. 当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。
3. 若文件初始状态基本有序(指正序)，则应选用 直接插 入、 冒泡或随机的 快速排序为宜；
4. 若n较大，则应采用时间复杂度为O(nlgn)的排序方法： 快速排序、 堆排序或归并排序。

1、快速排序

package package1_Array.array_Sort;
import java.util.Arrays;

//快速排序
//思想：分而治之
//假设我们现在需要对数组做增序排序
public class QuickSort {
    public static void main(String[] args) {
        int arr[]=new int[]{3,1,-9,12,54,78,0,100,-10};
        QS(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));//[-10, -9, 0, 1, 3, 12, 54, 78, 100]
    }

    public static void QS(int[] arr,int s,int t){
        if(s<t){//类似树的前序遍历
            int i=Partition(arr,s,t);
            QS(arr,s,i-1);
            QS(arr,i+1,t);
        }
    }

    public  static int Partition(int arr[],int low,int high){
        int temp = arr[low];//每次选择下标为low的元素作为划分的基准
        while(low < high){
            while(low < high && arr[high] > temp){//先移动high,从右往左找比temp小的数组元素的下标
                high--;
            }
            if(low < high){
                arr[low] = arr[high];//如果没有越界，则做填充，换low移动
                low++;
            }
            while(low < high && arr[low] < temp){//移动low,从左往右找比temp大的数组元素的下标
                low++;
            }
            if(low < high){//如果没有越界，则做填充，换high移动
                arr[high] = arr[low];
                high--;
            }
        }
        arr[low] = temp;//把temp填充到此次划分的位置
        return low;//返回划分的位置下标
    }
}

2、堆排序（不稳定）

 java中内置了堆排序，使用优先队列实现的。

平均时间复杂度：O(n*log(n))

package daily_code;

import org.junit.Test;
import java.util.PriorityQueue;
//import java.util.Set;

public class heapTest {
    //测试java中定义的堆结构-默认是建立小顶堆
    @Test
    public void testHeap1(){
        int[] arr = new int[]{4,5,1,6,2,7,3,8};
        PriorityQueue<Integer> heap = new PriorityQueue();
        for(int item: arr) {
            heap.add(item);
        }

        while(! heap.isEmpty()){
            System.out.print(heap.poll());
        }//12345678
    }

    //测试java中定义的堆结构-使用PriorityQueue实现大顶堆
    @Test
    public void testHeap2(){
        //方式1
//        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(new Comparator(){
//            public int compare(Object o1,Object o2){
//                return (int)o2 - (int)o1;
//            }
//        });

        PriorityQueue<Integer> maxHeap = new PriorityQueue<>((o1,o2) -> (o2-o1));//方式2

        int[] arr = new int[]{4,5,1,6,2,7,3,8};
        for(int item: arr) {
            maxHeap.add(item);
        }

        while(! maxHeap.isEmpty()){
            System.out.print(maxHeap.poll());//87654321
        }
    }
}

 数组工具类的常见用法

package package1_Array;

import java.util.Arrays;

public class array_tools {
    public static void main(String[] args) {
        //1.boolean equals(int[] a,int[] b) 判断两个数组是否相等
        int[] arr1 = new int[]{1,2,3,4};
        int[] arr2 = new int[]{1,4,2,3};
        int[] arr3 = new int[]{1,2,3,4};
        int[] arr4 = arr1;
        System.out.println(Arrays.equals(arr1,arr2));//false
        System.out.println(Arrays.equals(arr1,arr3));//true
        System.out.println(Arrays.equals(arr1,arr4));//true

        //2.String toString(int[] a) 输出数组信息。
        System.out.println(Arrays.toString(arr1));//[1, 2, 3, 4]

        //3.void fill(int[] a,int val) 将指定值填充到数组之中
        Arrays.fill(arr1,1);
        System.out.println(Arrays.toString(arr1));//[1, 1, 1, 1]

        //4.void sort(int[] a) 对数组进行排序
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));//[1, 2, 3, 4]

        //5.int binarySearch(int[] a,int key) 对排序后的数组进行二分法检索指定的值。
        int[] arr5 = new int[]{5,900,1,0,77,30,64,700};
        Arrays.sort(arr5);
        System.out.println(Arrays.toString(arr5));//[0, 1, 5, 30, 64, 77, 700, 900]
        int index = Arrays.binarySearch(arr5,64);
        System.out.println(index);//4
    }
}