常见的排序算法

集中常见的排序算法

插入排序

插入排序的原理就是我们对这个数组进行划分为有序数组和无序数组,将无序数组的元素插入到这个有序数组中它应该存放的位置当中去,使其有序数组逐渐扩大

** 难点 **

1. 我们如何进行插入
2. 插入之后是要将插入之后的有序数组的元素往后移动的,如何进行移动

import java.util.Scanner;

public class 插入排序 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100 + 1);
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        insertSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        input.close();
    }

    public static void insertSort(int[] arr) {
        int end;
        for (end = 0; end < arr.length; end++) {
            if (arr[end] > arr[end + 1]) {
                break;
            }
        }
        //此时的i就是有序数组的开始
        for (int j = end+1; j < arr.length; j++) {
            int temp = arr[j];
            int i= j-1;
            while (i>-1&&temp < arr[i]) {
                int index = arr[i];
                arr[i] = temp;
                arr[i+1] = index;
                temp = arr[i];
                i--;
            }
        }
    }
}

冒泡排序

冒泡排序就是将两两进行相互比较,大的后移,每一轮都会找到当前一轮的最大值并将其放到该轮对的最后面

难点

1. 每一轮范围的变化

public class 冒泡排序 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100 + 1);
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        bubbleSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        input.close();
    }

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

    }
    
}

二分搜索法

最简单的二分查找算法

难点

1. left和right的变化方式,
2. 区间的范围 是左闭右开区间还是左开右闭区间,这个是很重要的

    public static int erfen(int[] a, int target) {
        //改进二分算法
        int right = a.length-1, left = 0;
        int count = 0;
        while (left <= right) {
            System.out.println(count++);
            int mid = (right + left) / 2;
            if (target < a[mid]) {
                right = mid-1;
            } else if (target > a[mid]) {
                left = mid + 1;
            } else if (target == a[mid]) {
                return mid;
            }
        }
        return -1;
    }

改进算法

//int mid = left + (target - a[left]) / (a[right] - a[left]) * (right - left);

其实就是这个我们通过这个调整这个中值的取值方式来进行改进,上面的这种取值方式,适合那种比较均匀有序排列的数组之间的排序,通过确定这个target和a[left]之间的距离来确定这个权重,通过调整这个权重来确定这个最终的范围.

斐波那契数列查找

int mid =(int)((right - left) * (1.0 / 1.618) + left) ;

同上,相比于这个二分法,我们也就是这个最后的这个mid的取值不同

选择排序

找出每一轮循环的最大值和最小值放在最后面或者最前面

public class 选择排序 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100 + 1);
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        selectSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        input.close();
    }

    public static void selectSort(int[] arr) {
        int index=0;
        for (int i = 0; i < arr.length; i++) {
            int min = arr[i];
            for (int j = i; j < arr.length; j++) {
                if (min >= arr[j]) {
                    min = arr[j];
                    index = j;
                }
            }
            arr[index] = arr[i];
            arr[i] = min;
        }
    }
}

快速排序

原理比较复杂,其实大致总结下来就是我们通过这个确定这个"中点"来进行调整这个排序算法.

public class 快速排序 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100 + 1);
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        quickSort(arr,0,arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        input.close();
    }

    public static int Partion(int[]arr, int left, int right) {
        int i = left, j = right + 1;
        do{
            do{
                i++;
            }while(i<arr.length&&arr[i]<arr[left]);
            do{
                j--;
            }while(j>-1&&arr[j]>arr[left]);
            if(i<j){
                int temp= arr[j];
                arr[j]=arr[i];
                arr[i]=temp;
            }
        } while (i < j);
        int temp = arr[j];
        arr[j] = arr[left];
        arr[left] = temp;
        return j;
    }
    public static void quickSort(int[] arr,int left,int right) {
        if (left < right) {
            int j = Partion(arr, left, right);
            quickSort(arr, left, j - 1);
            quickSort(arr, j+1, right);
        }
    }
}

分块查找

分块查找的原理就是我们通过将这个数组进行分块来进行查找,每一个块中必须有这个块的最大值,开始点和终止点,我们通过这个分块查找的算法来进行这个排序.

package heima_study.day3算法查找排序;

import java.util.Objects;
import java.util.Scanner;

public class 分块查找 {
    public static void main(String[] args) {
        int[] arr = { 16, 5, 9, 12, 21, 18,
                32, 23, 37, 26, 45, 34,
                50, 48, 61, 52, 73, 66 };
        block[] brr = new block[3];
        brr[0]=new block(21, 5, 0, 5);
        brr[1]=new block(45, 23, 6, 11);
        brr[2]=new block(73, 48, 12, 17);
        
        int target;
        Scanner input = new Scanner(System.in);
        target = input.nextInt();
        int i = searchBlock(brr, target);
        if (i != -1) {
            //查找成功
            int result = searchAll(arr, target, brr[i].getStart(), brr[i].getEnd());
            System.out.println(result);
        } else {
            System.out.println(-1);
        }
        input.close();
        
    }

    public static int searchAll(int[] arr, int target, int start, int end) {
        for (int i = start; i <= end; i++) {
            if (arr[i] == target) {
                return i;
            }
        }
        return -1;
    }
    public static int searchBlock(block[] brr,int target){
        for (int i = 0; i < brr.length; i++) {
            if (target < brr[i].getMax() && target > brr[i].getMin()) {
                //说明是在这个块里面
                return i;
            }
        }
        return -1;
    }
    
}

class block {
    private int max;
    private int min;
    private int start;
    private int end;

    public block() {
    }

    public block(int max, int min, int start, int end) {
        this.max = max;
        this.min = min;
        this.start = start;
        this.end = end;
    }

    public int getMax() {
        return this.max;
    }

    public void setMax(int max) {
        this.max = max;
    }

    public int getMin() {
        return this.min;
    }

    public void setMin(int min) {
        this.min = min;
    }

    public int getStart() {
        return this.start;
    }

    public void setStart(int start) {
        this.start = start;
    }

    public int getEnd() {
        return this.end;
    }

    public void setEnd(int end) {
        this.end = end;
    }


    @Override
    public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof block)) {
            return false;
        }
        block block = (block) o;
        return max == block.max && min == block.min && start == block.start && end == block.end;
    }

    @Override
    public int hashCode() {
        return Objects.hash(max, min, start, end);
    }

    @Override
    public String toString() {
        return "{" +
            " max='" + getMax() + "'" +
            ", min='" + getMin() + "'" +
            ", start='" + getStart() + "'" +
            ", end='" + getEnd() + "'" +
            "}";
    }   

}