排序/查找算法

目录

二分查找

快速排序

插入排序

选择排序

希尔排序

归并排序

插值查找

斐波那契查找

---

---

---

二分查找

private static int SeachSort(int[] arr,int val) {
    int left=0;
    int right=arr.length-1;
    while(left<=right){
        int mid=(right+left)/2;
        if(arr[mid]==val){
            return mid;
        }else if(val>arr[mid]){
            left=mid+1;
        }else if(val<arr[mid]){
            right=mid-1;
        }
    }
    return -1;
}

快速排序

   private static void QuickSort(int[] arr,int left1,int right1) {
        int left=left1;
        int right=right1;
        if(left1>=right1) return;
        int temp=arr[left];
        while(left<right){
            while(left<right&&arr[right]>temp){
                right--;
            }
            if(left>=right){
                break;
            }else{
                arr[left]=arr[right];
            }
            while(left<right&&arr[left]<temp){
                left++;
            }
            if(left>=right){
                break;
            }else{
                arr[right]=arr[left];
            }
        }
        arr[left]=temp;
        int pivot = left;
        QuickSort(arr,left1,pivot-1);
        QuickSort(arr,pivot+1,right1);
    }

插入排序

    private static void QuickSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j >=1 ; j--) {
                if(arr[j]<arr[j-1]){
                    int temp=arr[j-1];
                    arr[j-1]=arr[j];
                    arr[j]=temp;
                }
            }
        }
    }

选择排序

  private static void QuickSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = arr.length-1; j > i; j--) {
                if(arr[i]>arr[j]){
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
    }

希尔排序

   private static void QuickSort(int[] arr) {
        for (int gap = arr.length/2; gap>0; gap/=2) {
            for (int j = gap; j < arr.length; j++) {
                for (int i = j-gap; i >= 0; i-=gap) {
                    if(arr[i]>arr[i+gap]){
                        int temp = arr[i];
                        arr[i]=arr[i+gap];
                        arr[i+gap]=temp;
                    }
                }
            }
        }
    }

归并排序

private static void MSort(int[] arr,int left,int right,int[] temp) {
        if(left<right){
            int mid = (left+right)/2;
            MSort(arr,left,mid,temp);
            MSort(arr,mid+1,right,temp);
            sum(arr,left,right,mid,temp);
        }
    }
    private static void sum(int[] arr,int left,int right,int mid,int[] temp){
        int leftIndex=left;
        int rightIndex=mid+1;
        int index=0;
        while(leftIndex<mid+1&&rightIndex<=right){
            if(arr[leftIndex]<arr[rightIndex]){
                temp[index++]=arr[leftIndex++];
            }else{
                temp[index++]=arr[rightIndex++];
            }
        }
        while(leftIndex<mid+1){
            temp[index++]=arr[leftIndex++];
        }
        while(rightIndex<=right){
            temp[index++]=arr[rightIndex++];
        }
        int tempIndex= left;
        int copyIndex=0;
        while(tempIndex<=right){
            arr[tempIndex++]=temp[copyIndex++];
        }
    }

插值查找

 private static int find(int[] arr,int val){
        int left=0;
        int right=arr.length-1;
        while(left<=right){
            int mid = left+(left+right)*(val-arr[left])/(arr[right]-arr[left]);
            if(arr[mid]==val){
                return mid;
            }else if(val>arr[mid]){
                left=mid+1;
            }else if(val<arr[mid]){
                right=mid-1;
            }
        }
        return -1;
    }

斐波那契查找

 public static int[] F(){
        int[] f = new int[20];
        f[0]=1;
        f[1]=1;
        for (int i = 2; i < f.length; i++) {
            f[i]=f[i-1]+f[i-2];
        }
        return f;
    }
    private static int FibonacciFind(int[] arr,int val){
        int low=0;
        int hight=arr.length-1;
        int k=0;
        int mid=0;
        int[] f = F();
        while(hight>f[k]-1){
            k++;
        }
        int[] temp = Arrays.copyOf(arr,f[k]);
        for (int i = hight+1; i < temp.length; i++) {
            temp[i]=arr[hight];
        }
        while(low<=hight){
            mid=low+f[k-1]-1;
            if(val<temp[mid]){
                hight=mid-1;
                k--;
            }else if(val>temp[mid]){
                low=mid+1;
                k-=2;
            }else{
                if(mid<=hight) {
                    return mid;
                }else{
                    return hight;
                }
            }
        }
        return -1;
    }