分治算法——快速排序、归并排序算法(Java实现)

排序问题

对序列42，96，23，89，48，75，36，30，57，61用快速排序、归并排序算法，从小到大排序。

算法实现：

import java.util.Arrays;
/**
 * 快速排序
 * @author 光
 *
 */
public class QuickSort {

	public static int getMiddle(int[] intArr, int low, int high) {
		int tmp = intArr[low];    //数组的第一个作为中轴数
		while (low < high) {
			while (low < high && intArr[high] > tmp) {
				high--;
			}
			intArr[low] = intArr[high];   //比中轴数小的记录移到低端
			while (low < high && intArr[low] < tmp) {
				low++;
			}
			intArr[high] = intArr[low];   //比中轴大的记录移到高端
		}
		intArr[low] = tmp;              //中轴记录到尾
		return low;                   //返回中轴的位置
	}
	
	public static void _quickSort(int[] intArr, int low, int high) {  
        if (low < high) {  
            int middle = getMiddle(intArr, low, high);  //将intArr数组进行一分为二  
            _quickSort(intArr, low, middle - 1);        //对低字表进行递归排序  
            _quickSort(intArr, middle + 1, high);       //对高字表进行递归排序  
        }  
    }
	public static void quick(int[] str) {  
        if (str.length > 0) {    //查看数组是否为空  
            _quickSort(str, 0, str.length - 1);  
        }  
    } 
	
	public static void main(String[] args) {  
          
         int[] intArr={42,96,23,89,48,75,36,30,57,61}; 
         System.out.println("old: "+Arrays.toString(intArr));
         quick(intArr); 
         System.out.println("new: "+Arrays.toString(intArr));
    } 
}

import java.util.Arrays;
/**
 * 归并排序
 * @author 光
 *
 */
public class Merge {
	 
    private static void sort(int[] array,int i,int j) {
        if(i<j){
            int middle=(i+j)/2;
            //递归处理相关的合并事项
            sort(array,i,middle);
            sort(array,middle+1,j);
            merge(array,i,middle,j);           
        }
    }
    /**
     * 合并相关的数组内容
     * 同时使合并后的数组仍然有序
     *
     */
    private static void merge(int[] array, int i, int middle, int j) {
        //创建一个临时数组用来存储合并后的数据
        int[] temp=new int[array.length];
        int m=i;
        int n=middle+1;
        int k=i;
        while(m<=middle&&n<=j){
            if(array[m]<array[n])
                temp[k++]=array[m++];
            else
                temp[k++]=array[n++];
        }
        //处理剩余未合并的部分
        while(m<=middle){
            temp[k++]=array[m++];
        }
        while(n<=j){
            temp[k++]=array[n++];
        }
        //将临时数组中的内容存储到原数组中
        while(i<=j){
            array[i]=temp[i++];
        }
    }

    public static void main(String[] args) {
    	//需要进行排序的数组
    	int[] array={42,96,23,89,48,75,36,30,57,61};
    	//输出原数组的内容
    	System.out.println("old: "+Arrays.toString(array));
    	//归并排序操作
    	sort(array,0,array.length-1);
    	//输出排序后的相关结果
    	System.out.println("new: "+Arrays.toString(array));
    }
}

输出结果：

old: [42, 96, 23, 89, 48, 75, 36, 30, 57, 61]
new: [23, 30, 36, 42, 48, 57, 61, 75, 89, 96]