数据结构练习题一
一、双向冒泡
-
普通冒泡排序算法:是一种简单直观的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。
-
双向冒泡排序算法:在正反两个方向交替进行扫描,即第一趟把关键字最大的元素放在序列的最后面,第二趟把关键字最小的元素放在序列的最前面,如此反复进行。
#include<stdio.h>
//编写双向冒泡排序算法,在正反两个方向交替进行扫描,即第一趟把关键字最
//大的元素放在序列的最后面,第二趟把关键字最小的元素放在序列的最前面,如
//此反复进行。
void BubbleSort(ElemType A[],int n) {
//这种排序方式也叫做双向气泡,奇数躺时,从前往后的比较相邻元素的关键字,
//遇到逆序就交换,直到把序列中的关键字最大的元素移动到序列尾部
//偶数躺时,则相反
int low=0,high=n-1;
bool flag=true;//用于记录是否发生了元素交换,如果没有发生交换,则排序完成
while(low<high && flag) {
//当flag为false时,跳出循环
flag=false;
//从前往后找大的
for(int i=low; i<high; i++) {
if(A[i]>A[i+1]) {
//如果成立,则交换顺序
swap(A[i],A[i+1]);
flag=true;
}
high--;//将最大的元素放到了序列最后边
//开始从后面往前冒泡
for(i=high; i>low; i--) {
if(A[i]<A[i-1]) {
//如果成立,则交换顺序
swap(A[i-1],A[i]);
flag=ture;
}
low++;
}
}
}
int main() {
}
二、二叉树遍历
已知某二叉树的先序序列和中序序列分别为ABCFLKDGHEIJ和LFKCBDHGAIEJ,
请画出这棵二叉树,并画出二叉树对应的森林
这里推荐使用这个网站,可以快速帮忙求解 二叉树网站
三、for循环中i++与++i的区别
- i++:先使用 i 的当前值,然后再将 i 增加 1。
- ++i:先将 i 增加 1,然后再使用 i 的新值。
- 我们知道for循环的执行顺序是:
for(A;B;D) {
C;
}
按ABCD的顺序执行。
因此
for(int i = 0; i<10; i++) {
printf("%d", i);
}
相当于
for(int i = 0; i<10;) {
printf("%d", i);、
i++;
}
而
for(int i = 0; i<10; ++i) {
printf("%d", i);
}
相当于
for(int i = 0; i<10;) {
printf("%d", i);
++i;
}
可见二者作用是一致的。
不过,在空间损耗上,i++要略高于++i,因为使用i++时,系统会预先申请一段存储空间,供后续使用。而使用++i时,存储空间则是用时再申请。
因此,在不影响代码逻辑的前提下,要尽量使用++i。
四、直接插入排序
我们可以将其类比成扑克牌,将第一待排序序列第一个元素看做一个有序序列,把第二个元素到最后一个元素当成是未排序序列。从头到尾依次扫描未排序序列,将扫描到的每个元素插入有序序列的适当位置。(如果待插入的元素与有序序列中的某个元素相等,则将待插入元素插入到相等元素的后面。)点击跳转菜鸟教程
void Insert_Sort(Elem A[],int n) {
int i,j;
for(i=2; i<=n; i++)
//依次将A[2]~A[n]插入前面一排好的序列
if(A[i]<A[j]) {
//若A[i] 小于前一个元素,应插入有序表中
A[0]=A[i];
for(j=i-1; A[0]<A[j]; --j) //从后往前插入
A[j+1]=A[j];//元素后移
A[j+1]=A[0];
}
}
- 应注意i++与++i的区别
- 应注意for循环没有使用{}
- 应注意此处哨兵的作用(不用每轮循环都判断j>=0,节省了一点效率)
五、树转二叉树
把下列树转化成二叉树,并给出转化后所得二叉树的前序、中序、后序遍历
的序列
- 应遵循左孩子右兄弟原则
先序遍历:ABEFCDGIH
中序遍历:EFBACIGHD
后序遍历:FEIHGDCBA
六、顺序表排序
设顺序表用数组 A[]表示,表中元素存储在数组下标 1~m+n 的范围内,
前m个元素递增有序,后n个元素递增有序,设计一个算法,使得整个顺序表有序
- 算法思想
将数组 A[1…m+n]视为一个已经过m趟插入排序的表, 则从m+1趟开
始,将后n个元素依次插入前面的有序表中。 - 代码实现
void Insert_Sort(ElemType A[],int m,int n) {
int i,j;
for(i=m-1; i<=m+n; i--) {
//依次将A[m+1,m+n]插入有序表中
A[0]=A[i]//将元素放到哨兵中
for(j=i-1; A[j]>A[0]; j--) //从后往前插入
A[j+1]=A[j];//元素后移
A[j+1]=A[0];
}
}
- 时间复杂度:O ( m * n )
- 空间复杂度:O ( 1 )
七、哈夫曼编码
已知字符集{a,b,c,d,e,f},若各字符出现的次数分别为3,5,6,7,10,11,请
写 出对应哈夫曼树和对应字符集中各字符的哈夫曼编码
- 由左零右一原则给出各字符编码方式
a:000
b:001
c:100
d:101
e:01
f:11
八、编写交换法的快速排序算法
快速排序的最坏运行情况是 O(n²),比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn),
且 O(nlogn) 记号中隐含的常数因子很小,比复杂度稳定等于 O(nlogn) 的归并排序要小很多。
所以,对绝大多数顺序性较弱的随机数列而言,快速排序总是优于归并排序。
- 算法步骤
- 从数列中挑出一个元素,称为 “基准”(pivot);
- 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;
- 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序;
- 代码实现
void quickSort1(int a[],int low, int high) {
if(low<high) { //只有low<high时,进行排序
int i = low;
int j = high;
int temp = a[low];//将第一个元素记录为基准元素
while(i<j) {
while(i<j && a[j]>=temp) {
//从第j个位置从后往钱查找小于基准元素的值
j--;
}
while(i<j && a[i]<=temp) {
//从i位置开始从前往后的找到第一个大于等于temp值
i++;
}
if(i<j) {
//交换i,j元素的值
int t=a[i];
a[i]=a[j];
a[j]=t ;
}
}
a[low] = a[i];//将基准元素与最终位置上的元素位置互换
a[i]= temp;
quickSort1(a,low,i-1); //递归调用,排序左右集合
qucikSort1(a,i+1.high);
}
}
九、散列查找—线性探测法
使用散列函数H (key) = key%11, 用线性探测法处理冲突,把一个整数值转
换成散列表下标,现在要把数据{1,13,47,23,27,15,134,154}依次插入散列表
,计算出等概率情况下查找成功和查找失败的平均查找长度
key | h |
---|---|
1 | 1 |
13 | 2 |
47 | 5 |
23 | 1 |
27 | 5 |
15 | 4 |
134 | 2 |
154 | 0 |
- 答案
十、编写挖坑法的快速排序算法
①i =low; j = high; 将基准数挖出形成第一个坑 a[low];
②j–由 后向前找比它小的数,找到后挖出此数填前一个坑 a[i]中;
③i++由前向后找比 它大的数,找到后也挖出此数填到前一个坑 a[j]中;
④再重复执行 2 ,3 二步, 直到 i==j,将基准数填入 a[i]中。
void quickSort1(int a[],int low, int high) {
if(low<high) { //只有low<high时,进行排序
int i = low;
int j = high;
int temp = a[low];//将第一个元素记录为基准元素
while(i<j) {
while(i<j && a[j]>=temp) {
//从第j个位置从后往钱查找小于基准元素的值
j--;
}
if(i<j) {
//找到第一个比基准元素小的右侧元素,填上一个坑
a[i]=a[j];
}
while(i<j && a[i]<=temp) {
//从i位置开始从前往后的找到第一个大于等于temp值
i++;
}
if(i<j) {
//找到一个比基准元素大的左侧元素,填上一个坑
a[j]=a[i];
}
}
a[i]= temp;//i==j 更新基准元素
quickSort1(a,low,i-1); //递归调用,排序左右集合
qucikSort1(a,i+1.high);
}
}
十一、散列函数----链地址法
使用散列函数H (key) = key%11, 用链地址法解决冲突来构造散列表,现在
要把数据{1,13,47,23,27,15,134,154}依次插入散列表,计算出等概率情况下
查找成功和查找失败的平均查找长度
- 注意点
- 查找失败时,有时只累加关键字节点比较次数即可,有时还需要加上空白节点
- 找构建表时,应特别注意表的长度有散列函数中%d中d的大小的关系,比如该题d为11,则表的长度应至少为12
十二、线性表分割
设有一组初始记录关键字序列(K1,K2,…,Kn),要求设计一个算法能够 在
O(n)的时间复杂度内将线性表划分成两部分,其中左半部分的每个关键字均 小
于 Ki,右半部分的每个关键字均大于等于 Ki。
- 算法思想
使用快排的思想。设置某个标志位,首先,将 Ki 与需要交换的第一个关键
字即大于或者等于 Ki 的值进行交换, 这样前半部分均为小于 Ki 的关键字。此时
可以假设 Ki 为枢轴, 前半部分不管, 对 ki 开始的后半部分, 执行快速排序。比
如,关键字为 1 2 8 3 4 6 7 9, ki 为 4,首先找到 8,将 8 与 4 交换位置,之
后 以 4 为枢轴开始比较,前面的 1、2 两个数不再考虑。算法如下: - 代码实现
void quickpass(int K[],int n, int i) {
int l =0,r=n-1;
int P= K[--i];
bool flag = true;
while(l < r ) {
while(l<r && K[l]<P) //左半部分小于p的值
l++;
if(l<r) {
if(flag) {
K[i]=K[l];
flag= false;
} else {
K[r]=K[l];
r--;
}
}
while(l<r && K[r]>P)//右半部分大于p的值
r--;
if(l<r) {
K[l]=K[r];
l++;
}
}
K[l]=P;
}
十三、散列函数—二次探测法
设有一组关键字{1,23,12,13,8,47,15,17},采用哈希函数H(key) = key
mod 7,表长为10,用开放定地法的二次探测在散列方法Hi = (H(key)+di) mod
10(di = 1^2,2^2,3^2...)解决冲突。要求:对该关键字序列构造哈希表,并计算
查找成功的平均查找长度