归并排序

归并排序

理解归并排序

public class MergeApp {
public static void main(String[] args) {
    int[] arrayA = {23,47,81,95};
    int[] arrayB = {7,14,39,55,62,74};
    int[] arrayC = new int[10];

    merge(arrayA,4,arrayB,6,arrayC);
    display(arrayC,10);
}

private static void merge(int[] arrayA, int sizeA, int[] arrayB, int sizeB, int[] arrayC) {
        int aDex = 0,bDex = 0, cDex = 0;
        while(aDex < sizeA&& bDex < sizeB) {
            if (arrayA[aDex] < arrayB[bDex]) {
                arrayC[cDex++] = arrayA[aDex++];
            } else {
                arrayC[cDex++] = arrayB[bDex++];
            }
        }
        while(aDex < sizeA){
            arrayC[cDex++] = arrayA[aDex++];
        }
        while (bDex<sizeB){
            arrayC[cDex++] = arrayB[bDex++];
        }
}
private static void display(int[] arrayC, int size) {
    for (int j = 0; j < size; j++) {
        System.out.println(arrayC[j]+" ");
         }
     }
 }

归并排序原理

归并排序

时间复杂度O（N*logN）

public class MergeSortApp {
    public static void main(String[] args) {
        int maxSize = 100;
        DArray arr;
        arr = new DArray(maxSize);

        arr.insert(64);
        arr.insert(21);
        arr.insert(33);
        arr.insert(70);
        arr.insert(12);
        arr.insert(85);
        arr.insert(44);
        arr.insert(3);
        arr.insert(99);
        arr.insert(0);
        arr.insert(108);
        arr.insert(36);
        arr.display();
        arr.mergeSort();
        System.out.println("========================================");
        arr.display();

    }
}

class DArray{
    private long[] theArray;
    private int nElems;
    public  DArray(int max){
        theArray = new long[max];
        nElems = 0;
    }
    public void insert(long value){
        theArray[nElems] = value;
        nElems++;
    }
    public void display(){
        for (int j = 0; j < nElems; j++) {
            System.out.println(theArray[j]+" ");
        }
    }
    public  void  mergeSort(){
        long[] workSpace = new long[nElems];
        recMergeSort(workSpace,0,nElems-1);
    }

    private void recMergeSort(long[] workSpace, int lowerBound, int upperBound) {
        if (lowerBound == upperBound){     return;   }
        else{
            int mid = (lowerBound+upperBound)/2;
            recMergeSort(workSpace, lowerBound, mid);
            recMergeSort(workSpace, mid+1,upperBound);
            merge(workSpace,lowerBound,mid+1,upperBound);
        }
    }

    private void merge(long[] workSpace, int lowPtr, int highPtr, int upperBound) {
        int j = 0;
        int lowerBound = lowPtr;
        int mid = highPtr-1;
        int n = upperBound-lowerBound+1;
        while (lowPtr <= mid && highPtr <= upperBound){
            if (theArray[lowPtr] < theArray[highPtr]){
                workSpace[j++] = theArray[lowPtr++];
            }else {
                workSpace[j++] = theArray[highPtr++];
            }
        }
        while (lowPtr <= mid){
            workSpace[j++] = theArray[lowPtr++];
        }
        while (highPtr <= upperBound){
            workSpace[j++] = theArray[highPtr++];
        }
        for (int l = 0; l < n; l++) {
            theArray[lowerBound+l] = workSpace[l];
        }
    }
}

快速排序

/*
 * 快速排序
 */
public class QuickSort {

	/**
	 * 划分数组
	 */
	public static int partition(long arr[],int left, int right,long point) {
		int leftPtr = left - 1;
		int rightPtr = right;
		while(true) {
			//循环,将比关键字小的留在左端
			while(leftPtr < rightPtr && arr[++leftPtr] < point);
			//循环，将比关键字大的留在右端
			while(rightPtr > leftPtr && arr[--rightPtr] > point);
			if(leftPtr >= rightPtr) {
				break;
			} else {
				long tmp = arr[leftPtr];
				arr[leftPtr] =  arr[rightPtr];
				arr[rightPtr] = tmp;
			}
		}
		//将关键字和当前leftPtr所指的这一个进行交换
		long tmp = arr[leftPtr];
		arr[leftPtr] =  arr[right];
		arr[right] = tmp;
		return leftPtr;
	}
	
	public static void displayArr(long[] arr) {
		System.out.print("[");
		for(long num : arr) {
			System.out.print(num + " ");
		}
		System.out.print("]");
		System.out.println();
	}
	
	public static void sort(long[] arr, int left, int right) {
		if(right - left <= 0) {
			return;
		} else {
			//设置关键字
			long point = arr[right];
			//获得切入点，同时对数组进行划分
			int partition = partition(arr, left, right, point);
			//对左边的子数组进行快速排序
			sort(arr,left,partition - 1);
			//对右边的子数组进行快速排序
			sort(arr,partition + 1, right);
		}
	}
}