Java实现四大基本排序算法和二分查找

Java 基本排序算法

二分查找法

二分查找也称为折半查找，是指当每次查询时，将数据分为前后两部分，再用中值和待搜索的值进行比较，如果搜索的值大于中值，则使用同样的方式（二分法）向后搜索，反之则向前搜索，直到搜索结束为止。

特别注意： 二分法只适用于有序的数据，也就是说，数据必须是从小到大，或是从大到小排序的。

	/**
 * 二分查找法
 * 基本思想:假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，
 * 如果两者相等，则查找成功，否则利用中间位置记录将表分成前、后两个字表，
 * 如果中间位置记录的关键字大于查找关键字，则进一步查找前一字表，反之
 * 则进一步查找后一字表，重复以上过程，直到找到满足条件的记录。
 */
private static int binarySerach(int[] array, int num) {
	// TODO Auto-generated method stub
	if(num<array[0] || num>array[array.length-1]) {
		return -1;
	}
	int begin = 0;
	int end = array.length;
	int mid = (begin+end)/2;
	while(begin<end) {
		mid = (begin+end)/2;
		if(num>array[mid]) {
			begin = mid+1;
		}else if(num<array[mid]) {
			end = mid - 1;
		}else {
			return mid;
		}
	}
	return -1;
}

冒泡排序

冒泡排序算法是所有排序算法中最简单、最基础的一个，它的实现思路是通过相邻数据的交换达到排序的目的。

执行流程： 对数组中相邻的数据，依次进行比较；如果前面的数据大于后面的数据，则把前面的数据交换到后面。经过一轮比较之后，就能把数组中最大的数据排到数组的最后面了；再用同样的方法，把剩下的数据逐个进行比较排序，最后得到就是从小到大排序好的数据。

/**
 * 冒泡排序法
 * 基本思想:重复地走过要排序的数列，比较两个相邻的元素，
 * 将值大的元素交换至右端(从小至大)，直至元素有序为止。
 */
private static void buddleSort(int[] array) {
	// TODO Auto-generated method stub
	for(int i=0;i<array.length-1;i++) {
		for(int j=0;j<array.length-1-i;j++) {
			if(array[j]>array[j+1]) {
				int temp = array[j];
				array[j] = array[j+1];
				array[j+1] = temp;
			}
		}
	}
}

选择排序

选择排序算法也是比较简单的排序算法，其实现思路是每一轮循环找到最小的值，依次排到数组的最前面，这样就实现了数组的有序排列。

执行流程：

• 初始化数据：18，1，6，27，15

• 第一轮排序：1，18，6，27，15

• 第二轮排序：1，6，18，27，15

• 第三轮排序：1，6，15，27，18

• 第四轮排序：1，6，15，18，27

    /**
     * 选择排序法
     * 基本思想:每一趟从待排序的记录中选出最小的记录，
     * 放在序列的起始位置，然后再从剩余的未排序元素寻找最小元素，
     * 放到已排序的序列的末尾，重复此过程，直到全部记录排序完毕。
     */
    private static void selectSort(int[] array) {
    	// TODO Auto-generated method stub
    	for(int i=0;i<array.length-1;i++) {
    		for(int j=i+1;j<array.length;j++) {
    			if(array[i]>array[j]) {
    				int temp = array[i];
    				array[i] = array[j];
    				array[j] = temp;
    			}
    		}
    	}
    }
  

插入排序

插入排序算法是指依次把当前循环的元素，通过对比插入到合适位置的排序算法。

执行流程：

• 初始化数据：18，1，6，27，15

• 第一轮排序：1，18，6，27，15

• 第二轮排序：1，6，18，27，15

• 第三轮排序：1，6，18，27，15

• 第四轮排序：1，6，15，18，27

    /**
     * 插入排序法
     * 基本思想:每一趟从待排序的数据元素中选择最小(或最大)的一个元素作为首元素，
     * 直到所有元素排完为止。
     */
    private static void insertSort(int[] array) {
    	// TODO Auto-generated method stub
    	for(int i=1;i<array.length;i++) {
    		int index = i-1;
    		int temp = array[i];
    		while(index>=0 && array[index]>temp) {
    			array[index+1] = array[index];
    			index--;
    		}
    		array[index+1] = temp;
    	}
    }
  

快速排序

快速排序算法是基于交换排序思想实现的，是对冒泡排序算法的改进，从而具有更高的执行效率。

快速是通过多次比较和交换来实现排序的执行流程如下：

• 首先设定一个分界值，通过该分界值把数组分为左右两个部分；

• 将大于等于分界值的元素放到分界值的右边，将小于分界值的元素放到分界值的左边；

• 然后对左边两边的数据进行独立的排序，在左边数据中取一个分界值，把小于分界值的元素放到分界值的左边，大于等于分界值的元素，放到数组的右边；右边的数据也执行同样的同样的操作；

• 重复上述操作，当左边各数据排序完成后，整个数组也就完成了排序。

    /**
     * 快速排序法
     * 基本思想:选择一个值作为基准值，比基准值小的都在左边，
     * 大的放在右边，一般选择序列的第一个元素为基准值，然后分为两组，
     * 再找基准值，进行以上比较、重复，一直到所有元素排完为止。
     */
    private static void quickSort(int[] array, int start, int end) {
    	// TODO Auto-generated method stub
    	if(start>end) {
    		return;
    	}
  
    	int key = array[start];
    	int i = start;
    	int j = end;
  
    	while(i<j) {
    		while(i<j&&array[j]>=key) {
    			j--;
    		}
    		while(i<j&&array[i]<=key) {
    			i++;
    		}
  
    		if(i<j) {
    			int temp = array[i];
    			array[i] = array[j];
    			array[j] = temp;
    		}
  
    	}
  
    	array[start] = array[i];
    	array[i] = key;
  
    	quickSort(array, start, i-1);
    	quickSort(array, i+1, end);
  
    }
  

补张图

待更新，路过点个赞…