排序算法题目及其代码

合集下载

数据结构经典题目及c语言代码

数据结构经典题目及c语言代码

数据结构经典题目及c语言代码一、线性表1. 顺序表顺序表是一种利用连续存储空间存储元素的线性表。

以下是一个顺序表的经典题目及C语言代码实现:```c#define MaxSize 50typedef struct {int data[MaxSize]; // 存储元素的数组int length; // 顺序表的当前长度} SeqList;// 初始化顺序表void initList(SeqList *L) {L->length = 0;}// 插入元素到指定位置void insert(SeqList *L, int pos, int elem) {if (pos < 1 || pos > L->length + 1) {printf("插入位置无效\n");return;}if (L->length == MaxSize) {printf("顺序表已满,无法插入\n"); return;}for (int i = L->length; i >= pos; i--) { L->data[i] = L->data[i - 1];}L->data[pos - 1] = elem;L->length++;}// 删除指定位置的元素void delete(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("删除位置无效\n");return;}for (int i = pos - 1; i < L->length - 1; i++) {L->data[i] = L->data[i + 1];}L->length--;}// 获取指定位置的元素值int getElement(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("位置无效\n");return -1;}return L->data[pos - 1];}```2. 链表链表是一种利用非连续存储空间存储元素的线性表。

编程面试题目

编程面试题目

编程面试题目在进行编程面试时,面试官会提出一系列的问题和任务,以评估应聘者的编程能力和解决问题的能力。

本文将介绍几个常见的编程面试题目,并提供相应的解答和示例代码。

1. 反转字符串题目描述:编写一个函数,将输入的字符串进行反转输出。

解答:```pythondef reverse_string(input_string):return input_string[::-1]input_str = "Hello World!"print(reverse_string(input_str))```2. 查找数组中的最大值和最小值题目描述:给定一个整数数组,编写一个函数找到数组中的最大值和最小值。

解答:```pythondef find_max_min(numbers):max_value = max(numbers)min_value = min(numbers)return max_value, min_valuenums = [5, -1, 9, 3, 0, 2]max_num, min_num = find_max_min(nums)print("Max value: ", max_num)print("Min value: ", min_num)```3. 判断两个字符串是否为异构词题目描述:给定两个字符串,判断它们是否为异构词(即包含相同的字符,但字符的顺序可以不同)。

解答:```pythondef is_anagram(str1, str2):if len(str1) != len(str2):return Falsecount = [0] * 26 # 假设只包含小写字母for i in range(len(str1)):count[ord(str1[i]) - ord('a')] += 1count[ord(str2[i]) - ord('a')] -= 1for c in count:if c != 0:return Falsereturn Truestring1 = "listen"string2 = "silent"print(is_anagram(string1, string2))```4. 链表反转题目描述:给定一个单向链表,编写一个函数将其反转。

408数据结构有几道算法题

408数据结构有几道算法题

408数据结构有几道算法题引言408数据结构是国内计算机专业考试中的一个重要科目,它涵盖了计算机科学中的数据结构相关知识和算法。

在408数据结构考试中,通常会涉及到一定数量的算法题,考察学生对数据结构的理解和应用能力。

本文将介绍408数据结构考试中常见的算法题目类型,并提供一些解题思路和示例代码。

线性表线性表是最基本的数据结构之一,它包括顺序表和链表两种实现方式。

顺序表顺序表是一种使用连续存储空间存储元素的线性表。

在408数据结构考试中,关于顺序表的算法题通常包括以下内容:1.初始化顺序表:创建一个空的顺序表,并指定其最大容量。

2.插入元素:向顺序表中指定位置插入一个元素。

3.删除元素:从顺序表中删除指定位置的元素。

4.查找元素:在顺序表中查找指定值的元素,并返回其位置。

以下是一个简单的示例代码:class SeqList:def __init__(self, max_size):self.data = [None] * max_sizeself.length = 0def insert(self, index, value):if index < 0 or index > self.length:raise IndexError("Index out of range")if self.length == len(self.data):raise ValueError("List is full")for i in range(self.length, index, -1):self.data[i] = self.data[i-1]self.data[index] = valueself.length += 1def delete(self, index):if index < 0 or index >= self.length:raise IndexError("Index out of range")for i in range(index, self.length-1):self.data[i] = self.data[i+1]self.length -= 1def search(self, value):for i in range(self.length):if self.data[i] == value:return ireturn -1链表链表是一种使用非连续存储空间存储元素的线性表。

内部排序比较 (实验报告+源程序)C++

内部排序比较  (实验报告+源程序)C++

实验报告3实验名称:数据结构与软件设计实习题目:内部排序算法比较专业:生物信息学班级:01 姓名:学号:实验日期:2010.07.24一、实验目的:比较冒泡排序、直接插入排序、简单选择排序、快速排序、希尔排序;二、实验要求:待排序长度不小于100,数据可有随机函数产生,用五组不同输入数据做比较,比较的指标为关键字参加比较的次数和关键字移动的次数;对结果做简单的分析,包括各组数据得出结果的解释;设计程序用顺序存储。

三、实验内容对各种内部排序算法的时间复杂度有一个比较直观的感受,包括关键字比较次数和关键字移动次数。

将排序算法进行合编在一起,可考虑用顺序执行各种排序算法来执行,最后输出所有结果。

四、实验编程结果或过程:1. 数据定义typedef struct { KeyType key; }RedType; typedef struct { RedType r[MAXSIZE+1]; int length;}SqList;2. 函数如下,代码详见文件“排序比较.cpp”int Create_Sq(SqList &L)void Bubble_sort(SqList &L)//冒泡排序void InsertSort(SqList &L)//插入排序void SelectSort(SqList &L) //简单选择排序int Partition(SqList &L,int low,int high) void QSort(SqList &L,int low,int high)//递归形式的快速排序算法void QuickSort(SqList &L)void ShellInsert(SqList &L,int dk)//希尔排序void ShellSort(SqList &L,int dlta[ ])3. 运行测试结果,运行结果无误,如下图语速个数为20元素个数为100错误调试无。

scratch编程算法题

scratch编程算法题

scratch编程算法题一、题目描述Scratch编程算法题是一个基于Scratch编程平台的趣味算法题目。

题目包括各种不同类型的算法问题,旨在锻炼学生的编程思维和解决问题的能力。

二、题目列表1.斐波那契数列求和:给定一个整数n,编写一个算法,使用递归或循环计算前n个斐波那契数的和。

2.寻找最长回文串:给定一个字符串,编写一个算法,找出其中的最长回文串。

3.快速排序:编写一个算法实现快速排序,并检查其性能。

4.八皇后问题:在一个8x8的棋盘上放置8个皇后,使得它们不能互相攻击(即在同一行、同一列或同一对角线上不能有两个皇后)。

编写一个算法找出所有解决方案。

5.汉明码校验:给定一组二进制数据和一个汉明码位数,编写一个算法验证数据的正确性。

三、解题思路1.斐波那契数列求和:可以使用递归或循环来计算斐波那契数列的和。

递归方法简单易懂,但效率较低;循环方法更常见,效率更高。

2.寻找最长回文串:可以使用双指针法,一左一右向中间移动,比较字符是否相同,当遇到不相同时就向后移动指针,直到指针相遇为止。

3.快速排序:快速排序是一种常用的排序算法,其核心思想是分而治之。

首先选取一个基准值,将数组分成两部分,一部分小于基准值,一部分大于基准值。

然后对这两部分继续进行快速排序,直到整个数组有序。

性能可以通过优化选择基准值的方式进行提高。

4.八皇后问题:这是一个经典的回溯算法问题。

首先在棋盘上放置一个皇后,检查是否会与其它皇后发生冲突。

如果不冲突,就将皇后向右下方移动一格。

如果冲突,则回溯到上一次放置的位置,并尝试另一种放置方式。

重复这个过程直到找到所有解决方案。

5.汉明码校验:汉明码是一种具有较强检错和纠错能力的编码方式。

首先根据给定的位数和二进制数据生成校验位,然后将数据和校验位一起传输。

在接收端,通过计算校验位是否正确来判断数据的正确性。

四、代码实现由于Scratch编程平台主要面向初学者,因此代码实现部分将主要以伪代码形式呈现,具体实现可以参考Scratch编程平台的官方文档和示例代码。

POJ 题目整理

POJ 题目整理

初期:一.基本算法:(1)枚举. (poj1753,poj2965)(2)贪心(poj1328,poj2109,poj2586)(3)递归和分治法.(4)递推.(5)构造法.(poj3295)(6)模拟法.(poj1068,poj2632,poj1573,poj2993,poj2996)二.图算法:(1)图的深度优先遍历和广度优先遍历.(2)最短路径算法(dijkstra,bellman-ford,floyd,heap+dijkstra)(poj1860,poj3259,poj1062,poj2253,poj1125,poj2240)(3)最小生成树算法(prim,kruskal) (poj1789,poj2485,poj1258,poj3026)(4)拓扑排序 (poj1094)(5)二分图的最大匹配 (匈牙利算法) (poj3041,poj3020)(6)最大流的增广路算法(KM算法). (poj1459,poj3436)三.数据结构.(1)串 (poj1035,poj3080,poj1936)(2)排序(快排、归并排(与逆序数有关)、堆排) (poj2388,poj2299)(3)简单并查集的应用.(4)哈希表和二分查找等高效查找法(数的Hash,串的Hash)(poj3349,poj3274,POJ2151,poj1840,poj2002,poj2503)(5)哈夫曼树(poj3253)(6)堆(7)trie树(静态建树、动态建树) (poj2513)四.简单搜索(1)深度优先搜索 (poj2488,poj3083,poj3009,poj1321,poj2251)(2)广度优先搜索(poj3278,poj1426,poj3126,poj3087.poj3414)(3)简单搜索技巧和剪枝(poj2531,poj1416,poj2676,1129)五.动态规划(1)背包问题. (poj1837,poj1276)(2)型如下表的简单DP(可参考lrj的书 page149):1.E[j]=opt{D+w(i,j)} (poj3267,poj1836,poj1260,poj2533)2.E[i,j]=opt{D[i-1,j]+xi,D[i,j-1]+yj,D[i-1][j-1]+zij} (最长公共子序列) (poj3176,poj1080,poj1159)3.C[i,j]=w[i,j]+opt{C[i,k-1]+C[k,j]}.(最优二分检索树问题)六.数学(1)组合数学:1.加法原理和乘法原理.2.排列组合.3.递推关系.(POJ3252,poj1850,poj1019,poj1942)(2)数论.1.素数与整除问题2.进制位.3.同余模运算.(poj2635, poj3292,poj1845,poj2115)(3)计算方法.1.二分法求解单调函数相关知识.(poj3273,poj3258,poj1905,poj3122)七.计算几何学.(1)几何公式.(2)叉积和点积的运用(如线段相交的判定,点到线段的距离等). (poj2031,poj1039)(3)多边型的简单算法(求面积)和相关判定(点在多边型内,多边型是否相交)(poj1408,poj1584)(4)凸包. (poj2187,poj1113)中级:一.基本算法:(1)C++的标准模版库的应用. (poj3096,poj3007)(2)较为复杂的模拟题的训练(poj3393,poj1472,poj3371,poj1027,poj2706)二.图算法:(1)差分约束系统的建立和求解. (poj1201,poj2983)(2)最小费用最大流(poj2516,poj2516,poj2195)(3)双连通分量(poj2942)(4)强连通分支及其缩点.(poj2186)(5)图的割边和割点(poj3352)(6)最小割模型、网络流规约(poj3308, )三.数据结构.(1)线段树. (poj2528,poj2828,poj2777,poj2886,poj2750)(2)静态二叉检索树. (poj2482,poj2352)(3)树状树组(poj1195,poj3321)(4)RMQ. (poj3264,poj3368)(5)并查集的高级应用. (poj1703,2492)(6)KMP算法. (poj1961,poj2406)四.搜索(1)最优化剪枝和可行性剪枝(2)搜索的技巧和优化 (poj3411,poj1724)(3)记忆化搜索(poj3373,poj1691)五.动态规划(1)较为复杂的动态规划(如动态规划解特别的施行商问题等) (poj1191,poj1054,poj3280,poj2029,poj2948,poj1925,poj3034)(2)记录状态的动态规划. (POJ3254,poj2411,poj1185)(3)树型动态规划(poj2057,poj1947,poj2486,poj3140)六.数学(1)组合数学:1.容斥原理.2.抽屉原理.3.置换群与Polya定理(poj1286,poj2409,poj3270,poj1026).4.递推关系和母函数.(2)数学.1.高斯消元法(poj2947,poj1487, poj2065,poj1166,poj1222)2.概率问题. (poj3071,poj3440)3.GCD、扩展的欧几里德(中国剩余定理) (poj3101)(3)计算方法.1.0/1分数规划. (poj2976)2.三分法求解单峰(单谷)的极值.3.矩阵法(poj3150,poj3422,poj3070)4.迭代逼近(poj3301)(4)随机化算法(poj3318,poj2454)(5)杂题. (poj1870,poj3296,poj3286,poj1095)七.计算几何学.(1)坐标离散化.(2)扫描线算法(例如求矩形的面积和周长并,常和线段树或堆一起使用).(poj1765,poj1177,poj1151,poj3277,poj2280,poj3004)(3)多边形的内核(半平面交)(poj3130,poj3335)(4)几何工具的综合应用.(poj1819,poj1066,poj2043,poj3227,poj2165,poj3429)高级:一.基本算法要求:(1)代码快速写成,精简但不失风格(poj2525,poj1684,poj1421,poj1048,poj2050,poj3306)(2)保证正确性和高效性. poj3434二.图算法:(1)度限制最小生成树和第K最短路. (poj1639)(2)最短路,最小生成树,二分图,最大流问题的相关理论(主要是模型建立和求解) (poj3155, poj2112,poj1966,poj3281,poj1087,poj2289,poj3216,poj2446) (3)最优比率生成树. (poj2728)(4)最小树形图(poj3164)(5)次小生成树.(6)无向图、有向图的最小环三.数据结构.(1)trie图的建立和应用. (poj2778)(2)LCA和RMQ问题(LCA(最近公共祖先问题) 有离线算法(并查集+dfs) 和在线算法(RMQ+dfs)).(poj1330)(3)双端队列和它的应用(维护一个单调的队列,常常在动态规划中起到优化状态转移的目的).(poj2823)(4)左偏树(可合并堆).(5)后缀树(非常有用的数据结构,也是赛区考题的热点). (poj3415,poj3294)四.搜索(1)较麻烦的搜索题目训练(poj1069,poj3322,poj1475,poj1924,poj2049,poj3426)(2)广搜的状态优化:利用M进制数存储状态、转化为串用hash表判重、按位压缩存储状态、双向广搜、A*算法. (poj1768,poj1184,poj1872,poj1324,poj2046,poj1482)(3)深搜的优化:尽量用位运算、一定要加剪枝、函数参数尽可能少、层数不易过大、可以考虑双向搜索或者是轮换搜索、IDA*算法.(poj3131,poj2870,poj2286)五.动态规划(1)需要用数据结构优化的动态规划. (poj2754,poj3378,poj3017)(2)四边形不等式理论.(3)较难的状态DP(poj3133)六.数学(1)组合数学.1.MoBius反演(poj2888,poj2154)2.偏序关系理论.(2)博奕论.1.极大极小过程(poj3317,poj1085)2.Nim问题.七.计算几何学.(1)半平面求交(poj3384,poj2540)(2)可视图的建立(poj2966)(3)点集最小圆覆盖.(4)对踵点(poj2079)八.综合题.(poj3109,poj1478,poj1462,poj2729,poj2048,poj3336,poj3315,poj2148,poj1263) 以及补充Dp状态设计与方程总结1.不完全状态记录<1>青蛙过河问题<2>利用区间dp2.背包类问题<1> 0-1背包,经典问题<2>无限背包,经典问题<3>判定性背包问题<4>带附属关系的背包问题<5> + -1背包问题<6>双背包求最优值<7>构造三角形问题<8>带上下界限制的背包问题(012背包)3.线性的动态规划问题<1>积木游戏问题<2>决斗(判定性问题)<3>圆的最大多边形问题<4>统计单词个数问题<5>棋盘分割<6>日程安排问题<7>最小逼近问题(求出两数之比最接近某数/两数之和等于某数等等)<8>方块消除游戏(某区间可以连续消去求最大效益)<9>资源分配问题<10>数字三角形问题<11>漂亮的打印<12>邮局问题与构造答案<13>最高积木问题<14>两段连续和最大<15>2次幂和问题<16>N个数的最大M段子段和<17>交叉最大数问题4.判定性问题的dp(如判定整除、判定可达性等)<1>模K问题的dp<2>特殊的模K问题,求最大(最小)模K的数<3>变换数问题5.单调性优化的动态规划<1>1-SUM问题<2>2-SUM问题<3>序列划分问题(单调队列优化)6.剖分问题(多边形剖分/石子合并/圆的剖分/乘积最大)<1>凸多边形的三角剖分问题<2>乘积最大问题<3>多边形游戏(多边形边上是操作符,顶点有权值)<4>石子合并(N^3/N^2/NLogN各种优化)7.贪心的动态规划<1>最优装载问题<2>部分背包问题<3>乘船问题<4>贪心策略<5>双机调度问题Johnson算法8.状态dp<1>牛仔射击问题(博弈类)<2>哈密顿路径的状态dp<3>两支点天平平衡问题<4>一个有向图的最接近二部图9.树型dp<1>完美服务器问题(每个节点有3种状态)<2>小胖守皇宫问题<3>网络收费问题<4>树中漫游问题<5>树上的博弈<6>树的最大独立集问题<7>树的最大平衡值问题<8>构造树的最小环转一个搞ACM需要的掌握的算法.要注意,ACM的竞赛性强,因此自己应该和自己的实际应用联系起来.适合自己的才是好的,有的人不适合搞算法,喜欢系统架构,因此不要看到别人什么就眼红, 发挥自己的长处,这才是重要的.第一阶段:练经典常用算法,下面的每个算法给我打上十到二十遍,同时自己精简代码,因为太常用,所以要练到写时不用想,10-15分钟内打完,甚至关掉显示器都可以把程序打出来.1.最短路(Floyd、Dijstra,BellmanFord)2.最小生成树(先写个prim,kruscal要用并查集,不好写)3.大数(高精度)加减乘除4.二分查找. (代码可在五行以内)5.叉乘、判线段相交、然后写个凸包.6.BFS、DFS,同时熟练hash表(要熟,要灵活,代码要简)7.数学上的有:辗转相除(两行内),线段交点、多角形面积公式.8. 调用系统的qsort, 技巧很多,慢慢掌握.9. 任意进制间的转换第二阶段:练习复杂一点,但也较常用的算法。

题库编程题整理

题库编程题整理

第三章三、编程题1.从键盘上输入一个大写字母,要求改用小写字母输出。

(1级)2.编写程序,求方程ax2+bx+c=0的解x。

(1级)3.请编写一个程序,能显示出以下两行文字。

(1级)I am a student.I love China.三、编程题1.#include <stdio.h>main( ){char c1,c2;c1=getchar( );printf(“%c,%d\n”,c1,c1);c2=c1+‟A‟-…a‟;printf(“%c,%d\n”,c2,c2);}2.#include <stdio.h>#include <math.h>main( ){float a,b,c,disc,x1,x2,realpart,imagpart;scanf(“%f%f%f”,&a,&b,&c);printf(“the equation”);if(fabs(a)<=1e-6)printf(“is not quadratic”);else disc=b*b-4*a*c;if(fabs(disc) <=1e-6)printf(“has two equal roots:%8.4f\n”,-b/(2*a)); else if (disc>1e-6){x1=(-b+sqrt(disc))/(2*a);x2=(-b-sqrt(disc))/(2*a);printf(“has distincr real roots: %8.4f\n”,x1,x2);}else{realpart=-b/(2*a);imagpart=sqrt(-disc)/(2*a);printf(“has complex roots:\n”);printf(“%8.4f+%8.4fi\n”,realpart,imagpart); printf(“%8.4f-%8.4fi\n”,realpart,imagpart);}}3.mian( ){printf(“I am a student.\n”);printf(“I love China.\n”);第四章三、编程题1.编写一个程序,要求有键盘输入三个数,计算以这三个数为边长的三角形的面积。

常用的排序算法及其适用场景

常用的排序算法及其适用场景

常⽤的排序算法及其适⽤场景⼀、排序的具体应⽤1、淘宝商品价格排序:商品按价格⾼低排序后显⽰;租房时看价格,从低到⾼;2、微博热搜排⾏榜:排序后,最⾼的⼗个关键字,上热搜3、QQ好友列表:按照好友名字的排序(涉及字符排序)4、超星移动图书馆热书榜:排序后,最⾼的⼗本书为热书⼆、选择排序——取商品的价格1.升序public class choose {public static void main(String[] args) {// double[] arr = {50.60,65.344,42.9,94,12,33,61};//float的数后⾯必须加f//选择排序/*思路:1.拿第⼀个元素与后⾯的⽐较,把⼩的放在第⼀个,进⾏位置互换2.拿第⼆个元素与后⾯的⽐较,把⼩的放在第⼆个,进⾏位置互换......*///1.升序//取商品的价格float[] arr2 = {50,61.10f,72.9f,80,77.777f,45.31f};//控制排序的次数nfor (int i = 0; i <arr2.length -1 ; i++) {//取第⼀个数为最⼩的数的位置int min= i;//寻找最⼩的数for(int j = i+1 ;j <arr2.length ;j++){if (arr2[min] > arr2[j]){//记录⽬前能找到的最⼩值元素的下标min = j;}}//将找到的最⼩值和i位置所在的值进⾏交换if (i != min){float temp = arr2[i];arr2[i] = arr2[min];arr2[min] = temp;}}//第 i轮排序的结果为System.out.print("排序后的结果为:"+ Arrays.toString(arr2));}}2.降序//取商品的价格float[] arr2 = {50,61.10f,72.9f,80,77.777f,45.31f};//控制排序的次数nfor (int i = 0; i <arr2.length -1 ; i++) {//取第⼀个数为最⼩的数的位置int min= i;//寻找最⼩的数for(int j = i+1 ;j <arr2.length ;j++){if (arr2[min] < arr2[j]){//记录⽬前能找到的最⼩值元素的下标min = j;}}//将找到的最⼩值和i位置所在的值进⾏交换if (i != min){float temp = arr2[i];arr2[i] = arr2[min];arr2[min] = temp;}}//第 i轮排序的结果为System.out.print("排序后的结果为:"+ Arrays.toString(arr2));}}三、冒泡排序——给同学们按⾝⾼排座位public class PaiXu {public static void main(String[] args) {//冒泡排序——给同学们按⾝⾼排座位/*思路:1.第⼀个与第⼆个⽐,⼤的放第⼆个2.第⼆个与第三个⽐,⼤的放第三个*/int[] arr = {178, 162,174,166,184,171,175, 177,169};//控制循环次数nfor (int i = 0;i < arr.length;i++){//每排序依次,就少⼀次for (int j = 0;j < arr.length -1-i ;j++){if (arr[j]> arr[j+1]){int temp = arr[j];arr[j]= arr[j+1];arr[j + 1] = temp;}}}System.out.println("排序后:");//数组输出System.out.println(Arrays.toString(arr));}}四、插⼊排序1.基本排序⽅法public class ChaRu {public static void main(String[] args) {//插⼊排序/*1.第⼀个数字默认已经排序2.取第⼆个数与第⼀个⽐较,然后排序3.取第三个数与前两个数⽐较,然后⽐较......*/int[] arr = {345,78,98,67,56,77};int j;//第⼀层循环:控制⽐较次数for (int i = 1; i < arr.length; i++) {int temp = arr[i];j = i;while (j > 0 && temp < arr[j - 1]) {arr[j] = arr[j - 1]; //向后挪动j--;}//存在更⼩的数,插⼊arr[j] = temp;}System.out.println(Arrays.toString(arr));}}2.给中⽂姓名排序public class NameSort {public static void main(String[] args) {String[] a = {"王五", "李四", "张三", "刘六", "⽩⼀", "苦⼆"};getSortOfChinese(a);/*for (int i = 0; i < a.length; i++) {System.out.println(a[i]);}*/System.out.println(Arrays.toString(a));}//定义排序函数public static String[] getSortOfChinese(String[] a) {// Collator 类是⽤来执⾏区分语⾔环境这⾥使⽤CHINAComparator cmp = Collator.getInstance(java.util.Locale.CHINA); // JDKz⾃带对数组进⾏排序。

内部排序比较 (实验报告+源程序)C++

内部排序比较  (实验报告+源程序)C++

实验报告3实验名称:数据结构与软件设计实习题目:内部排序算法比较专业:生物信息学班级:01 姓名:学号:实验日期:2010.07.24一、实验目的:比较冒泡排序、直接插入排序、简单选择排序、快速排序、希尔排序;二、实验要求:待排序长度不小于100,数据可有随机函数产生,用五组不同输入数据做比较,比较的指标为关键字参加比较的次数和关键字移动的次数;对结果做简单的分析,包括各组数据得出结果的解释;设计程序用顺序存储。

三、实验内容对各种内部排序算法的时间复杂度有一个比较直观的感受,包括关键字比较次数和关键字移动次数。

将排序算法进行合编在一起,可考虑用顺序执行各种排序算法来执行,最后输出所有结果。

四、实验编程结果或过程:1. 数据定义typedef struct { KeyType key; }RedType; typedef struct { RedType r[MAXSIZE+1]; int length;}SqList;2. 函数如下,代码详见文件“排序比较.cpp”int Create_Sq(SqList &L)void Bubble_sort(SqList &L)//冒泡排序void InsertSort(SqList &L)//插入排序void SelectSort(SqList &L) //简单选择排序int Partition(SqList &L,int low,int high) void QSort(SqList &L,int low,int high)//递归形式的快速排序算法void QuickSort(SqList &L)void ShellInsert(SqList &L,int dk)//希尔排序void ShellSort(SqList &L,int dlta[ ])3. 运行测试结果,运行结果无误,如下图语速个数为20元素个数为100错误调试无。

选择排序简单例题

选择排序简单例题

选择排序简单例题含解答共5道问题1:使用选择排序对以下数组进行排序:[64, 25, 12, 22, 11]解答1:```plaintext初始数组:[64, 25, 12, 22, 11]第1步:找到最小元素11,并与第一个元素64交换位置[11, 25, 12, 22, 64]第2步:在剩余元素中找到最小元素12,并与第二个元素25交换位置[11, 12, 25, 22, 64]第3步:在剩余元素中找到最小元素22,并与第三个元素25交换位置[11, 12, 22, 25, 64]第4步:在剩余元素中找到最小元素25,并与第四个元素25交换位置(实际上不需要交换)[11, 12, 22, 25, 64]最终排序结果:[11, 12, 22, 25, 64]```问题2:使用选择排序对以下数组进行排序:[38, 27, 43, 3, 9, 82, 10]解答2:```plaintext初始数组:[38, 27, 43, 3, 9, 82, 10]第1步:找到最小元素3,并与第一个元素38交换位置[3, 27, 43, 38, 9, 82, 10]第2步:在剩余元素中找到最小元素9,并与第二个元素27交换位置[3, 9, 43, 38, 27, 82, 10]第3步:在剩余元素中找到最小元素10,并与第三个元素43交换位置[3, 9, 10, 38, 27, 82, 43]第4步:在剩余元素中找到最小元素27,并与第四个元素38交换位置[3, 9, 10, 27, 38, 82, 43]第5步:在剩余元素中找到最小元素38,并与第五个元素38交换位置(实际上不需要交换)[3, 9, 10, 27, 38, 82, 43]第6步:在剩余元素中找到最小元素43,并与第六个元素82交换位置[3, 9, 10, 27, 38, 43, 82]最终排序结果:[3, 9, 10, 27, 38, 43, 82]```问题3:使用选择排序对以下数组进行排序:[5, 8, 2, 1, 6, 3]解答3:```plaintext初始数组:[5, 8, 2, 1, 6, 3]第1步:找到最小元素1,并与第一个元素5交换位置[1, 8, 2, 5, 6, 3]第2步:在剩余元素中找到最小元素2,并与第二个元素8交换位置[1, 2, 8, 5, 6, 3]第3步:在剩余元素中找到最小元素3,并与第三个元素8交换位置[1, 2, 3, 5, 6, 8]第4步:在剩余元素中找到最小元素5,并与第四个元素5交换位置(实际上不需要交换)[1, 2, 3, 5, 6, 8]第5步:在剩余元素中找到最小元素6,并与第五个元素6交换位置(实际上不需要交换)[1, 2, 3, 5, 6, 8]最终排序结果:[1, 2, 3, 5, 6, 8]```问题4:使用选择排序对以下数组进行排序:[20, 15, 10, 5, 25]解答4:```plaintext初始数组:[20, 15, 10, 5, 25]第1步:找到最小元素5,并与第一个元素20交换位置[5, 15, 10, 20, 25]第2步:在剩余元素中找到最小元素10,并与第二个元素15交换位置[5, 10, 15, 20, 25]第3步:在剩余元素中找到最小元素15,并与第三个元素15交换位置(实际上不需要交换)[5, 10, 15, 20, 25]第4步:在剩余元素中找到最小元素20,并与第四个元素20交换位置(实际上不需要交换)[5, 10, 15, 20, 25]最终排序结果:[5, 10, 15, 20, 25]```问题5:使用选择排序对以下数组进行排序:[12, 11, 13, 5, 6]解答5:```plaintext初始数组:[12, 11, 13, 5, 6]第1步:找到最小元素5,并与第一个元素12交换位置[5, 11, 13, 12, 6]第2步:在剩余元素中找到最小元素6,并与第二个元素11交换位置[5, 6, 13, 12, 11]第3步:在剩余元素中找到最小元素11,并与第三个元素13交换位置[5, 6, 11, 12, 13]第4步:在剩余元素中找到最小元素12,并与第四个元素12交换位置(实际上不需要交换)[5, 6, 11, 12, 13]最终排序结果:[5, 6, 11, 12, 13]```。

快速排序算法实验报告

快速排序算法实验报告

快速排序算法实验报告快速排序算法实验报告引言:快速排序算法是一种常用且高效的排序算法,它的核心思想是通过分治的思想将一个大问题分解成多个小问题,并通过递归的方式解决这些小问题。

本实验旨在通过实际实现和测试快速排序算法,探究其性能和效果。

实验目的:1. 理解快速排序算法的原理和思想;2. 掌握快速排序算法的实现方法;3. 通过实验比较快速排序算法与其他排序算法的性能差异。

实验步骤:1. 算法实现首先,我们需要实现快速排序算法。

快速排序算法的基本步骤如下:- 选择一个基准元素(通常选择数组的第一个元素);- 将数组分成两个子数组,小于基准元素的放在左边,大于基准元素的放在右边;- 对左右子数组分别递归地应用快速排序算法;- 合并左右子数组和基准元素。

代码实现如下:```pythondef quick_sort(arr):if len(arr) <= 1:return arrpivot = arr[0]left = [x for x in arr[1:] if x < pivot]right = [x for x in arr[1:] if x >= pivot]return quick_sort(left) + [pivot] + quick_sort(right)```2. 性能测试接下来,我们将使用不同规模的随机数组进行性能测试,比较快速排序算法与其他排序算法的效率。

我们选择插入排序算法和归并排序算法作为对比算法。

首先,我们生成1000个随机整数,并分别使用快速排序算法、插入排序算法和归并排序算法进行排序。

记录下每个算法的运行时间。

然后,我们逐渐增加数组的规模,分别测试10000、100000、1000000个随机整数的排序时间。

最后,我们绘制出三种算法在不同规模下的运行时间曲线,并进行分析和比较。

实验结果:经过多次实验和测试,我们得到了以下结果:在1000个随机整数的排序中,快速排序算法的平均运行时间为X秒,插入排序算法的平均运行时间为Y秒,归并排序算法的平均运行时间为Z秒。

高级研发测试题及答案

高级研发测试题及答案

高级研发测试题及答案1. 题目一:数据结构- 问题:请解释什么是二叉搜索树,并给出其插入操作的伪代码。

- 答案:二叉搜索树是一种特殊的二叉树,其中每个节点的值都大于其左子树中所有节点的值,且小于其右子树中所有节点的值。

插入操作的伪代码如下:```function insert(node, value):if node is null:return new TreeNode(value)if value < node.value:node.left = insert(node.left, value)else if value > node.value:node.right = insert(node.right, value)return node```2. 题目二:算法- 问题:描述快速排序算法的过程,并给出其时间复杂度。

- 答案:快速排序是一种分治算法,其基本思想是选择一个基准值,然后将数组分为两部分,一部分包含小于基准值的元素,另一部分包含大于基准值的元素。

之后,递归地在这两部分上重复这个过程。

快速排序的平均时间复杂度为O(n log n),最坏情况下为O(n^2)。

3. 题目三:操作系统- 问题:什么是死锁?请给出避免死锁的策略。

- 答案:死锁是指两个或多个进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法向前推进。

避免死锁的策略包括:- 互斥条件:确保资源不会被多个进程同时使用。

- 占有和等待:进程在请求资源时,不能占有其他资源。

- 不剥夺:进程已获得的资源,在未使用完之前,不能被其他进程强行剥夺。

- 循环等待:系统给所有资源类型分配一个序号,进程可以在申请资源时,只能申请序号比自己低的资源。

4. 题目四:计算机网络- 问题:简述TCP/IP协议栈的层次结构及其主要协议。

- 答案:TCP/IP协议栈通常被分为四层:应用层、传输层、网络层和链路层。

排序算法题 c语言

排序算法题 c语言

排序算法题 c语言
以下是一个简单的C语言排序算法题,要求使用冒泡排序算法对一个整数数组进行排序:
#include <stdio.h>
void bubbleSort(int arr[], int n) {
int i, j, temp;
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main() {
int arr[] = {5, 2, 8, 3, 9, 1};
int n = sizeof(arr) / sizeof(arr[0]);
bubbleSort(arr, n);
printf("Sorted array: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
}
该程序定义了一个名为bubbleSort的函数,该函数接受一个整数数组和数组的大小作为参数,并使用冒泡排序算法对数组进行排序。

在主函数中,我们定义了一个整数数组并调用bubbleSort函数对其进行排序。

最后,我们打印出排序后的数组。

(完整版)数据结构经典题目及c语言代码

(完整版)数据结构经典题目及c语言代码

《数据结构》课程设计题目(程序实现采用C语言)题目1:猴子选王(学时:3)一堆猴子都有编号,编号是1,2,3 .。

.m,这群猴子(m个)按照1-m的顺序围坐一圈,从第1开始数,每数到第n个,该猴子就要离开此圈,这样依次下来,直到圈中只剩下最后一只猴子,则该猴子为大王.要求:m及n要求从键盘输入,存储方式采用向量及链表两种方式实现该问题求解.//链表#include 〈stdio.h〉#include 〈stdlib.h>// 链表节点typedef struct _RingNode{int pos;struct _RingNode *next;}RingNode, *RingNodePtr;// 创建约瑟夫环,pHead:链表头指针,count:链表元素个数void CreateRing(RingNodePtr pHead, int count){RingNodePtr pCurr = NULL, pPrev = NULL;int i = 1;pPrev = pHead;while(——count 〉 0){pCurr = (RingNodePtr)malloc(sizeof(RingNode));i++;pCurr—〉pos = i;pPrev-〉next = pCurr;pPrev = pCurr;}pCurr-〉next = pHead; // 构成环状链表}void KickFromRing(RingNodePtr pHead, int n){RingNodePtr pCurr, pPrev;int i = 1; // 计数pCurr = pPrev = pHead;while(pCurr != NULL){if (i == n){// 踢出环printf("\n%d", pCurr->pos); // 显示出圈循序pPrev—>next = pCurr->next;free(pCurr);pCurr = pPrev—>next;i = 1;}pPrev = pCurr;pCurr = pCurr—〉next;if (pPrev == pCurr){// 最后一个printf("\nKing is %d", pCurr—〉pos); // 显示出圈循序 free(pCurr);break;}i++;}}int main(){int n = 0, m = 0;RingNodePtr pHead = NULL;printf("M(person count)= ”);scanf(”%d”, &m);printf("N(out number) = ");scanf(”%d”, &n);if(m 〈= 0 || n <= 0){printf("Input Error\n”);return 0;}// 建立链表pHead = (RingNodePtr)malloc(sizeof(RingNode)); pHead->pos = 1;pHead->next = NULL;CreateRing(pHead, m);// 开始出圈printf("\nKick Order: ");KickFromRing(pHead, n);printf(”\n");system(”pause”);return 0;}//数组做:#include<stdio。

归并排序例题解析

归并排序例题解析

归并排序例题解析归并排序是一种基于分治思想的排序算法,在实际程序设计中应用广泛。

下面我们将介绍归并排序的实现过程,并通过一个简单的例题来解析它的基本原理。

一、算法思想1. 分治法:将原始序列分为若干子序列,分别进行排序;2. 合并有序序列:将已排序的子序列进行合并,得到排好序的原始序列。

二、实现步骤1. 分割:将待排序序列分成两个长度相等的子序列;2. 归并:将两个已排序的子序列合并成一个有序序列。

三、例题题目描述:给定一个由数字组成的序列,将其按照从小到大的顺序进行排序。

输入数据:7,6,3,8,2,9,1,4,5输出结果:1,2,3,4,5,6,7,8,9(1)分割我们将待排序序列分成两个长度相等的子序列:7,6,3,8,2,9,1,4,57,6,3,8,2 9,1,4,57,6 3,8,2 9,1 4,57 6 3 8 2 9 1 4 5(2)归并我们先将左右两个子序列进行排序:左子序列:6,7,2,3,8右子序列:1,9,4,5接着,我们从左右两个子序列的首位开始,将每个数字按照从小到大的顺序放入一个新序列中:1,2,3,4,5,6,7,8,9四、代码实现下面是归并排序在Python中的简单实现:def merge_sort(arr):if len(arr) > 1:mid = len(arr) // 2left_half = arr[:mid]right_half = arr[mid:]merge_sort(left_half)merge_sort(right_half)i, j, k = 0, 0, 0while i < len(left_half) and j < len(right_half): if left_half[i] < right_half[j]:arr[k] = left_half[i]i += 1else:arr[k] = right_half[j]j += 1k += 1while i < len(left_half):arr[k] = left_half[i]i += 1k += 1while j < len(right_half):arr[k] = right_half[j]j += 1k += 1return arrarr = [7,6,3,8,2,9,1,4,5]arr = merge_sort(arr)print(arr)以上代码会输出排序后的结果:[1,2,3,4,5,6,7,8,9]。

选择排序算法题

选择排序算法题

选择排序算法题全文共四篇示例,供读者参考第一篇示例:选择排序算法是一种简单而有效的排序算法,它的基本思想是在未排序的数据中,找到最小(或最大)元素,将其放在已排序序列的末尾,然后再从剩余未排序的数据中找到最小(或最大)元素,放在已排序序列的末尾,依次类推,直到所有元素均已排序完成。

选择排序算法的时间复杂度为O(n^2),相比起其他高效的排序算法如快速排序、归并排序等,选择排序并不是最优的选择。

选择排序算法简单易懂,容易实现,对于小规模数据排序仍具有一定的实用性。

选择排序算法的实现非常简单,主要分为两个步骤:选择和交换。

在未排序的数据中找到最小(或最大)元素的下标,然后将该元素与未排序序列的第一个元素进行交换,这样最小(或最大)元素就被放在已排序序列的末尾;接着,在剩余的未排序数据中再次找到最小(或最大)元素的下标,执行交换操作,如此往复,直到所有元素均已排序完成。

下面我们通过一个简单的例子来演示选择排序算法的实现过程:假设有一个数组arr[] = {64, 25, 12, 22, 11},我们要对该数组进行升序排列,首先我们从数组中选择最小的元素,即arr[4]=11,将其与arr[0]=64进行交换,得到新数组{11, 25, 12, 22, 64};然后在剩余的未排序数据中选择最小元素,即arr[2]=12,将其与arr[1]=25进行交换,得到新数组{11, 12, 25, 22, 64};继续这个过程直至得到有序数组{11, 12, 22, 25, 64}。

虽然选择排序算法的时间复杂度为O(n^2),在大规模数据排序时并不适用,但在数据量较小的情况下,选择排序算法依然表现出一定的性能优势。

相比于其他更为复杂的排序算法,选择排序算法的实现过程简单直观,容易理解,且不需要额外的存储空间,这使得选择排序算法在某些场景下仍然具有一定的实用性。

除了选择排序算法之外,还有许多其他更为高效的排序算法,如快速排序、归并排序、插入排序等,它们在时间复杂度和性能上都比选择排序更为优越。

信奥赛 排序算法选择题

信奥赛 排序算法选择题

信奥赛排序算法选择题一、排序算法的选择是信息学竞赛中的重要内容,以下是一些常见的排序算法,请选出最适合解决特定问题的算法。

1.冒泡排序vs快速排序:当数据规模较大且需要较高效率的排序算法时,应选择________。

A.冒泡排序B.快速排序C.插入排序D.归并排序2.桶排序vs计数排序:对于非负整数的排序,应选择________。

A.桶排序B.计数排序C.冒泡排序D.归并排序3.选择排序vs插入排序:当数据量较小且需要稳定排序时,应选择________。

A.选择排序B.插入排序C.快速排序D.归并排序4.希尔排序vs堆排序:当数据量较大且需要更高效的排序算法时,应选择________。

A.希尔排序B.堆排序C.二分查找D.分治策略二、答案与解析:对于每一个问题,下面我会给出相应的答案和解析,帮助你理解每个算法的特点和适用场景。

1.答案:B。

快速排序通常在处理大规模数据时表现优异,因为它是一种高效的分治策略,可以在O(nlogn)的时间复杂度内完成排序。

而冒泡排序在大数据量下效率较低。

2.答案:B。

对于非负整数,我们可以将每个数放入一个桶中,再根据桶内的元素个数进行排序,这就是桶排序。

而计数排序则是专门针对非负整数的线性时间复杂度排序算法。

3.答案:B。

选择排序和插入排序都是稳定排序算法,它们都试图保持相等元素之间的相对顺序。

然而,在数据量较小且需要稳定排序的情况下,插入排序通常更快,因为它不需要像选择排序那样一次选择整个序列。

4.答案:B。

希尔排序是一种改进的插入排序,它在数据分布较散乱的情况下进行多次插入操作,以达到加速的目的。

但是,当数据量较大时,希尔排序可能会陷入O(n^2)的时间复杂度。

堆排序则是一种利用堆这种数据结构所设计的比较高效的算法,可以在O(nlogn)的时间复杂度内完成有序序列的构建和比较。

三、练习与挑战:现在你可以尝试一些实际的排序算法选择题,并思考如何根据具体情况选择合适的算法。

1.10编程基础之简单排序(10题)

1.10编程基础之简单排序(10题)

1.10编程基础之简单排序(10题)01:谁考了第k名•查看•提交•统计•提问总时间限制:1000ms描述在一次考试中,每个学生的成绩都不相同,现知道了每个学生的学号和成绩,求考第k名学生的学号和成绩。

输入第一行有两个整数,分别是学生的人数n(1≤n≤100),和求第k名学生的k(1≤k≤n)。

其后有n行数据,每行包括一个学号(整数)和一个成绩(浮点数),中间用一个空格分隔。

输出输出第k名学生的学号和成绩,中间用空格分隔。

(注:请用%g输出成绩)样例输入5 390788001 67.890788002 90.390788003 6190788004 68.490788005 73.9样例输出90788004 68.402:奇数单增序列•查看•提交•统计•提问总时间限制:1000ms内存限制:65536kB描述给定一个长度为N(不大于500)的正整数序列,请将其中的所有奇数取出,并按升序输出。

输入共2行:第1行为N;第2行为N 个正整数,其间用空格间隔。

输出增序输出的奇数序列,数据之间以逗号间隔。

数据保证至少有一个奇数。

样例输入101 32 6 5 4 9 8 7 10样例输出1,3,5,7,903:成绩排序总时间限制:1000ms内存限制:65536kB描述给出班里某门课程的成绩单,请你按成绩从高到低对成绩单排序输出,如果有相同分数则名字字典序小的在前。

输入第一行为n (0 < n < 20),表示班里的学生数目;接下来的n行,每行为每个学生的名字和他的成绩, 中间用单个空格隔开。

名字只包含字母且长度不超过20,成绩为一个不大于100的非负整数。

输出把成绩单按分数从高到低的顺序进行排序并输出,每行包含名字和分数两项,之间有一个空格。

样例输入4Kitty 80Hanmeimei 90Joey 92Tim 28样例输出Joey 92Hanmeimei 90Kitty 80Tim 2804:奖学金描述某小学最近得到了一笔赞助,打算拿出其中一部分为学习成绩优秀的前5名学生发奖学金。

数学计算机面试题及答案

数学计算机面试题及答案

数学计算机面试题及答案1. 题目:给定一个整数数组,请编写一个函数来找出数组中第二大的数。

答案:为了找出数组中第二大的数,我们可以首先初始化两个变量,一个用来存储最大值,另一个用来存储第二大的值。

遍历数组中的每个元素,如果当前元素大于最大值,则更新第二大的值为最大值,并将最大值更新为当前元素。

如果当前元素小于最大值但大于第二大的值,则更新第二大的值。

最后,第二大的值变量中存储的就是数组中第二大的数。

2. 题目:描述快速排序算法的过程,并给出一个实现快速排序的伪代码。

答案:快速排序是一种分治算法,它通过一个称为“基准”的元素将数组分为两个子数组,一个包含小于基准的元素,另一个包含大于基准的元素。

然后递归地对这两个子数组进行快速排序。

伪代码如下: ```function quickSort(array, low, high)if low < highpivotIndex = partition(array, low, high)quickSort(array, low, pivotIndex - 1)quickSort(array, pivotIndex + 1, high)end functionfunction partition(array, low, high)pivot = array[high]i = low - 1for j = low to high - 1if array[j] <= pivoti = i + 1swap array[i] with array[j]end ifend forswap array[i + 1] with array[high]return i + 1end function```3. 题目:解释什么是时间复杂度,并给出一个例子。

答案:时间复杂度是衡量算法运行时间随输入规模增长的变化趋势。

它通常用大O符号表示,例如O(n)、O(n^2)、O(log n)等。

算法大赛试题及答案

算法大赛试题及答案

算法大赛试题及答案1. 问题描述给定一个整数数组,请找出数组中第二大的数。

2. 输入格式第一行包含一个整数N,表示数组的长度。

第二行包含N个整数,表示数组的元素。

3. 输出格式输出第二大的整数。

4. 样例输入53 14 1 55. 样例输出46. 问题分析要解决这个问题,我们可以使用一次遍历的方法。

首先初始化两个变量,一个用来保存数组中的最大值,另一个用来保存第二大的值。

遍历数组,对于每个元素,如果它大于当前的最大值,则更新第二大的值和最大值;如果它小于当前的最大值但大于第二大的值,则更新第二大的值。

7. 算法实现```pythondef find_second_max(nums):first_max = second_max = float('-inf')for num in nums:if num > first_max:second_max = first_maxfirst_max = numelif num > second_max and num != first_max: second_max = numreturn second_max# 读取输入N = int(input().strip())nums = list(map(int, input().strip().split()))# 输出第二大的数print(find_second_max(nums))```8. 测试用例- 输入: `4` `1 2 3 4`输出: `3`- 输入: `6` `10 20 10 30 20 40`输出: `30`9. 注意事项- 如果数组中所有元素都相同,则不存在第二大的数。

- 如果数组中只有一个元素,则不存在第二大的数。

10. 复杂度分析- 时间复杂度:O(N),其中N是数组的长度。

- 空间复杂度:O(1),只需要常数级别的额外空间。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

排序算法题目及其代码1、明明的随机数(Noip2006)【问题描述】明明想在学校中请一些同学一起做一项问卷调查,为了实验的客观性,他先用计算机生成了N个1到1000之间的随机整数(N≤100),对于其中重复的数字,只保留一个,把其余相同的数去掉,不同的数对应着不同的学生的学号。

然后再把这些数从小到大排序,按照排好的顺序去找同学做调查。

请你协助明明完成“去重”与“排序”的工作。

【输入文件】输入文件random.in 有2行,第1行为1个正整数,表示所生成的随机数的个数:N第2行有N个用空格隔开的正整数,为所产生的随机数。

【输出文件】输出文件random.out 也是2行,第1行为1个正整数M,表示不相同的随机数的个数。

第2行为M个用空格隔开的正整数,为从小到大排好序的不相同的随机数。

【输入样例】1020 40 32 67 40 20 89 300 400 15【输出样例】815 20 32 40 67 89 300 400【参考程序】var n,s:byte;i,min,max,x:word;b:array[1..1000]of boolean;beginassign(input,'random.in');reset(input);assign(output,'random.out');rewrite(output);readln(n);fillchar(b,sizeof(b),false);min:=1000;max:=0;s:=0;for i:=1 to n dobeginread(x);b[x]:=true;if x<min then min:=x;if x>max then max:=x;end;close(input);for i:=min to max do if b[i] then inc(s);writeln(s);for i:=min to max do if b[i] then write(i,' ');end.2、车厢重组(carry.pas)【问题描述】在一个旧式的火车站旁边有一座桥,其桥面可以绕河中心的桥墩水平旋转。

一个车站的职工发现桥的长度最多能容纳两节车厢,如果将桥旋转180度,则可以把相邻两节车厢的位置交换,用这种方法可以重新排列车厢的顺序。

于是他就负责用这座桥将进站的车厢按车厢号从小到大排列。

他退休后,火车站决定将这一工作自动化,其中一项重要的工作是编一个程序,输入初始的车厢顺序,计算最少用多少步就能将车厢排序。

【输入文件】输入文件有两行数据,第一行是车厢总数N(不大于10000),第二行是N个不同的数表示初始的车厢顺序。

【输出文件】一个数据,是最少的旋转次数。

【输入样例】carry .in44 3 2 1【输出样例】carry .out6【参考程序】var n,i,j,t:word;a:array[1..10000]of word;change:boolean;s:longword;beginassign(input,'carry.in');reset(input);assign(output,'carry.out');rewrite(output);readln(n);for i:=1 to n do read(a[i]);close(input);s:=0;i:=1;repeatchange:=false;for j:=1 to n-i doif a[j]>a[j+1] thenbegint:=a[j];a[j]:=a[j+1];a[j+1]:=t;change:=true;inc(s);end;until not change;writeln(s);end.3、众数(masses.pas)【问题描述】由文件给出N个1到30000间无序数正整数,其中1≤N≤10000,同一个正整数可能会出现多次,出现次数最多的整数称为众数。

求出它的众数及它出现的次数。

【输入格式】输入文件第一行是正整数的个数N,第二行开始为N个正整数。

【输出格式】输出文件有若干行,每行两个数,第1个是众数,第2个是众数出现的次数。

【输入样例】masses.in122 4 23 2 5 3 7 2 34 3【输出样例】masses.out2 43 4【参考程序】var n,i,x,min,max,maxx:word;a:array[1..30000]of word;beginassign(input,'masses.in');reset(input);assign(output,'masses.out');rewrite(output);fillchar(a,sizeof(a),0);min:=30000;max:=0;maxx:=0;readln(n);for i:=1 to n dobeginread(x);if x<min then min:=x;if x>max then max:=x;inc(a[x]);if a[x]>maxx then maxx:=a[x];end;for i:=min to max do if a[i]=maxx then writeln(i,' ',a[i]);close(input);close(output);end.4、第k小整数(knunber.pas)【问题描述】现有n个正整数,n≤10000,要求出这n个正整数中的第k个最小整数(相同大小的整数只计算一次),k≤1000,正整数均小于30000。

【输入格式】第一行为n和k,第二行开始为n个正整数的值,整数间用空格隔开。

【输出格式】第k个最小整数的值;若无解,则输出“NO RESULT”。

【输入样例】knunber.in10 31 3 3 72 5 1 2 4 6【输出样例】knunber.out3【参考程序】var n,k,i,x,min,max,s:word;b:array[1..30000]of boolean;beginassign(input,'knumber.in');reset(input);assign(output,'knumber.out');rewrite(output);fillchar(b,sizeof(b),false);min:=30000;max:=0;s:=0;readln(n,k);for i:=1 to n dobeginread(x);b[x]:=true;if x<min then min:=x;if x>max then max:=x;end;close(input);for i:=min to max dobeginif b[i] then inc(s);if s=k then begin writeln(i); close(output); halt; end; end;writeln('NO RESULT');close(output);end.5、军事机密(Secret.pas)【问题描述】军方截获的信息由n(n<=30000)个数字组成,因为是敌国的高端秘密,所以一时不能破获。

最原始的想法就是对这n个数进行小到大排序,每个数都对应一个序号,然后对第i个是什么数感兴趣,现在要求编程完成。

【输入格式】第一行n,接着是n个截获的数字,接着一行是数字k,接着是k行要输出数的序号。

【输出格式】 k行序号对应的数字。

【输入样例】Secret.in5121 1 126 123 73243【输出样例】Secret.out7123121【参考程序】var n,i,k:word;a:array[1..30000]of longword;procedure qsort(l,r:longword);var pl,pr,m,t:longword;beginpl:=l;pr:=r;m:=a[(l+r)shr 1];repeatwhile a[pl]<m do inc(pl);while a[pr]>m do dec(pr);if pl<=pr thenbegint:=a[pl];a[pl]:=a[pr];a[pr]:=t;inc(pl);dec(pr);end;until pl>pr;if pl<r then qsort(pl,r);if pr>l then qsort(l,pr);end;{qsort}begin{main}assign(input,'secret.in');reset(input);assign(output,'secret.out');rewrite(output);readln(n);for i:=1 to n do read(a[i]);qsort(1,n);readln(k);for i:=1 to k do begin readln(n); writeln(a[n]); end; close(input);close(output);end.。

相关文档
最新文档