Introduction to Algorithm Chapter 02 思考题

最新推荐文章于 2025-06-15 12:47:14 发布

原创最新推荐文章于 2025-06-15 12:47:14 发布 · 236 阅读

0 ·

CC 4.0 BY-SA版权

Introduction to Algorithm 专栏收录该内容

4 篇文章

订阅专栏

本文深入探讨了插入排序和冒泡排序的算法原理，分析了它们的时间复杂度，详细解释了循环不变式的概念及其在排序过程中的应用，同时对比了两种排序算法的性能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

2-1

a).插入排序对长度为k的排序时间为 $k^{2}$ ，有n/k部分，所以总的时间复杂度为 $k^{2} * (n/k) = nk$

b).总共的层数为lg(n/k) + 1，每一层合并的复杂度为 $\Theta (n)$ ，所以总的时间复杂度为n*lg(n/k)

c).

d).

2-2

a).

A'中的每一个元素都能在A中找到且两个数组中拥有相同的数量。

b).

我们先看代码：

1 for i = 1 to A.length - 1
2     for j = A.length downto i + 1
3         if A[j] < A[j - 1]
4             exchange A[j] with A[j-1]

2~4行代码，通过维持以下循环不变式，执行A.length - 1个基本步骤：

在for循环的每次迭代开始时，元素A[j]为子数组A[j...A.length]中最小的元素。

初始化：首先证明在第一次循环迭代之前(j = A.length)，循环不变式成立。此时，数组A[j,A.length]中的元素数为1。所以A[j]是数组A[j,A.length]中最小的元素，循环不变式成立。

保持：如果A[j] < A[j-1] 那么这两个元素将交换位置。否则不用。此时，A[j - 1] 为子数组A[j - 1, A.length]的最小元素。对for循环的下一次迭代减小j将保持循环不变式。

终止：此时j = i。根据循环不变式：A[i] 是 A[i...A.length]的最小元素。由于A[i...A.length]就是我们循环的整个数组，到此都满足不变式，那么，这个循环不变式成立。

c).

循环不变式：在for循环每次迭代之前子数组A[1..i-1]将会是子数组A[1..A.length]中最小的i-1的元素，并且已经排好序。

初始化：首先证明在第一次循环迭代之前(i = 1)，循环不变式成立。此时，数组A[1..i-1]中的元素数为0。循环不变式成立。

保持：根据三到四行的循环不变式的终止结论，A[i]是A[i..A.length]中的最小元素。对for循环的下一次迭代i增加一将保持循环不变式。

终止：终止时，i的值为A.length。子数组A[1..i-1]就已经是原数组的升序的状态。

d).

我们假定if判断的时间代价为c1,交换的时间代价为c2，for迭代的代价为c，数组长度为n

最差的时间为((c1 +c2) * n + (c1 + c2) * (n - 1) * ... (c1 + c2) * 1) * c * c

所以最坏的时间复杂度为 $\Theta (n^{2})$

与插入排序相比，性能要差一些。他们最坏情况的时间复杂度都为 $\Theta (n^{2})$ 。冒泡排序最好情况时间复杂度也为 $\Theta (n^{2})$ ，而插入排序在排好序的情况，时间复杂度为 $\Theta (n)$ 。

2-3.

a).

$\Theta (n)$

b).

y = 0
for i = 0 to n
    t = 1
    for j = 0 to i - 1
        t = t * x
    y = y + ai * t

运行时间 $\Theta (n^2)$ 。与霍纳规则相比，性能差了太多。

c).

终止时：i = -1 $y = \sum_{k = 0}^{n - (i + 1)}a_{k + i + 1}x^{k} = \sum_{k = 0}^{n}a_{k}x^{k}$

d).

2-4

JAVA实现


import java.util.Random;
import java.util.Scanner;

public class ReverseAlignment {
	
	final static int MAXN = 5;
	static int nums[] = new int[MAXN];
	public static int findPairs(int[] nums, int beg, int end) {
		if(beg == end) return 0;
		int ret = 0;
		int mid = (beg + end) / 2;
		//System.out.println(beg+" "+end + " " + ret);
		ret = ret + findPairs(nums, beg, mid) + findPairs(nums, mid + 1, end);
		int LL = beg, RR = mid + 1, pp = beg;
		int[] tmp = new int[MAXN];
		for(pp = beg; pp <= end; pp++) {
			if(LL > mid || RR > end) break;
			if(nums[LL] > nums[RR]) {
				tmp[pp] = nums[RR++];
				ret += mid - LL + 1;
				//System.out.println(ret);
			}
			else {
				tmp[pp] = nums[LL++];
			}
		}
		while(LL <= mid) {
			tmp[pp++] = nums[LL++];
		}
		while(RR <= end) {
			tmp[pp++] = nums[RR++];
		}
		for(int i = beg; i <= end; i++) {
			nums[i] = tmp[i];
		}
		//System.out.println(ret+ " " + beg + " "+end);
		return ret;
	}
	
	public static void randomN(int[] nums, int n)
	{
		Random rand = new Random();
		for(int i = 0; i < n; i++) {
			nums[i] = rand.nextInt(100);
		}
	}
	public static void print(int[] nums) {
		for(int i = 0; i < MAXN; i++) {
			System.out.print(nums[i] + " ");
		}
		System.out.println();
	}
	public static void input(int[] nums, int n) {
		Scanner sc = new Scanner(System.in);
		for(int i = 0; i < n; i++) {
			nums[i] = sc.nextInt();
		}
		sc.close();
	}
	public static void main(String[] args) {
		
		// TODO Auto-generated method stub
		randomN(nums, MAXN);
		//input(nums, MAXN);
		print(nums);
		int ans = findPairs(nums, 0, MAXN - 1);
		print(nums);
		System.out.println(ans);
	}
	

}