数据结构练习题一

数据结构练习题一

一、双向冒泡

• 普通冒泡排序算法：是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

• 双向冒泡排序算法：在正反两个方向交替进行扫描,即第一趟把关键字最大的元素放在序列的最后面,第二趟把关键字最小的元素放在序列的最前面,如此反复进行。

#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) 的归并排序要小很多。
所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。

• 算法步骤

1. 从数列中挑出一个元素，称为 “基准”（pivot）;
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3. 递归地（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}依次插入散列表，计算出等概率情况下
查找成功和查找失败的平均查找长度

• 注意点
  1. 查找失败时，有时只累加关键字节点比较次数即可，有时还需要加上空白节点
  2. 找构建表时，应特别注意表的长度有散列函数中%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...）解决冲突。要求：对该关键字序列构造哈希表，并计算
查找成功的平均查找长度