数据结构练习(三)1252_百度文库
数据结构练习(三)1252
19、立志宜思真品格，读书须尽苦功夫——阮元
数据结构练习（三）参考
一、选择题
1.顺序查找法适合于存储结构为
A）哈希存储
B）顺序存储或链式存储
C）压缩存储
D）索引存储
2.一个长度为100的已排好序的表，用二分查找法进行查找，若查找不成功，至少比较________次
3.采用顺序查找方法查找长度为n的线性表时，平均比较次数为
C）（n+1）/2
D）（n-1）/2
4.对线性表进行折半查找时，要求线性表必须
A）以顺序方式存储
B）以顺序方式存储，且结点按关键字有序排列
C）以链表方式存储
D）以链表方式存储，且结点按关键字有序排列
5.采用二分查找法查找长度为n的线性表时，每个元素的平均查找长度为
A）O（n2）
B）O（nlog2n）
D）O（log2n）
6.有一个长度为12的有序表R[0...11]，按折半查找法对该表进行查找，在表内各元素等概率查找情况下查找成功所需的平均比较次数为
7.有一个有序表为{1，3，9，12，32，41，45，62，75，77，82，95，99}，当采用折半查找法查找关键字为82的元素时，
次比较后查找成功
8.当采用分块查找时，数据的组织方式为
A）数据分成若干块，每块内存数据有序
B）数据分成若干块，每块内数据不必有序，但块间必须有序，每块内最大(或最小)的数据组成索引块
C）数据分成若干块，每块内数据有序，每块内最大（或最小）的数据组成索引块
D）数据分成若干块，每块（出最后一块外）中的数据个数需相同
9.采用分块查找时，若线性表中共有625个元素，查找每个元素的概率相同，假设采用顺序查找来确定结点所在的块时，每块应有
个结点最佳
10. 不能生成右图所示二叉排序树的关键字序列是_____
A）45312 B）42531 C）45213 D）42315
11.按____遍历二叉排序树，可以得到按值递增或递减次序的关键码序列
12.在一棵平衡二叉树中，每个结点的平衡因子的取值范围是
13.具有5层结点的AVL树至少有
14.在含有15个结点的平衡二叉树上，查找关键字为28的结点，则依次比较的关键字可能是
B）38.48.28
C）48，18，38，28
D）60，30，50，40，38，36
15.一棵深度为k的平衡二叉树，其每个非叶子结点的平衡因子均为0，则该树共有
C）2k-1 +1
贡献者：jcgzhso80462
喜欢此文档的还喜欢&&&& 本人因为最近工作用到了一些排序算法，就把几个简单的排序算法，想冒泡排序，选择排序，插入排序，奇偶排序和快速排序等整理了出来，代码用C#代码实现，并且通过了测试。希望能给大家提供参考。
&&& 1.冒泡排序
&&&&&&&冒泡排序，是指计算机的一种排序算法，它的时间复杂度是O（n^2），虽然不及堆排序和快速排序时间复杂度为O（nlogn，底数为2），但是有两个优点：1：编程复杂度低，很容易实现；2 是具有稳定性，这里的稳定性是指源序列中相同元素的相对顺序仍然保持到排序后的顺序，而堆排序和快速排序都不具有稳定性。
&&&& 基本概念
&&&&&&&& 冒泡排序（BubbleSort)的基本概念：依次比较相邻两个数，小的在前，大的在后。在第一趟，首先比较第1个数和第2个数，小的放在前面，大的放在后面，然后比较第2个数和第3个数，小的在前，大的在后，如此继续，直到比较最后两个数，小的在前，大的在后，第一趟结束时，就把最大的数放在了最后。在第二趟，仍从第一对数开始比较（因为由于第2个数和第3个数的交换，使第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一个数已经是最大的），第二趟结束，这样在倒数第二个位置得到一个新的最大数，如此循环下去，重复以上过程，直至最终完成排序。
比如有一个数列10, 33, 2, 4, 55, 6, 12, 34, 456, 66, 43, 23, 65, 1, 345, 61, 76, 31, 43, 76
第一次排序后：10,2,4,33,6,12,34,55,66,43,23,65,1,345,61,76,31,43,76,456
第二次排序后：2,4,10,6,12,33,34,55,43,23,65,1,66,61,76,31,43,76,345,456
第三次排序后：2,4,6,10,12,33,34,43,23,55,1,65,61,66,31,43,76,76,345,456
第四次排序后：2,4,6,10,12,33,34,23,43,1,55,61,65,31,43,66,76,76,345,456
第五次排序后: 2,4,6,10,12,33,23,34,1,43,55,61,31,43,65,66,76,76,345,456
第六次排序后: 2,4,6,10,12,23,33,1,34,43,55,31,43,61,65,66,76,76,345,456
第七次排序后: 2,4,6,10,12,23,1,33,34,43,31,43,55,61,65,66,76,76,345,456
第八次排序后: 2,4,6,10,12,1,23,33,34,31,43,43,55,61,65,66,76,76,345,456
第九次排序后: 2,4,6,10,1,12,23,33,31,34,43,43,55,61,65,66,76,76,345,456
第十次排序后: 2,4,6,1,10,12,23,31,33,34,43,43,55,61,65,66,76,76,345,456
第十一次排序后：2,4,1,6,10,12,23,31,33,34,43,43,55,61,65,66,76,76,345,456
第十二次排序后：2,1,4,6,10,12,23,31,33,34,43,43,55,61,65,66,76,76,345,456
第十三次排序后: 1,2,4,6,10,12,23,31,33,34,43,43,55,61,65,66,76,76,345,456
这样经过13趟排序后这个序列就成为一个有序的数列。
具体实现代码为：
&&&&&& private static void BubbleSort(int[] R)&&&&&&& {&&&&&&&&&&& int len = R.L&&&&&&&&&&& bool flag =&&&&&&&&&&& for (int i = 0; i & len-1; i++)&&&&&&&&&&& {&&&&&&&&&&&&&&& flag =&&&&&&&&&&&&&&& for (int j = 0; j & len - i-1; j++)&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&& if (R[j] & R[j + 1])&&&&&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&&&&&& Swap(ref R[j], ref R[j + 1]);&&&&&&&&&&&&&&&&&&&&&&& flag =&&&&&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&& if (!flag)&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& }&&&&&&&&&&& }&&&&&&& }
&&&&&& private static void Swap(ref int left, ref int right)&&&&&&& {&&&&&&&&&&& int temp =&&&&&&&&&&& left =&&&&&&&&&&& right =&&&&&&& }
2. 选择排序
&&&&& 每一趟从待排序的元素中选择最小的（最大的）一个元素，顺序放在已排好序的数列的最后，直到待排序的元素派完，选择排序是不稳定的排序。
&&& 基本概念
&&&&&&&&& 具有n元素的数列可以进行n-1趟直接选择排序得到有序结果，初始状态有序区为空，无序区为R[1...n]
&&&&&&&&& 第1趟排序在无序区R[1...n]选择关键字最小的元素R[k],将它与无序区的R[1] 进行交换，使R[1...1]和R[2...n]变为个增加为1新有序区，和无序区的元素个数减去1的新无序区。
&&&&&&&&&第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(1&i&n-1)。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，
&&&&&&&& 使R[1..i]和R分别变& 为记录个数增加1个的新有序区和记录个数减少1个的新无序区。 这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果&.
&&&&&&&& 对于数列&&& 10,33,2,4,55,6,12,34,456,66,43,23,65,1,345, 61,76,31,43,76&&&&&
&&&&&&&& 第一次排序后：1,33,2,4,55,6,12,34,456,66,43,23,65,10,345,61,76,31,43,76
&&&&&&&& 第二次排序后:& 1,2,33,4,55,6,12,34,456,66,43,23,65,10,345,61,76,31,43,76
&&&&&&&& 第三次排序后：1,2,4,33,55,6,12,34,456,66,43,23,65,10,345,61,76,31,43,76
&&&&&&&& 第四次排序后：1,2,4,6,55,33,12,34,456,66,43,23,65,10,345,61,76,31,43,76
&&&&&&&& 第五次排序后：1,2,4,6,10,33,12,34,456,66,43,23,65,55,345,61,76,31,43,76
&&&&&&&& 第六次排序后:& 1,2,4,6,10,12,33,34,456,66,43,23,65,55,345,61,76,31,43,76
&&&&&&&& 第七次排序后:& 1,2,4,6,10,12,23,34,456,66,43,33,65,55,345,61,76,31,43,76
&&&&&&&& 第八次排序后:&&1,2,4,6,10,12,23,31,456,66,43,33,65,55,345,71,76,34,43,76
&&&&&&&&&第九次排序后:&&1,2,4,6,10,12,23,31,33,66,43,456,65,55,345,71,76,34,43,76
&&&&&&&& 第十次排序后:& 1,2,4,6,10,12,23,31,33,34,43,456,65,55,345,71,76,66,43,76
&&&&&&&&&第十一次排序后: 1,2,4,6,10,12,23,31,33,34,43,43,65,55,345,71,76,66,456,76
&&&&&&& &第十二次排序后:& 1,2,4,6,10,12,23,31,33,34,43,43,55,65,345,71,76,66,456,76
&&&&&&&& 第十三次排序后:&&1,2,4,6,10,12,23,31,33,34,43,43,55,65,66,71,76,345,456,76
&&&&&&& 第十四次排序后:&& 1,2,4,6,10,12,23,31,33,34,43,43,55,65,66,71,76,76,456,345
&&&&&&& 第十五次排序后:&& 1,2,4,6,10,12,23,31,33,34,43,43,55,65,66,71,76,76,345,456
&&&&&& 最终经过15次排序后成为有序的数列。
&&&&&& 具体实现代码为：
&&&&&&& private static void SelectSort(int[] R)&&&&&&& {&&&&&&&&&&& int len = R.L&&&&&&&&&&& int min = 0;&&&&&&&&&&& for (int i = 0; i & len - 1; i++)&&&&&&&&&&& {&&&&&&&&&&&&&&& min =&&&&&&&&&&&&&&& for (int j = i + 1; j & len - 1; j++)&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&& if (R[min] & R[j])&&&&&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&&&&&& min =&&&&&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&& Swap(ref R[i], ref R[min]);&&&&&&&&&&& }&&&&&&& }
3. 插入排序
&&&&&&& 插入排序算法是一种稳定的算法，时间复杂度是O(n^2)，适用于少量数据的排序。插入算法的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的，个数加1的有序数据。插入算法把要排序的数组分为两部分：第一部分包含了数组的所有元素，但将最后一个元素除外，而第二部分就只包含这一个元素，在第一部分排序后，再把最后这个元素插入到此刻已是有序的一部分中。
&&&基本思想
&&&&&&&& 1：每次处理都是将无序序列的第一个元素和有序序列的元素从后面逐一比较，查到合适的插入位置，将该元素插入到有序序列的合适位置。
&&&&&&&& 2：从有序R[1]和无序R[2...n]开始进行排序。
&&&&&&&&&3：处理第i个元素时(i=2,3,&,n) ,数列{R1,R2,...Ri-1}都是有序的，而数列{Ri,Ri+1,...Rn}都是无序的，用Ri 与{R1,R2,...Ri-1}逐个比较，找到合适位置，将Ri插入，
&&&&&&&& 4：重复第三部，共进行n-i次插入处理，数组全部有序
&&&&&&&& 对于数列&&& 10,33,2,4,55,6,12,34,456,66,43,23,65,1,345, 61,76,31,43,76&&&&&
&&&&&&& 第一次排序后：10,33,2,4,55,12,34,456,66,43,23,65,1,345,61,76,31,43,76
&&&&&&& 第二次排序后:& 2,10,33,4,55,12,34,456,66,43,23,65,1,345,61,76,31,43,76
&&&&&&& 第三次排序后:& 2,4,10,33,55,12,34,456,66,43,23,65,1,345,61,76,31,43,76
&&&&&&& 第四次排序后:& 2,4,10,33,55,12,34,456,66,43,23,65,1,345,61,76,31,43,76
&&&&&&& 第五次排序后:& 2,3,10,12,33,55,34,456,66,43,23,65,1,345,61,76,31,43,76
&&&&&&& 第六次排序后:& 2,3,10,12,33,34,55,456,66,43,23,65,1,345,61,76,31,43,76
&&&&&&& 第七次排序后:&&2,3,10,12,33,34,55,456,66,43,23,65,1,345,61,76,31,43,76
&&&&&&& 第八次排序后:& 2,3,10,12,33,34,55,66,456,43,23,65,1,345,61,76,31,43,76
&&&&&&&&第九次排序后:& 2,3,10,12,33,34,43,55,66,456,23,65,1,345,61,76,31,43,76
&&&&&&& 第十次排序后:& 2,3,10,12,23,33,34,43,55,66,456,65,1,345,61,76,31,43,76
&&&&&&& 第十一次排序后: 2,3,10,12,23,33,34,43,55,65,66,456,1,345,61,76,31,43,76
&&&&&&& 第十二次排序后: 1,2,3,10,12,23,33,34,43,55,65,66,456,345,61,76,31,43,76
&&&&&&& 第十三次排序后: 1,2,3,10,12,23,33,34,43,55,65,66,345,456,61,76,31,43,76
&&&&&&& 第十四次排序后: 1,2,3,10,12,23,33,34,43,55,61,65,66,345,456,76,31,43,76
&&&&&&& 第十五次排序后: 1,2,3,10,12,23,33,34,43,55,61,65,66,76,345,456,31,43,76
&&&&&&& 第十六次排序后: 1,2,3,10,12,23,31,33,34,43,55,61,65,66,76,345,456,43,76
&&&&&&&&第十七次排序后:&1,2,3,10,12,23,31,33,34,43,43,55,61,65,66,76,345,456,76
&&&&&&& 第十八次排序后: 1,2,3,10,12,23,31,33,34,43,43,55,61,65,66,76,76,345,456
&&&&&& 共十八次排序后，数组才是全部有序的。
&&&&& 实现代码为:
&&&&&&&& private static void InsertSort(int[] R)&&&&&&& {&&&&&&&&&&& int len = R.L&&&&&&&&&&& int j = 0;&&&&&&&&&&& int temp = 0;&&&&&&&&&&& for (int i = 1; i & i++)&&&&&&&&&&& {&&&&&&&&&&&&&&& temp=R[i];&&&&&&&&&&&&&&& j=i-1;&&&&&&&&&&&&&&& while (j &= 0 && temp & R[j])&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&& R[j + 1] = R[j];&&&&&&&&&&&&&&&&&&& j--;&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&& R[j + 1] =&&&&&&&&&&& }&&&&&&& }
4. 快速排序
&&&&&&&&&&&快速排序是对冒泡排序的一种改进，它的基本思想是：通过一趟排序将要排序的数列分成独立的两个部分，其中一部分的所有数据都比后一部分的所有数据都要小，然后再按此方法对这两个部分分别进行快速排序，整个排序过程可以递归进行，以次达到整个数列变为有序。快速排序不是稳定的排序。
& 算法过程
&&&&&&&& 设要排序的数组为R[1...n],首先任意选取一个元素（通常选择第一个元素）作为关键元素，然后把所有比它小的都放在前面，所有比它大的都放在后面，这个过程成为一趟快速排序。
&&&&&&&& 1. 设置两个变量 low ,high,排序开始的时候low=0,high=n-1;
&&&&&&&& 2. 以第一个数组元素为关键数据key,即key = R[low];
&&&&&&&& 3. 从high开始往前搜索，即由后开始向前搜索，high=high-1,找到第一个小于key的值R[high], 并执行 R[low] = R[high];
&&&&&&&&&4. 从low 开始向后搜索，即由前开始向后搜索，low=low+1,找到第一个大于key的值R[low],并执行R[high] = R[high];
&&&&&&&&&5. 重复3,4.直到low=high.
&&&&&&&&&&& 对于数列&&& 10,33,2,4,55,6,12,34,456,66,43,23,65,1,345, 61,76,31,43,76&&&
&&&&&&&&&&&初始关键数据key=10;
&&&&&&&&&&&第一次交换后：1, 33, 2, 4, 55, 6, 12, 34, 456, 66, 43, 23, 65, 1, 345, 61, 76, 31, 43, 76
&&&&&&&&&&&第二次交换后:&&1, 33, 2, 4, 55, 6, 12, 34, 456, 66, 43, 23, 65, 33, 345, 61, 76, 31, 43, 76
&&&&&&&&&& 第三次交换后:&& 1, 6, 2, 4, 55, 6, 12, 34, 456, 66, 43, 23, 65, 33, 345, 61, 76, 31, 43, 76
&&&&&&&&&&&第四次交换后:&&1, 6, 2, 4, 55, 55, 12, 34, 456, 66, 43, 23, 65, 33, 345, 61, 76, 31, 43, 76
&&&&&&&&& 这样low=high=4
&&&&&&&&&& 再把R[low]=key
&&&&&&&&&&这样第一次快速排序后数列就变为{1,6,2,4}10{55,12,34,456,66,43,23,65,33,345,61,76,31,43,76}&&
&&&&&&&&&&这样再分别对{1,6,2,4}和{55,12,34,456,66,43,23,65,33,345,61,76,31,43,76}&&分别进行快速排序,重复这个步骤，最终使整个数组都是有序的。
&&&&&&&& 具体实现代码为：
&&&&&&&&& private static void QuickSort(int[] R, int low, int high)&&&&&&& {&&&&&&&&&&& int pivotLoc = 0;
&&&&&&&&&&& if(low&high)
&&&&&&&&&&&& {&&&&&&&&&&&&&&&& &pivotLoc = Partition(R, low, high);&&&&&&&&&&&&&&& & QuickSort(R, low, pivotLoc - 1);&&&&&&&&&&&&&&&&& QuickSort(R, pivotLoc + 1, high);
&&&&&&&&&&&&& }&&&&&&& }
&&&&&&& private static int Partition(int[] R, int low, int high)&&&&&&& {&&&&&&&&&&& int temp = R[low];&&&&&&&&&&& while (low & high)&&&&&&&&&&& {&&&&&&&&&&&&&&& while (low & high && temp &= R[high])&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&& high--;&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&& R[low] = R[high];&&&&&&&&&&&&&&& while (low & high && temp &= R[low])&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&& low++;&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&& R[high] = R[low];&&&&&&&&&&& }&&&&&&&&&&& R[low] =&&&&&&&&&&&&&&&&&& }
&&& //快速非递归排序&&&&&&& public static void QuickSort(int[] R, int Low, int High, Stack&int& stack)&&&&&&& {&&&&&&&&&&& int low = L&&&&&&&&&&& int high = H&&&&&&&&&&& int key= R[low];&&&&&&&&&&& while (high & low)&&&&&&&&&&& {&&&&&&&&&&&&&&& while (low & high && key&= R[high])&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&& high--;&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&& if (high & low)&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&& R[low] = R[high];&&&&&&&&&&&&&&&&&&& R[high] =&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&& while (low & high && key&= R[low])&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&& low++;&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&& if (high & low)&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&& R[high] = R[low];&&&&&&&&&&&&&&&&&&& R[low] =&&&&&&&&&&&&&&& }
& & & & & & & }&&&&&&&&&&&&&&& if (low == high)&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&& if (Low & low - 1)&&&&&&&&&&&&&&&&&&& {
& 　　　　　　　　stack.Push(low - 1);&&&&&&&&&&&&&&&&&&&&&&& stack.Push(Low);&&&&&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&&&&&& if (High & low + 1)&&&&&&&&&&&&&&&&&&& {
& &　　　　　　　stack.Push(High);&&&&&&&&&&&&&&&&&&&&&&& stack.Push(low + 1);&&&&&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&& }& & & & & &&&&&&&&& }
&&&&&& 测试代码：
&static void Main(string[] args)
&&&&&&& int[] arry = new int[] { 10, 33, 2, 4, 55, 6, 12, 34, 456, 66, 43, 23, 65, 1, 345, 61, 76, 31, 43, 76 };&&&&&&&&&&& Stack&int& s=new Stack&int&();&
& & & & & & s.Push(arry.Length - 1);
&&&&&&&&&&& s.Push(0);& & & & & &&int low&= 0;
　　　　&int high&&= 0 ;
&&&&&&&&&&& while (s.Count & 0)&&&&&&&&&&& {& & & & & & & & &low = s.Pop();& & & & & & & & &high = s.Pop();&&&&&&&&&&&&&&& QuickSort(arry, low, high, s);&&&&&&&&&&&&& &&&&&&&&&&& }&&&&&& &&&&&&&&&&& Console.ReadLine();
通过对10万条随机数据进行递归和非递归排序后发现，非递归方法的速度是递归方法速度的40倍左右。
5 . 一个无序的数组，如何通过一个函数取出最大值和最小值，要求时间复杂度最低和空间最少
& 具体算法如下：
&&&&&&& private static int[] GetMaxMin(int[] R)&&&&&&& {&&&&&&&&& &&&&&&&&&&& int len=R.L&&&&&&&&&&& int min = R[0];&&&&&&&&&&& int max = R[0];&&&&&&&&&&& for (int i = 1; i &i++ )&&&&&&&&&&& {&&&&&&&&&&&&&&& if (min & R[i])&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&& min = R[i];&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&& if (max & R[i])&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&& max = R[i];&&&&&&&&&&&&&&& }&&&&&&&&&&& }&&&&&&&&&&& int[] res = new int[2];&&&&&&&&&&& res[0] =&&&&&&&&&&& res[1] =&&&&&&&&&&&
&&&&&&& }6对于已知数组，随机存储一百个数，把奇数放左边，偶数放右边，具体算法如下：
&&&&&&&&7.二分查找算法&
&&&&&&&&&&&&&&& 二分查找算法又叫折半查找，优点是比较次数少，查找速度快，平均性能好，缺点是给定的数组必须是有序的，且插入删除困难，因此二分查找使用与不经常变动而又查找频繁的有序表。 首先，假设数组是按照升序的有序表，将表中间位置的元素与给定要查找的元素比较，如果相等，则查找成功，否则利用中间位置将表分为前后两个字表，如果中间位置记录的元素大于给定的查找的数据，在前面的字表中进行查找，否则在后面的字表中进行查找。重复以上过程，直到找到或没有子表为止。
具体实现代码如下：
&&&&&& private static int BinarySearch(int[] R, int arg)&&&&&&& {&&&&&&&&&&& int low = 0;&&&&&&&&&&& int high = R.Length - 1;&&&&&&&&&&& while (low & high)&&&&&&&&&&& {&&&&&&&&&&&&&&& int middle = (low + high) / 2;&&&&&&&&&&&&&&& if (arg == R[middle])&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&& else if (arg & R[middle])&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&& high = middle - 1;&&&&&&&&&&&&&&& }&&&&&&&&&&&&&&& else&&&&&&&&&&&&&&& {&&&&&&&&&&&&&&&&&&& low = middle + 1;&&&&&&&&&&&&&&& }&&&&&&&&&&& }&&&&&&&&&&& return -1;&&&&&&& }
阅读(...) 评论()1. 新增扫二维码功能，可直接扫 VeryCD 网站影片页面的二维码，便能在应用上打开；
2. 新增支持 B 站视频（哔哩哔哩），满屏的弹幕更欢乐；
1. 新增支持 B 站视频（哔哩哔哩），满屏的弹幕更欢乐；
2. 在影片封面上展示在线视频的清晰度；
您的位置：
图书分类:&网络出版社:&语言:&
收藏资源后，一旦有新更新（字幕、文件）我们
将会用站内消息和电子邮件通知你。
收藏资源后，一旦有新更新（字幕、文件）我们
将会用站内消息和电子邮件通知你。
该内容尚未提供权利证明，无法提供下载。
中文名:&算法：C语言实现(第1-4部分)基础知识、数据结构、排序及搜索（原书第3版）原名:& Algorithms in C, Parts 1-4: Fundamentals, Data Structures, Sorting, Searching (3rd Edition) (Pts. 1-4) 作者:&译者:&图书分类:&网络资源格式:&PDF版本:&扫描版出版社:&书号:&地区:&语言:&简介:&
评论处1楼有网盘链接内容介绍：　　本书细腻讲解计算机算法的c语言实现。全书分为四部分，共16章。包括基本算法分析原理，基本数据结构、抽象数据结构、递归和树等数据结构知识，选择排序、插入排序、冒泡排序、希尔排序、快速排序方法、归并和归并排序方法、优先队列与堆排序方法、基数排序方法以及特殊用途的排序方法，并比较了各种排序方法的性能特征，在进一步讲解符号表、树等抽象数据类型的基础上，重点讨论散列方法、基数搜索以及外部搜索方法。书中提供了用c语言描述的完整算法源程序，并且配有丰富的插图和练习，还包含大量简洁的实现将理论和实践成功地相结合，这些实现均可用在真实应用上。.　　 本书内容丰富，具有很强的实用价值，适合作为高等院校计算机及相关专业本科生算法课程的教材，也是广大研究人员的极佳参考读物。　　 本书是sedgewick彻底修订和重写的c算法系列的第一本。全书分为四部分，共16章。第一部分“基础知识”(第1～2章)介绍基本算法分析原理。第二部分“数据结构”(第3～5章)讲解算法分析中必须掌握的数据结构知识，主要包括基本数据结构、抽象数据结构、递归和树。第三部分“排序”(第6～11章)按章节顺序分别讨论基本排序方法(如选择排序、插入排序、冒泡排序、希尔排序等)、快速排序方法、归并和归并排序方法、优先队列与堆排序方法、基数排序方法以及特殊用途的排序方法，并比较了各种排序方法的性能特征。第四部分“搜索”(第12～16章) 在进一步讲解符号表、树等抽象数据类型的基础上，重点讨论散列方法、基数搜索以及外部搜索方法。..　　 书中提供了用c语言描述的完整算法源程序，并且配有丰富的插图和练习。作者用简洁的实现将理论和实践成功地结合了起来，这些实现均可在真实应用上测试，使得本书自问世以来备受程序员的欢迎。　　 本书可作为高等院校计算机相关专业算法与数据结构课程的教材和补充读物，也可供自学之用。　　 本书作者的网站http://www.cs.princeton.edu/～rs/为程序员提供了本书的源代码和勘误表。... 内容截图：
出版者的话译者序前言第一部分 基础知识第1章 引言 11.1 算法 11.2 典型问题—连通性 21.3 合并－查找算法 51.4 展望 121.5 主题概述 13第2章 算法分析的原理 152.1 实现和经验分析 152.2 算法分析 172.3 函数的增长 192.4 大o符号 232.5 基本递归方程 272.6 算法分析示例 292.7 保证、预测及局限性 33第二部分 数据结构第3章 基本数据结构 37.3.1 构建组件 373.2 数组 443.3 链表 493.4 链表的基本处理操作 543.5 链表的内存分配 603.6 字符串 633.7 复合数据结构 66第4章 抽象数据类型 744.1 抽象对象和对象集 764.2 下推栈adt 784.3 栈adt客户示例 794.4 栈adt的实现 844.5 创建一个新adt 874.6 fifo队列和广义队列 904.7 复制和索引项 954.8 一级adt 994.9 基于应用的adt示例 1064.10 展望 110第5章 递归与树 1115.1 递归算法 1115.2 分治法 1165.3 动态规划 1275.4 树 1335.5 树的数学性质 1385.6 树的遍历 1405.7 递归二叉树算法 1455.8 图的遍历 1495.9 综述 155第三部分 排序第6章 基本排序方法 1576.1 游戏规则 1586.2 选择排序 1616.3 插入排序 1626.4 冒泡排序 1646.5 基本排序方法的性能特征 1666.6 希尔排序 1716.7 对其他类型的数据进行排序 1776.8 索引和指针排序 1806.9 链表排序 1856.10 关键字索引统计 188第7章 快速排序 1917.1 基本算法 1917.2 快速排序算法的性能特征 1957.3 栈大小 1987.4 小的子文件 2017.5 三者取中划分.. 2037.6 重复关键字 2067.7 字符串和向量 2097.8 选择 210第8章 归并与归并排序 2138.1 两路归并 2138.2 抽象原位归并 2158.3 自顶向下的归并排序 2168.4 基本算法的改进 2198.5 自底向上的归并排序 2208.6 归并排序的性能特征 2238.7 归并排序的链表实现 2258.8 改进的递归过程 227第9章 优先队列和堆排序 2299.1 基本操作的实现 2319.2 堆数据结构 2339.3 基于堆的算法 2359.4 堆排序 2409.5 优先队列adt 2449.6 索引数据项的优先队列 2479.7 二项队列 250第10章 基数排序 25810.1 位、字节和字 25910.2 二进制快速排序 26110.3 msd基数排序 26510.4 三路基数快速排序 27110.5 lsd基数排序 27410.6 基数排序的性能特征 27810.7 亚线性时间排序 280第11章 特殊用途的排序方法 28411.1 batcher奇偶归并排序 28411.2 排序网 28911.3 外部排序 29511.4 排序－归并的实现 29911.5 并行排序/归并 303第四部分 搜索第12章 符号表和二叉搜索树 30712.1 符号表抽象数据类型 30812.2 关键字索引搜索 31112.3 顺序搜索 31312.4 二分搜索 31812.5 二叉搜索树 32112.6 bst的性能特征 32712.7 符号表的索引实现 32912.8 在bst的根节点插入 33212.9 其他adt函数的bst实现 336第13章 平衡树 34313.1 随机化bst 34513.2 伸展bst 35013.3 自顶向下2-3-4树 35513.4 红黑树 36013.5 跳跃表 36813.6 性能特征 374第14章 散列 37714.1 散列函数 37714.2 链地址法 38514.3 线性探测法 38814.4 双重散列表 39214.5 动态散列表 39614.6 综述 399第15章 基数搜索 40215.1 数字搜索树 40215.2 线索 40615.3 帕氏线索 41315.4 多路线索和tst 41915.5 文本字符串索引算法 430第16章 外部搜索 43416.1 游戏规则 43516.2 索引顺序访问 43616.3 b树 43816.4 可扩展散列 44716.5 综述... 455
正在读取……
这里是其它用户补充的资源():
暂无补充资源
使用 BBCODE()
类似“顶”、“沙发”之类没有营养的文字，对勤劳贡献的楼主来说是令人沮丧的反馈信息。
提问之前请再仔细看一遍楼主的说明，或许是您遗漏了。
勿催片。请相信驴友们对分享是富有激情的，如果确有更新版本，您一定能搜索到。
请勿到处挖坑绊人、招贴广告。既占空间让人厌烦，又没人会搭理，于人于己都无利。
如果您发现自己的评论不见了，请参考以上4条。
刚收藏了本资源的用户
正在读取……
上海隐志网络科技有限公司
打个分吧：
留点口水(可选)：}