• 刷题笔记之十 (小易的升级之路+找出字符串中第一个只出现一次的字符+洗牌+MP3光标位置)

    目录

    1.存取任意指定序号的元素和在最后进行插入和删除运算,利用顺序表存储最节省时间

    2. 数据结构中具有记忆功能的是栈

    3. 递归程序的优化一般为 尾递归优化

    4.二叉树遍历,前中后序遍历用到的是栈,而层序遍历用到的队列

    5. 将两个各有n个元素的有序表归并成一个有序表,最少的比较次数是n

    6. 每经过一次元素的交换会产生新的逆序的是快速排序

    7. 小易的升级之路

    8. 找出字符串中第一个只出现一次的字符

    9. 设一个有序的单链表中有n个结点，现要求插入一个新结点后使得单链表仍然保持有序，则该操作的时间复杂度（D）

    10. 给定下列程序，那么执行printf("%d\n", foo(20, 13));的输出结果是（D）

    11. 循环链表不是循环队列的存储结构,数组才是

    12. 堆(大根堆/小根堆)是从任意结点出发到根路径上所经过的结点序列按其关键字有序

    13. 堆排序是一个非常稳定的O(nlogn)

    14. 将整数数组（7-6-3-5-4-1-2）按照堆排序的方式原地进行升序排列，请问在第一轮排序结束之后，数组的顺序是（C）

    15. 洗牌

    16. MP3光标位置

    1.存取任意指定序号的元素和在最后进行插入和删除运算,利用顺序表存储最节省时间

    若某线性表最常用的操作是存取任意指定序号的元素和在最后进行插入和删除运算,则利用(A)存储方式最节省时间

    A. 顺序表         B. 双链表             C. 带头结点的双循环链表             D. 单循环链表

    存取任意指定序号,如果是数组取元素的话是O(1)

    如果是在数组末尾的插入和删除那也是O(1),所以最好是数组,也就是顺序表存储最节省时间选A

    2. 数据结构中具有记忆功能的是栈

    下列数据结构具有记忆功能的是?   C

    A. 队列        B. 循环队列        C. 栈        D. 顺序表

    记忆功能比如, 浏览器的回退功能,文本编辑器的撤销功能,都属于记忆功能

    而栈的LIFO特性,A函数调用B函数,B函数调用C函数,然后最后一层一层返回,这也具有记忆功能

    3. 递归程序的优化一般为 尾递归优化

    对递归程序的优化的一般的手段为(A)

    A. 尾递归优化       B. 循环优化        C. 堆栈优化            D. 停止值优化

    比如快速排序和归并排序,在递归的终止条件是 l 是区间最左侧,r 是区间最右侧

    //终止条件

    (l >= r){return ;}

    //在递归终止条件处进行优化

    //当区间个数较小时,采用插入排序来优化

    (r - l <= 15)  --->  采用插入排序

    所以这种对递归的优化一般都是 尾递归优化

    4.二叉树遍历,前中后序遍历用到的是栈,而层序遍历用到的队列

    将一颗二叉树的根结点放入队列,然后递归的执行如下操作,将出队结点所有子结点加入队.以上操作可以实现哪种遍历?     D

    A. 前序遍历      B. 中序遍历      C. 后序遍历       D. 层序遍历

    题中是将二叉树的根结点放入队列中,在这几种遍历中,只有层序遍历会用到队列,

    而前中后序遍历用到的是栈 ,所以选D

    5. 将两个各有n个元素的有序表归并成一个有序表,最少的比较次数是n

    将两个各有n个元素的有序表归并成一个有序表,最少的比较次数是(D)

    A. 2n         B. 2n-1          C. n-1       D. n

    两个有序的子区间个数都为n,最好的情况为第二个区间都要比第一个子区间要大

    这样只需要比较n次即可(归并排序)

    6. 每经过一次元素的交换会产生新的逆序的是快速排序

    下列排序法中,每经过一次元素的交换会产生新的逆序的是(A)

    A. 快速排序        B. 冒泡排序        C. 简单插入排序          D. 简单选择排序    

    数组的逆序:每当一次元素交换后,当前元素之后还有比当前元素还小的元素,就构成了一次逆序

    而快排就是扫描到一个arr[i] < key,就把arr[i]交换到 < key 的区间中

    每当交换一次,相对于元素key来将,就产生了一组新的逆序对 

    而冒泡,简单插入,简单选择排序都是交换相邻元素,不一定会产生逆序对(减少逆序对)

    7. 小易的升级之路

    题目链接：小易的升级之路_牛客题霸_牛客网 (nowcoder.com)

    题目要求：

     题目分析：       

    这道题就是根据c和b的大小来分情况讨论

    c = a;

    c >= bi 时, 那 c += bi

    c < bi 时, 那 c += gcd(c,bi)     输出最后的c就可以了

    只要会写 gcd(c,bi)求最大公约数那就没啥问题

    最大公约数用辗转相除法,记住这个公式,下次看着这个写就可以了

    gcd(a,b) = gcd(b,a%b)    最后返回a就可以

    有两种,递归和非递归的

    上代码

    1. import java.util.Scanner;
    2.  
    3. public class Main {
    4.     public static void main(String[] args) {
    5.         Scanner scan = new Scanner(System.in);
    6.         while(scan.hasNext()) {
    7.             int n = scan.nextInt();
    8.             int a = scan.nextInt();
    9.             int[] b = new int[n];
    10.             for (int i = 0; i < n; i++) {
    11.                 b[i] = scan.nextInt();
    12.             }
    13.  
    14.             int c = a;
    15.             for (int i = 0; i < n; i++) {
    16.                 if(b[i] <= c ) {
    17.                     c += b[i];
    18.                 }else {
    19.                     c += gcd(b[i],c);
    20.                 }
    21.             }
    22.             System.out.println(c);
    23.         }
    24.     }
    25.  
    26.     private static int gcd1(int a, int b) {
    27.         if(b == 0) {
    28.             return a;
    29.         }
    30.         int r = a%b;
    31.         return gbc(b,r);
    32.     }
    33.     private static int gcd(int a, int b) {
    34.         int c;
    35.         while((c = a % b) != 0) {
    36.             a = b;
    37.             b = c;
    38.         }
    39.         return b;
    40.     }
    41. }

    8. 找出字符串中第一个只出现一次的字符

    题目链接：找出字符串中第一个只出现一次的字符_牛客题霸_牛客网 (nowcoder.com)

    题目要求：

     

    题目分析：

    可以利用哈希的思想来做这道题

    字符ascii码表是0-127,这里可以定义一个数组大小为128的数组 arr

    然后根据每个字符的ascii对应arr数组位置,然后存入1,遇到相同字符,就给对应字符下标存储的元素+1

    arr['a']:1    arr['s'];1      arr['d'];1    arr['f'];1     arr['a'];2       arr['s'];2     arr['d'];2   arr['f'];2   arr['0'];1

    上代码

    1. import java.io.*;
    2. import java.util.*;
    3.  
    4. public class Main {
    5.     public static void findFirstChar(String str) {
    6.         int[] count = new int[128];
    7.         char[] arr = str.toCharArray();
    8.         //遍历字符统计数组
    9.         for(int i = 0; i < arr.length; i++) {
    10.             count[arr[i]]++;
    11.         } 
    12.         //找到第一个只出现一次的字符
    13.         boolean ret = false;
    14.         for(int i = 0; i < arr.length; i++) {
    15.             if(count[arr[i]] == 1) {
    16.                 System.out.println(arr[i]); 
    17.                 ret = true;
    18.                 break;
    19.             }
    20.         }
    21.         if(!ret) {
    22.             System.out.println(-1);
    23.         }
    24.     }
    25.  
    26.     public static void main(String[] args) throws Exception{
    27.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    28.         String str;
    29.         while((str = br.readLine()) != null) {
    30.             findFirstChar(str);
    31.         }
    32.     }
    33. }

    方法二 

    有两个方法是根据字符串中的字符来返回对应下标的

    indexof() 是从前往后找,根据字符返回其下标

    lastIndexof() 是从后往前找,根据字符返回其下标

    如何可以通过遍历字符串来,来根据这两个方法其返回的下标是否一样来判断字符串中只出现一次的字符.

    1. import java.io.BufferedReader;
    2. import java.io.IOException;
    3. import java.io.InputStreamReader;
    4. import java.util.*;
    5.  
    6. public class Main {
    7.     public static void main(String[] args) throws IOException {
    8.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    9.         String str;
    10.         while ((str = br.readLine()) != null) {
    11.             findFirstChar(str);
    12.         }
    13.     }
    14.  
    15.     private static void findFirstChar(String a) {
    16.         int ret = 0;
    17.         for (int i = 0; i < a.length(); i++) {
    18.             //从前往后找,从后往前找,只有遍历完字符下标是一样的
    19.             if(a.indexOf(a.charAt(i)) == a.lastIndexOf(a.charAt(i))) {
    20.                 ret = 1;
    21.                 System.out.println(a.charAt(i));
    22.                 break;
    23.             }
    24.         }
    25.         if(ret == 0) {
    26.             System.out.println(-1);
    27.         }
    28.     }
    29. }

    9. 设一个有序的单链表中有n个结点，现要求插入一个新结点后使得单链表仍然保持有序，则该操作的时间复杂度（D）

     最坏情况 2-3-4-5-6 插入新结点1(尾插)

    2-3-4-5-6-1,移动n次,所以最坏情况下O(n),选D

    10. 给定下列程序，那么执行printf("%d\n", foo(20, 13));的输出结果是（D）

     

    11. 循环链表不是循环队列的存储结构,数组才是

     循环链表不是循环队列的存储结构,数组才是

    12. 堆(大根堆/小根堆)是从任意结点出发到根路径上所经过的结点序列按其关键字有序

     关键字有序是升序或者降序

    哈夫曼树:是带权值的树(与元素大小顺序无关)

    二叉排序树(BST)的特点是:

    （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

    （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值；

    这个就是一个二叉排序树,可以看到从根节点走下去,不是有序的

    AVL是平衡二叉查找树,它的特点是,树中任意结点的两个子树高度最大差为1,所以也叫高度平衡树

    堆,如果是大根堆,那么堆中的所有结点都是,根节点大于左右孩子,同样小根堆是根节点小于左右孩子,所以堆是有序的选D

    13. 堆排序是一个非常稳定的O(nlogn)

    堆排序是一个非常稳定的O(nlogn)

    快速排序,当出现大量重复元素或者数组几乎有序时,递归数退化为链表O(n^2)

    冒泡排序O(n^2)

    希尔排序本质上是插入排序的优化,而插入排序是O(n^2),优化为希尔排序后至少是比O(nlogn)

    14. 将整数数组（7-6-3-5-4-1-2）按照堆排序的方式原地进行升序排列，请问在第一轮排序结束之后，数组的顺序是（C）

    15. 洗牌

    题目链接：洗牌_牛客题霸_牛客网 (nowcoder.com)

    题目要求：

     题目分析：

    上代码

    1. import java.util.*;
    2.  
    3. public class Main {
    4.     // 左: i -->  2*i;
    5.     // 右: i+n --> 2*i + 1;
    6.     private static void playCard(int[] cards, int n,int k ) {
    7.         for(int i = 0; i < k; i++) {
    8.             //一次洗牌的顺序
    9.             int[] newCards = new int[cards.length];
    10.             //遍历编号为0-n-1
    11.             for(int j = 0; j < n; j++) {
    12.                 newCards[2*j] = cards[j];
    13.                 newCards[2*j+1] = cards[j+n];
    14.             }
    15.             cards = newCards;
    16.         }
    17.         //从上往下打印
    18.         printCard(cards);
    19.     }
    20.     private static void printCard(int[] cards) {
    21.         for(int i = 0; i < cards.length-1; i++) {
    22.             System.out.print(cards[i] + " ");
    23.         }
    24.         System.out.println(cards[cards.length-1]);
    25.     }
    26.     public static void main(String[] args) {
    27.         Scanner scan = new Scanner(System.in);
    28.         int group = scan.nextInt();
    29.         for(int i = 0; i < group; i++) {
    30.             //读入每组数据
    31.             int n = scan.nextInt();
    32.             int k = scan.nextInt();
    33.             int[] arr = new int[2*n];
    34.             for(int j = 0; j < 2*n; j++) {
    35.                 arr[j] = scan.nextInt();
    36.             }
    37.             //洗牌
    38.             playCard(arr,n,k);
    39.         }
    40.     }
    41. }
    42.

    16. MP3光标位置

    题目链接：MP3光标位置_牛客题霸_牛客网 (nowcoder.com)

    题目要求：

     题目分析：

    这道题需要多注意每个条件

    可以使用 first来表示列表的起始位置,使用mouse来表示光标的位置

    所以每个判断条件也就是来写 first mouse 和U/D 的值和关系

    只有一个地方需要注意

    当 n > 4 时                     

    //屏幕显示的不是第一页时,光标在当前屏幕最后一首歌时,按Down键显示下一首歌,

    正常根据这个是写这样的条件 first != 1 && mouse == first+3 && order[i] == 'D'

    但是这里要注意,如果是最后一页的话,按D就会到第一首歌

    所以应该是 first != n-3 && mouse == first+3 && order[i] == 'D'

    上代码

    1. import java.util.Scanner;
    2. import java.io.*;
    3.  
    4. public class Main {
    5.     private static void mouseMove(String numStr, String orderStr) {
    6.         //歌曲数量
    7.         int n = Integer.parseInt(numStr);
    8.         //指令数组: ud
    9.         char[] order = orderStr.toCharArray();
    10.         //当前鼠标所在的位置
    11.         int mouse = 1;
    12.         //显示列表所在的起始位置
    13.         int first = 1;
    14.  
    15.         //指令处理
    16.         // n <= 4
    17.         if(n <= 4) {
    18.             for(int i = 0; i < order.length; i++) {
    19.                 if(mouse == 1 && order[i] == 'U') {
    20.                     mouse = n;
    21.                 }else if(mouse == n && order[i] == 'D') {
    22.                     mouse = 1;
    23.                 }else if(order[i] == 'U') {
    24.                     mouse--;
    25.                 }else if(order[i] == 'D') {
    26.                     mouse++;
    27.                 }
    28.             }
    29.             //输出
    30.             //打印当前显示列表
    31.             for(int i = 1; i < n; i++) {
    32.                 System.out.print(i + " ");
    33.             }
    34.             System.out.println(n);
    35.             //打印当前歌曲
    36.             System.out.println(mouse);
    37.         } else {
    38.             // n>4
    39.             for (int i = 0; i < order.length; i++) {
    40.                 if(first == 1 && mouse == 1 && order[i] == 'U') {
    41.                     first = n-3;
    42.                     mouse = n;
    43.                 }else if (first == n-3 && mouse == n && order[i] == 'D') {
    44.                     first = 1;
    45.                     mouse = 1;
    46.                 }else if (first != 1 && mouse == first && order[i] == 'U') {
    47.                     first--;
    48.                     mouse--;
    49.                     //屏幕显示的不是第一页时,光标在当前屏幕最后一首歌时,按Down键显示下一首歌,这里要注意,如果是最后一页的话,按D就会到第一首歌
    50.                 }else if (first != n-3 && mouse == first+3 && order[i] == 'D') {
    51.                     first++;
    52.                     mouse++;
    53.                     //其他情况只移动光标
    54.                 }else if (order[i] == 'U') {
    55.                     mouse--;
    56.                 }else if (order[i] == 'D') {
    57.                     mouse++;
    58.                 }
    59.             }
    60.             //输出
    61.             //打印当前显示列表
    62.             for(int i = first; i < first+3; i++) {
    63.                 System.out.print(i + " ");
    64.             }
    65.             System.out.println(first+3);
    66.             //打印当前歌曲
    67.             System.out.println(mouse);
    68.         }
    69.     }
    70.     public static void main(String[] args) throws Exception{
    71.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    72.         String numStr;
    73.         while((numStr = br.readLine()) != null) {
    74.             String orderStr = br.readLine();
    75.             mouseMove(numStr,orderStr);
    76.         }
    77.     }
    78. }

  • 相关阅读:
    【Go实现】实践GoF的23种设计模式：迭代器模式
    python之xml文件的读取介绍
    WithThread多线程识别某一线程受阻
    【软考软件评测师】第二十五章 系统安全设计（网络攻击）
    数据结构和算法（7）：图应用
    深入理解操作系统之线程
    element ui el-table表格复选框，弹框关闭取消打勾选择
    Origin绘制热重TG和微分热重DTG曲线
    CSS 太阳光线透过窗户
    通过Gunicorn、Supervisor和Nginx更好地运行Django
  • 原文地址：https://blog.csdn.net/m0_58761900/article/details/127776872