练习
2.1.1给出选择排序是如何将数组E A S Y Q U E S T I O N排序的
import java.lang.Comparable; public class T_2_1_1 { public static void main(String[] args) { String[] A = {"E","A","S","Y","Q","U","E","S","T","I","O","N"}; sort(A); } public static void sort(String[] A) { for (int i = 0; i < A.length; i++) { int min = i;//最小标号为min for (int j = i + 1; j < A.length; j++) { if (A[j].compareTo(A[min]) < 0) min = j; } exch(A, i, min); show(A); } } public static void exch(String[] A, int i, int j) { String temp = A[i]; A[i] = A[j]; A[j] = temp; } public static void show(String[] A) { for (int i = 0; i < A.length; i++) { System.out.print(A[i] + " "); } System.out.println(); } } //实现结果 A E S Y Q U E S T I O N A E S Y Q U E S T I O N A E E Y Q U S S T I O N A E E I Q U S S T Y O N A E E I N U S S T Y O Q A E E I N O S S T Y U Q A E E I N O Q S T Y U S A E E I N O Q S T Y U S A E E I N O Q S S Y U T A E E I N O Q S S T U Y A E E I N O Q S S T U Y A E E I N O Q S S T U Y
2.1.2在选择排序中,一个元素最多可能被交换多少次,平均交换多少次
一个元素最多可能被交换N次,如4123,4被交换了4次.平均交换N/N=1次
2.1.3构造一个含有N个元素的数组,使得选择排序运行过程中A[j]<A[min]的成功次数最大.
51234
2.1.4给出插入排序是如何将数组E A S Y Q U E S T I O N排序的
import java.lang.Comparable; public class T_2_1_4 { public static void main(String[] args) { String[] A = {"E", "A", "S", "Y", "Q", "U", "E", "S", "T", "I", "O", "N"}; sort(A); } public static void sort(String[] A) { for (int i = 0; i < A.length; i++) { for (int j = i; j - 1 >= 0 && A[j].compareTo(A[j - 1]) < 0; j -= 1) { exch(A, j, j - 1); } show(A); } } public static void exch(String[] A, int i, int j) { String temp = A[i]; A[i] = A[j]; A[j] = temp; } public static void show(String[] A) { for (int i = 0; i < A.length; i++) { System.out.print(A[i] + " "); } System.out.println(); } } //结果 E A S Y Q U E S T I O N A E S Y Q U E S T I O N A E S Y Q U E S T I O N A E S Y Q U E S T I O N A E Q S Y U E S T I O N A E Q S U Y E S T I O N A E E Q S U Y S T I O N A E E Q S S U Y T I O N A E E Q S S T U Y I O N A E E I Q S S T U Y O N A E E I O Q S S T U Y N A E E I N O Q S S T U Y
2.1.5构造一个含有N个元素的数组,使得插入排序运行过程中内循环的两个判断结果总是假
顺序数组即可
2.1.6在所有的主键都相同时,选择排序和插入排序哪种更快
显然是插入排序
2.1.7对于逆序元素,选择排序和插入排序哪个更快
选择排序
2.1.8假设元素只可能有三种值,使用插入排序处理这样一个随机数组,运行时间是线性的还是平方级别的?或是介于两者之间
平方级别的
2.1.9希尔排序是如何将数组EASYSHELLSORTQUESTION排序的
import java.lang.Comparable; public class T_2_1_9 { public static void main(String[] args) { String[] A = {"E", "A", "S", "Y", "S", "H", "E", "L", "L", "S", "O", "R", "T", "Q", "U", "E", "S", "T", "I", "O", "N"}; sort(A); } public static void sort(String[] A) { int h = 1; while (h < A.length / 4) h = h * 3 + 1; while (h >= 1) { for (int i = 0; i < A.length; i++) { for (int j = i; j - h >= 0 && A[j].compareTo(A[j - h]) < 0; j -= h) { exch(A, j, j - h); } show(A); } h /= 2; } } public static void exch(String[] A, int i, int j) { String temp = A[i]; A[i] = A[j]; A[j] = temp; } public static void show(String[] A) { for (int i = 0; i < A.length; i++) { System.out.print(A[i] + " "); } System.out.println(); } } //结果 E A S Y S H E L L S O R T Q U E S T I O N E A S Y S H E L L S O R T Q U E S T I O N E A S Y S H E L L S O R T Q U E S T I O N E A S Y S H E L L S O R T Q U E S T I O N E A S Y S H E L L S O R T Q U E S T I O N E A S Y S H E L L S O R T Q U E S T I O N E A S Y S H E L L S O R T Q U E S T I O N E A S Y S H E L L S O R T Q U E S T I O N E A S Y S H E L L S O R T Q U E S T I O N E A S Y S H E L L S O R T Q U E S T I O N E A S Y S H E L L S O R T Q U E S T I O N E A S Y S H E L L S O R T Q U E S T I O N E A S Y S H E L L S O R T Q U E S T I O N E A S Y S H E L L S O R T Q U E S T I O N E A S Y S H E L L S O R T Q U E S T I O N E A E Y S H E L L S O R T Q U S S T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S S H E L L S O R T Q U S Y T I O N E A E S O H E L L S S R T Q U S Y T I O N E A E S O H E L L S S R T Q U S Y T I O N E A E S O H E L L S S R T Q U S Y T I O N E A E S O H E L L S S R T Q U S Y T I O N E A E S O H E L L S S R T Q U S Y T I O N E A E S O H E L L S S R T Q U S Y T I O N E A E S O H E L L S S R T Q U S Y T I O N E A E S O H E L L S S R T Q U S Y T I O N E A E S O H E L L S S R I Q U S Y T T O N E A E S O H E L L S S R I O U S Y T T Q N E A E S O H E L L S S R I O N S Y T T Q U E A E S O H E L L S S R I O N S Y T T Q U E A E S O H E L L S S R I O N S Y T T Q U E A E S O H E L L S S R I O N S Y T T Q U E A E S O H E L L S S R I O N S Y T T Q U E A E S O H E L L S S R I O N S Y T T Q U E A E S O H E L L S S R I O N S Y T T Q U E A E E O H S L L S S R I O N S Y T T Q U E A E E L H S O L S S R I O N S Y T T Q U E A E E L H S O L S S R I O N S Y T T Q U E A E E L H S O L S S R I O N S Y T T Q U E A E E L H S O L S S R I O N S Y T T Q U E A E E L H S O L S S R I O N S Y T T Q U E A E E L H I O L S S R S O N S Y T T Q U E A E E L H I O L S O R S S N S Y T T Q U E A E E L H I O L S O N S S R S Y T T Q U E A E E L H I O L S O N S S R S Y T T Q U E A E E L H I O L S O N S S R S Y T T Q U E A E E L H I O L S O N S S R S Y T T Q U E A E E L H I O L S O N S S R S Y T T Q U E A E E L H I O L S O N S Q R S S T T Y U E A E E L H I O L S O N S Q R S S T T Y U E A E E L H I O L S O N S Q R S S T T Y U A E E E L H I O L S O N S Q R S S T T Y U A E E E L H I O L S O N S Q R S S T T Y U A E E E L H I O L S O N S Q R S S T T Y U A E E E L H I O L S O N S Q R S S T T Y U A E E E H L I O L S O N S Q R S S T T Y U A E E E H I L O L S O N S Q R S S T T Y U A E E E H I L O L S O N S Q R S S T T Y U A E E E H I L L O S O N S Q R S S T T Y U A E E E H I L L O S O N S Q R S S T T Y U A E E E H I L L O O S N S Q R S S T T Y U A E E E H I L L N O O S S Q R S S T T Y U A E E E H I L L N O O S S Q R S S T T Y U A E E E H I L L N O O Q S S R S S T T Y U A E E E H I L L N O O Q R S S S S T T Y U A E E E H I L L N O O Q R S S S S T T Y U A E E E H I L L N O O Q R S S S S T T Y U A E E E H I L L N O O Q R S S S S T T Y U A E E E H I L L N O O Q R S S S S T T Y U A E E E H I L L N O O Q R S S S S T T Y U A E E E H I L L N O O Q R S S S S T T U Y
2.1.10在希尔排序中为什么在实现h有序时不选择用选择排序
由于选择排序不能利用元素现有次序来减少排序的时间复杂度,当希尔排序中采用选择排序时,h=1时的排序不能利用之前h>1时的排序结果,所以希尔排序不采用选择排序来实现。
2.1.11将希尔排序中实时计算递增序列改为预先计算并且存贮在一个数组中
将h的变化值存储在一个数组中,比较简单.
2.1.12待更新
提高题
2.1.13纸牌排序,说说你会如何将一副扑克牌按照花色排序(花色顺序是黑桃红桃梅花和方片).限制条件是所有的牌背面朝上排成一列,而你一次只能翻看两张牌或者交换两张牌(保持背面朝上)
插入排序的原理
### 2.1.14出列排序.说说你会如何将一副扑克牌排序,限制条件是只能查看最上面的两张牌,交换最上面的两张牌,或者是将最上面的牌移动到堆底
import java.lang.Math; import java.lang.Comparable; public class T_2_1_9 { public static void main(String[] args) { int[] A = {2, 345, 123, 83, 4, 5, 6, 4, 1, 2, 1, 9, 21}; sort(A); show(A); } public static void sort(int[] A) { int N = A.length; for (int i = 1; i < N; i++) { for (int j = 0; j < N - i; j++) { if (A[0] > A[1]) exch(A, 0, 1); backToFront(A, A.length, 1); } backToFront(A, A.length, i); } } public static void exch(int[] A, int i, int j) { int temp = A[i]; A[i] = A[j]; A[j] = temp; } public static void backToFront(int[] A, int l, int times) { //将数组元素向前移动一位,第一位到达最后 for (int i = 0; i < times; i++) { int temp = A[0]; for (int j = 0; j < l - 1; j++) { A[j] = A[j + 1]; } A[l - 1] = temp; } } public static void show(int[] A) { for (int i = 0; i < A.length; i++) { System.out.print(A[i] + " "); } System.out.println(); } }
2.1.15一家运货公司的一位职员得到了一项任务,需要将若干大货箱按照时间顺序排好,比较发货时间很容易,但是将两个货箱交换位置却很难,仓库只有一个空闲的位置,请问这位职员应该采用哪种排序算法呢
首先肯定不能采用一些需要很多额外空间的算法,对于空间复杂度为O(1)的排序算法主要有冒泡排序,选择排序,插入排序,这题采用选择排序较好,多比较少交换.
2.1.16编写一个check()算法,调用sort()对任意数组排序,如果排序成功而且数组中任何元素都没有被修改则返回true,否则返回false.
public static boolean check(Comparable[] a) { Comparable[] aClone=new Comparable[a.length];//创建一个新数组 for(int i=0;i<a.length;i++)//复制数组元素 aClone[i]=a[i]; sort(a); Arrays.sort(aClone); //compare array a and aClone for(int i=0;i<a.length;i++)//用java内置函数Array.sort()排序并且比较 if (a[i] !=aClone[i]) return false; return true; }
2.1.17修改插入排序和选择排序的代码,使之将数组内容绘制成棒状图展示出来.
未完待续