java 实现部分排序算法

java 实现部分排序算法

选择排序

1，设一个第一位为最大值
2，遍历列表与第一位比较，如果更大则交换
3，重复1

冒泡排序

双重循环解决

插入排序

• 直接插入排序
  思想是分为有序序列和无序序列
  1，设第一个有序
  2，从第二个开始，从右到左扫描有序序列，当碰到第一个小于有序序列的时候，腾出位置，然后插入
  3，重复2
  注意，记录有序序列长度
• 折半插入排序
  递归折半查找有序序列
  注意，折半查找溢出

归并排序

快速排序

附录

public class Main {

    public static void main(String args[]) {
	int [] test = {2, 5, 6, 3, 1, 8, 4, 9};
	quick_sort_result(test);
	printArray(test);
    }
    
    /* 排序 */
    public static void quick_sort_result(int [] a) {
	quickSort(a, 0, a.length-1);
    }
    
    /* 快速排序 */
    public static int [] quickSort(int [] a, int start, int end) {
	if(start < end) {
	    int base_index = base(a, start, end);
		
	    // 左边递归快排
	    quickSort(a, start, base_index-1);
	    
	    // 右边递归快排
            quickSort(a, base_index+1, end);
	}
	
	
	return a;
	
	
	
    }
    
    /* 中轴元素 */
    public static int base(int [] a, int start, int end) {
	int base_num = a[start];
	
	int i = start+1, j = end;
	
	while(true){
	    

	    
	    while(a[i] < base_num) { // 左边扫描
		i++;
	    }
	    
	    while(a[j] > base_num) { // 右边扫描
		j--;
	    }
	    
	    if(i > j) {
		break;
	    }
	    
	    swap(a, i, j);
	    printArray(a);
	    
	}
        	

	swap(a, start ,j);
	printArray(a);
	return j;
	

    }

    /* 交换两个数 */
    public static void swap(int [] arr, int i, int j) {
	int temp;
	temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
    }
    
    /* 归并排序 */
    public static int [] mergeSort(int[] a) {
        	if(a.length < 2) {
        	    return a;
        	}
	    	
		
		int middle_index = a.length / 2;
		int [] left = new int[middle_index];
		int [] right = new int[a.length - middle_index];
		
		for(int i=0; i< middle_index; i++) {
		    left[i] = a[i];
		}
		
		for(int j=middle_index; j< a.length; j++) {
		    right[j-middle_index] = a[j];
		}
		
		return merge(mergeSort(left), mergeSort(right));
    }
    
    /* 归并操作 */
    public static int [] merge(int [] left, int [] right) {

	int[] result = new int[left.length + right.length];
        int i = 0;
        while (left.length > 0 && right.length > 0) {
            if (left[0] <= right[0]) {
                result[i++] = left[0];
                left = Arrays.copyOfRange(left, 1, left.length);
            } else {
                result[i++] = right[0];
                right = Arrays.copyOfRange(right, 1, right.length);
            }
        }

        while (left.length > 0) {
            result[i++] = left[0];
            left = Arrays.copyOfRange(left, 1, left.length);
        }

        while (right.length > 0) {
            result[i++] = right[0];
            right = Arrays.copyOfRange(right, 1, right.length);
        }
        printArray(result);
        return result;
	
    }
    
    /* 冒泡排序 */
    public static void bubbleSort(int [] a) {
	int temp;
	for(int i=0; i< a.length; i++) { // 浮上去的个数
	    for(int j=0; j< a.length-1-i; j++) {
		if(a[j] > a[j+1]) {
		   temp = a[j];
		   a[j] = a[j+1];
		   a[j+1] = temp;
		}
	    }
	}
    }

    
    /* 插入排序 */
    public static void insertSort(int [] a) {  // 从小到大
	int insertNum;
	
	for(int i=1; i< a.length; i++) {
	    insertNum = a[i];
	    int j = i-1;
	    while(j >= 0 && insertNum < a[j]) {
		a[j+1] = a[j];
		j--;
	    }
	    a[j+1] = insertNum;
	}
	
	
    }
    
    /* 折半插入排序 */
    public static void insertSort_binary(int [] a) {  // 从小到大
	int insertNum;
	
	for(int i=1; i< a.length; i++) {
	    insertNum = a[i];
	    int j = i-1;
	    int insert_index = binary_find_recursion(a, insertNum, 0, j); // 找到交换的位置
	
    	    while(j>=insert_index) { // 然后从该位置起后移一位
    		a[j+1] = a[j];
    		j--;
    	    }
    	    
    	    a[insert_index] = insertNum;  // 覆盖
        	    

	}
	
	
    }
    
    /* 折半查找 */
    public static int binary_find_recursion(int [] a, int number, int low_index, int high_index) {
	int mid_index = low_index+(high_index-low_index)/2;  // 防止溢出
	
	
	if(low_index > high_index) {
	    return mid_index;
	}
	else {
        	if(number > a[mid_index]) { // 去右边区间查找
        	    return binary_find_recursion(a, number, mid_index+1, high_index);
        	}
        	else{ // 去左边区间查找
        	    return binary_find_recursion(a, number, low_index, mid_index-1);
        	}
	}
    }
    
    
    /* 打印数组 */
    public static void printArray(int [] a) {
	for(int i=0; i< a.length; i++) {
	    System.out.printf("%d\t", a[i]);
	}
	System.out.println("\n");
    }
    
    
}