＜＜算法＞＞第二章习题(第一节)

最新推荐文章于 2024-08-12 19:04:41 发布
最新推荐文章于 2024-08-12 19:04:41 发布
阅读量243 收藏 2
点赞数
分类专栏： 算法 文章标签： 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57027679/article/details/122332538
版权

练习

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修改插入排序和选择排序的代码,使之将数组内容绘制成棒状图展示出来.

未完待续

梵谷的忧伤
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法习题2.1.14 出列排序
sun_lm的博客
09-27 858
题目： 出列排序。说说你会如何将一副扑克牌排序，限制条件是只能查看最上面的两张牌，交换最上面的两张牌，或是将最上面的一张牌放到这摞牌的最下面。 思路： 将牌的大小以条形图的高低来表示，假设最开始牌是逆序的，简单起见假设牌只有5张，如下图所示。（为了表示清楚，将一摞牌画成了一列的形式） 因为只能查看和交换最上面的两张牌，那么可以在每次查看之后，将最上面的两张牌中较小的那张牌移到最上面，然...
第2章 算法分析：课后习题
ZhengKen
07-20 2344
1：Eratosthenes筛选法 （1）算法描述： Eratosthenes
排序算法---Shell排序
chen930724的专栏
04-20 595
基本思路： 先把数组分成差量为d 的几组，即： a[1],a[1+d] ,a[1+d+d] ... 为一组； a[2],a[2+d] ,a[2+d+d] ... 为一组； 然后依次对每组进行插入排序。 各组排完序后 在 取第二个增量d2 直到 增量 d = 1； 即 所有的数都放在同一组中进行插入排序。 下面是 c语言实现 #include void shellInse
shell冒泡排序简单应用
weixin_50344914的博客
11-12 131
冒泡排序 通过对数据循环排序，得出数值大小进行排序 排序流程 第一轮比较4次 3 5 2 1 4 第一次 3 2 5 1 4 第二次 3 2 1 5 4 第三次 3 2 1 4 5 第四次 得出最大数值 第二轮比较3次 2 3 1 4 第一次 2 1 3 4 第二次 2 1 3 4 第三次 得出第二大数值 第三轮比较两次 1 2 3 第一次 1 2 3 第二次 得出第三大数值 第四轮比较一次 1 2 3 得出第四大数值 例脚本排序： 结果 例键盘输入冒泡排序 结果 ...
算法第四版2.1.14 出列排序
wang_yong_zhang的博客
12-27 210
出列排序 说说你会如何将一副扑克牌排序，限制条件是只能查看最上面的两张牌，交换最上面的两张牌，或是将最上面的一张牌放到这摞牌的最下面。 package Algorithm.chapter02.exercise; // 出列排序：说说你会如何将一副扑克牌排序。 // 限制条件是只能查看最上面的两张牌，交换最上面的两张牌，或是将最上面的一张牌放到这摞牌的最下面。 // 一摞牌52张，花色顺序黑桃、红桃、梅花、方片 // 思路：可以将52张牌看成是1到52个数，随机生成，然后按照规则排序 //
排序算法笔记_____2(选择排序和插入排序)
老黑牛
02-11 763
选择排序package com.chapter_two;/*** * 选择排序的思想： * * 在所有的元素中找出最小的元素，与数组的第一个元素进行交换， * * 再在剩下的元素中找出最小的元素，与数组的第二个元素进行交换， * * 如此往复，最终使整个数组有序。 * * 特点： * * ①运行时间和输入无关 ②相比其他排序算法，数据移动是最小的 * * 命题：
第二章 算法
shili1417
07-01 272
2     程序的灵魂—算法    12.1   算法的概念    12.2   简单算法举例    12.3   算法的特性    42.4   怎样表示一个算法    42.4.1       用自然语言表示算法    42.4.2       用流程图表示算法    42.4.3       三种基本结构和改进的流程图    82.4.4       用N-S
Java程序设计与数据结构第二章习题答案
11-05
这个压缩包提供的第二章习题答案可以作为参考，帮助学生检查自己的理解，激发解决问题的新思路。 在学习过程中，不断练习和应用这些知识点，逐步积累经验，才能真正掌握Java程序设计和数据结构。遇到困难时，可以...
C语言第二章习题.doc
12-21
C语言第二章习题.doc 本节习题涵盖了C语言第二章的主要知识点，包括基本结构、算法设计、变量赋值、赋值语句、逻辑运算符、字符串操作等。以下是对每道习题的详细解释： 1. 错误选项是 A)，因为结构化程序设计语言...
算法设计第一章习题解答
04-25
1. **基础算法思想**：习题可能会涉及如何运用基础的算法思想来解决具体问题，比如排序算法（冒泡排序、快速排序等）和搜索算法（二分查找、广度优先搜索等）。 2. **复杂度分析**：习题可能要求对算法的时间复杂度...
C语言程序设计教程第五章练习题题目.docx
11-15
本文档提供了C语言程序设计教程第五章的练习题题目，涵盖了C语言程序设计中的多个方面，包括数组定义和初始化、数组元素的引用、数组下标的数据类型、数组的声明和赋值、二维数组的定义和初始化、字符串数组的定义和...
第一章 算法初步课时练习题及答案.doc
10-12
通过这些练习题，学生可以深入理解算法和程序框图的概念，熟悉它们在解决实际问题中的应用，提高逻辑思维和问题解决能力。在后续的学习中，应继续强化这些基础，逐步提升到更复杂的算法设计和分析。
Algs4-2.1.15昂贵的交换
weixin_33962621的博客
10-27 431
2.1.15昂贵的交换。一家货运公司的一位职员得到了一项任务，需要将若干大货箱按照发货时间摆放。比较发货时间很容易（对照标签即可），但将两个货箱交换位置则很困难（移动麻烦）。仓库已经快满了，只有一个空闲的仓位。这位职员应该使用哪种排序算法呢？答：选择排序算法是多比较，少交换的算法。所以采用选择排序算法成本会低一些。 转载于:https://www.cnblogs.com/longjin2018/p...
数据结构第八章内排序MOOC整理
只是一个小作坊
06-04 2685
1.对于序列{E，A，S，Y，Q，U，E，S，T，I，O，N}，以{6，3，1}为增量采用Shell排序。头两趟{6，3}增量排序后，关键字的累积比较次数为()。D A.16 B.15 C.18 D.17 2.已知一组元素的排序码为(46，74，16，53，14，26，40，38，86，65，27，34)，利用直接插入排序的方法（第一个数字不用插入）,写出第四次向前面有序表插入一个元素后的排列结果。 14 16 46 53 74 26 40 38 86 65 27 34 3.已知一组元素的排序码为(46
算法（第四版）C#题解——2.1
01-03 568
算法（第四版）C#题解——2.1 写在前面 整个项目都托管在了 Github 上：https://github.com/ikesnowy/Algorithms-4th-Edition-in-Csharp 这一节内容可能会用到的库文件有 Sort 和 SortData，同样在 Github 上可以找到。 善用 Ctrl + F 查找题目。 习题&题解 2....
《算法》2.1~2算法进阶之路-排序
页川叶川
06-12 742
二、排序 排序算法类的模板 大多数情况下，我们所实现的排序算法只会通过两个方法操作数据：**less()方法对元素进行比较，exch()方法将元素交换位置。exch()方法的实现很简单，通过Comparable接口实现less()方法也不困难。sort()方法**非常重要，它决定着算法执行所需要的时间，不同的算法对sort()有不同的实现，sort()方法将是我们本节讨论的重点。 **注意:相信...
数据结构内排序题库
热门推荐
闲狗的博客
08-01 1万+
网络课课后题 1、已知一组元素的排序码为(46，74，16，53，14，26，40，38，86，65，27，34)，利用直接插入排序的方法（第一个数字不用插入）,写出第四次向前面有序表插入一个元素后的排列结果。 解析 未插入元素前，排列结果为46 74 16 53 14 26 40 38 86 65 27 34 第一次插入74，结果为 46 74 16 53 14 26 40...
Algs4-2.1.10在希尔排序中为什么实现h有序时不使用选择排序？
weixin_33887443的博客
10-27 272
2.1.10在希尔排序中为什么实现h有序时不使用选择排序？答：由于选择排序不能利用元素现有次序来减少排序的时间复杂度，当希尔排序中采用选择排序时，h=1时的排序不能利用之前h>1时的排序结果，所以希尔排序不采用选择排序来实现。 转载于:https://www.cnblogs.com/longjin2018/p/9860016.html...
图解大顶堆的构建、排序过程
最新发布
sagima_sdu的博客
08-12 496
开始，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值