Java基础排序算法

冒牌排序

• 相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。同理，其他的元素就可以排好。

public static void bubbleSort(int[] arr) {

     for(int x=0; x <arr.length;x++){

           for(int y=0; y<arr.length-1;y++){

               if(arr[y]>arr[y+1]) {

               int temp = arr[y];

               arr[y] = arr[y+1];

               arr[y+1] = temp;

} } } }

选择排序

• 把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。同理，其他的元素就可以排好。

public static void selectSort(int[] arr) {

     for(int x=0; x<arr.length-1;x++){

         for(int y=x+1;y<arr.length;y++(){

                 if(arr[y]<arr[x]){

                         int temp=arr[x];

                         arr[x]=arr[y];

                          arr[y]=temp;

}}}}

插入排序

• 它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

public class Insert{
 public static void main(String[] args){
 	int[] ins = {2,3,5,1,23,6,78,34};
 	int[] ins2 = sourt(ins);
 	for(int in : ins2){
		System.out.println(in);
	}
 }_
 public static int[] sort(int[] ins){
 	for(int i = 1; i<ins.length;i++){
 		for(int j=i;j>0;j--){
 			if(ins[j]<ins[j-1]){
 				int temp = ins[j-1];
 				ins[j-1] = ins[j];
 				ins[j] = temp;
 			}
 		}
 	}
 	return ins;
 }
}

快速排序

• 快速排序的原理就是每次设置一个基准点,这个基准点可以是要排序的一趴数之间的任何数,然后将比基准点小的数放在基准点左边,比基准点大的数放在基准点右边

public class QuickSort {

    public static int partition(int[] array, int low, int high) {
        // 取最后一个元素作为中心元素
        int pivot = array[high];
        // 定义指向比中心元素大的指针，首先指向第一个元素
        int pointer = low;
        // 遍历数组中的所有元素，将比中心元素大的放在右边，比中心元素小的放在左边
        for (int i = low; i < high; i++) {
            if (array[i] <= pivot) {
                // 将比中心元素小的元素和指针指向的元素交换位置
                // 如果第一个元素比中心元素小，这里就是自己和自己交换位置，指针和索引都向下一位移动
                // 如果元素比中心元素大，索引向下移动，指针指向这个较大的元素，直到找到比中心元素小的元素，并交换位置，指针向下移动
                int temp = array[i];
                array[i] = array[pointer];
                array[pointer] = temp;
                pointer++;
            }
            System.out.println(Arrays.toString(array));
        }
        // 将中心元素和指针指向的元素交换位置
        int temp = array[pointer ];
        array[pointer] = array[high];
        array[high] = temp;
        return pointer;
    }

    public static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            // 获取划分子数组的位置
            int position = partition(array, low, high);
            // 左子数组递归调用
            quickSort(array, low, position -1);
            // 右子数组递归调用
            quickSort(array, position + 1, high);
        }
    }

    public static void main(String[] args) {
        int[] array = {6,72,113,11,23};
        quickSort(array, 0, array.length -1);
        System.out.println("排序后的结果");
        System.out.println(Arrays.toString(array));
    }
}

二分法排序

• 针对数组有序的情况(千万不要先排序，在查找)

public static int binarySearch(int[] arr,int value) {
          int min = 0;
          int max = arr.length-1;
          int mid = (min+max)/2;
       while(arr[mid] != value) {
               if(arr[mid] > value) {
                     max = mid - 1;
              }else if(arr[mid] < value) {
                    min = mid + 1;
          }
              if(min > max) {
                    return -1;
             }
                   mid = (min+max)/2;
 }
                 return mid;
 }