机试刷题 排序算法 代码总结

堆排序

public void heapSort(int[] nums){//大顶堆，用来做升序排序
	int len = nums.length;
	buildHeap(nums);
	for(int i=len; i>1; i--){
		swap(nums, 0, i-1);
		rebuild(nums, 0, i-1);
	}
}
public void buildHeap(int[] nums, int realSize){//从最后一个子树开始向前调整
	for(int i=realSize/2-1; i>=0; i--){
        rebuild(nums,i,realSize);
    }
}
public void rebuild(int[] nums, int index, int realSize){//调整当前子树
    int left = (index + 1) * 2 - 1, right = left + 1;
    int maxIndex = index;
    if(left < realSize && nums[left] > nums[index]){
        //左子节点大于父节点，暂时认为左子节点最大
        maxIndex = left;
    }
    if(right < realSize && nums[right] > nums[index] && nums[right] > nums[left]){
        //右子节点大于父节点、大于左子节点，更新最大的节点
        maxIndex = right;
    }
    if(maxIndex != index){
        //如果最大节点是子节点，那么把最大节点移动到父节点，并且更新这个子树
        swap(nums, index, maxIndex);
        rebuild(nums, maxIndex, realSize);//更新子树
    }
}
public void swap(int[] a, int i, int j) {
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

快排

public static void quickSort(int[] nums, int left, int right){
    if(left < right){
        int index = partition(nums, left, right);
        quickSort(nums, left, index - 1);
        quickSort(nums, index + 1, right);
    }
}
public static void quickSort_wei(int[] nums, int left, int right){
//尾递归优化的快排，尾递归优化：充分利用栈空间，这一次递归覆盖上一次递归的栈空间
    while(left < right){
        int index = partition(nums, left, right);
        quickSort(nums, left, index - 1);
        left = index + 1;
    }
}
public static int partition(int[] nums, int left, int right){
    int part = nums[left];
    while (left < right){
        while(left < right && nums[right] >= part) right--;
        nums[left] = nums[right];
        while(left < right && nums[left] <= part) left++;
        nums[right] = nums[left];
    }
    nums[left] = part;
    return left;
}

归并排序

void mergeSort(int[] nums, int left, int right){
    if(left == right){
        return;
    }
    if(right == left + 1){//只有两个元素的时候，排个序
        if(nums[left] > nums[right]){
            swap(nums, left, right);
        }
        return ;
    }
    //拆分
    int m = (right - left) / 2 + left;
    mergeSort(nums, left, m);
    mergeSort(nums, m+1, right);
    //合并
    merge(nums, left, m, m+1, right);
}
void merge(int[] nums, int l1, int r1, int l2, int r2){//合并该数组的两个有序子数组
    int[] new_nums = new int[r2-l1+1];
    int i = l1, j = l2, k = 0;
    while(i <= r1 && j <= r2){
        if(nums[i] < nums[j]){
            new_nums[k++] = nums[i++];
        }else{
            new_nums[k++] = nums[j++];
        }
    }
    while(i <= r1){
        new_nums[k++] = nums[i++];
    }
    while(j <= r2){
        new_nums[k++] = nums[j++];
    }
    for(i=l1,j=0; i<=r2; i++,j++){
        nums[i] = new_nums[j];
    }
}
void swap(int[] nums, int x, int y){
    int t = nums[x];
    nums[x] = nums[y];
    nums[y] = t;
}