这道数据结构题怎么做？ 这道关于《数据结构》的题该如何做呢？
\u8bf7\u95ee\u4e00\u4e0b\u8fd9\u9053\u6570\u636e\u7ed3\u6784\u9898\u76ee\u600e\u4e48\u505a\uff1f\u7b54\u6848\u662f:
N%8
S
\u89e3\u91ca\uff1a\u5341\u8fdb\u5236\u8f6c\u516b\u8fdb\u5236\u7684\u65b9\u6cd5\u6709\u4e24\u79cd\uff1a
1.\u5148\u628a\u5341\u8fdb\u5236\u8f6c\u6210\u4e8c\u8fdb\u5236\uff0c\u7136\u540e\u518d\u7531\u4e8c\u8fdb\u5236\u8f6c\u6210\u516b\u8fdb\u5236\u3002
2.\u6309\u7167\u96648\u53d6\u4f59\u6cd5\uff0c\u76f4\u5230\u5546\u4e3a0\u4e3a\u6b62\u3002\u5373\uff1a
1\uff09\u5c06\u6574\u6570\u90e8\u5206\u9664\u4ee58\uff0c\u4f59\u6570\u4e3a\u516b\u8fdb\u5236\u8be5\u4f4d\u6743\u4e0a\u7684\u6570\uff0c\u5165\u6808\uff1b
2\uff09\u7528\u5546\u7ee7\u7eed\u9664\u4ee58\uff0c\u4f59\u6570\u53c8\u4e3a\u516b\u8fdb\u5236\u4f4d\u6743\u4e0a\u7684\u6570\uff0c\u5165\u6808\u3002
3\uff09\u5546\u4e0d\u4e3a0\uff0c\u5219\u91cd\u590d2\uff09\uff1b\u5546\u4e3a\u96f6\uff0c\u7ed3\u675f\u5faa\u73af\u3002
4\uff09\u6700\u540e\u4ece\u6700\u540e\u4e00\u4e2a\u4f59\u6570\u5411\u524d\u6392\u5217\u5c31\u53ef\u4ee5\u4e86\u3002\u56fe\u793a\uff1a
\u8be5\u9898\u9009\u62e9\u7684\u662f\u7b2c\u4e8c\u79cd\u65b9\u6cd5\u3002
\u5982\u679c\u4e0e\u540e\u7ee7\u5143\u7d20\u4f4d\u7f6e\u4ea4\u6362\u4e86\u5c82\u4e0d\u662f\u5c31\u4e0d\u518d\u9012\u589e\u6709\u5e8f\u4e86\uff1f...\u90a3\u4e48\u5c31\u6ca1\u6709\u4ec0\u4e48\u6027\u8d28\u4e86\uff1f
\u4e0d\u8fc7\u770b\u9898\u76ee\u610f\u601d\u597d\u50cf\u662f\u53ea\u8981\u6c42\u8fdb\u884c\u4e00\u6b21\u64cd\u4f5c\uff0c\u800c\u4e14\u53ea\u8981\u6c42\u67e5\u627e\u5230\u5b83\u7684\u65f6\u95f4\u6700\u77ed\u3002
\u6709\u4e00\u79cd\u6bd4\u8f83\u7b80\u5355\u7684\u505a\u6cd5\uff0c\u5c31\u662f\u4e8c\u5206\u6cd5\u3002
\u6bcf\u6b21\u4e8c\u5206\u8fd9\u4e2a\u6709\u5e8f\u6570\u7ec4\u4e2d\u7684\u4e00\u4e2a\u4f4d\u7f6emid=(l+r)/2\u3002\u7136\u540e\u5224\u65ad\u8fd9\u4e2a\u5143\u7d20\u548cx\u7684\u5927\u5c0f\u5173\u7cfb\u3002
\u5982\u679ca[mid]>x\uff0c\u90a3\u4e48\u53ef\u4ee5\u5c06r\u79fb\u52a8\u5230mid\uff0c\u5982\u679ca[mid]>=x\uff0c\u90a3\u4e48\u53ef\u4ee5\u5c06l\u79fb\u52a8\u5230mid\u3002\u4e00\u76f4\u5230\u533a\u95f4\u5927\u5c0f\u4e3a1\uff0c\u5c31\u662f\u90a3\u4e2a\u5143\u7d20\u3002
\u5176\u4e2dl\u7684\u521d\u59cb\u503c\u4e3a1.r\u7684\u521d\u59cb\u503c\u4e3an\u3002
\u4e0a\u9762\u53ea\u662f\u67e5\u627e\u65b9\u6cd5\uff0c\u4f46\u662f\u6570\u7ec4\u4e2d\u7684\u6dfb\u52a0\u5f88\u6162\u3002
\u6240\u4ee5\u53ef\u4ee5\u4f7f\u7528\u4e00\u79cd\u795e\u5947\u7684\u6570\u636e\u7ed3\u6784\u53eb\u5e73\u8861\u6811\u6216\u8005\u4e8c\u53c9\u641c\u7d22\u6811\u3002[\u4f46\u662f\u4e00\u770b\u5c31\u4e0d\u662f\u8981\u95ee\u8fd9\u4e2a]\u3002
假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一躺快速排序的算法是：
1）、设置两个变量I、J，排序开始的时候I：=1，J：=N；
2）以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；
3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；
4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；
5）、重复第3、4步，直到I=J；
例如：待排序的数组A的值分别是：（初始关键数据X：=49）
A[1] A[2] A[3] A[4] A[5] A[6] A[7]：
49 38 65 97 76 13 27
进行第一次交换后： 27 38 65 97 76 13 49
( 按照算法的第三步从后面开始找
进行第二次交换后： 27 38 49 97 76 13 65
( 按照算法的第四步从前面开始找>X的值，65>49,两者交换，此时I：=3 )
进行第三次交换后： 27 38 13 97 76 49 65
( 按照算法的第五步将又一次执行算法的第三步从后开始找
进行第四次交换后： 27 38 13 49 76 97 65
( 按照算法的第四步从前面开始找大于X的值，97>49,两者交换，此时J：=4 )
此时再执行第三不的时候就发现I=J，从而结束一躺快速排序，那么经过一躺快速排序之后的结果是：27 38 13 49 76 97 65，即所以大于49的数全部在49的后面，所以小于49的数全部在49的前面。
快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示：
初始状态 {49 38 65 97 76 13 27}
进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65}
分别对前后两部分进行快速排序 {13} 27 {38}
结束 结束 {49 65} 76 {97}
49 {65} 结束
结束
图6 快速排序全过程
1）、设有N（假设N=10）个数，存放在S数组中；
2）、在S[1。。N]中任取一个元素作为比较基准，例如取T=S[1]，起目的就是在定出T应在排序结果中的位置K，这个K的位置在：S[1。。K-1]<=S[K]<=S[K+1..N]，即在S[K]以前的数都小于S[K]，在S[K]以后的数都大于S[K]；
3）、利用分治思想（即大化小的策略）可进一步对S[1。。K-1]和S[K+1。。N]两组数据再进行快速排序直到分组对象只有一个数据为止。
如具体数据如下，那么第一躺快速排序的过程是：
数组下标： 1 2 3 4 5 6 7 8 9 10
45 36 18 53 72 30 48 93 15 36
I J
（1） 36 36 18 53 72 30 48 93 15 45
（2） 36 36 18 45 72 30 48 93 15 53
（3） 36 36 18 15 72 30 48 93 45 53
（4） 36 36 18 15 45 30 48 93 72 53
（5） 36 36 18 15 30 45 48 93 72 53
通过一躺排序将45放到应该放的位置K，这里K=6，那么再对S[1。。5]和S[6。。10]分别进行快速排序。
一般来说，冒泡法是程序员最先接触的排序方法，它的优点是原理简单，编程实现容易，但它的缺点就是--程序的大忌--速度太慢。下面我介绍一个理解上简单但编程实现上不是太容易的排序方法，我不知道它是不是现有排序方法中最快的，但它是我见过的最快的。排序同样的数组，它所需的时间只有冒泡法的 4% 左右。我暂时称它为“快速排序法”。
“快速排序法”使用的是递归原理，下面我结合一个例子来说明“快速排序法”的原理。首先给出一个数组{53，12，98，63，18，72，80，46， 32，21}，先找到第一个数--53，把它作为中间值，也就是说，要把53放在一个位置，使得它左边的值比它小，右边的值比它大。{21，12，32， 46，18，53，80，72，63，98}，这样一个数组的排序就变成了两个小数组的排序--53左边的数组和53右边的数组，而这两个数组继续用同样的方式继续下去，一直到顺序完全正确。
我这样讲你们是不是很胡涂，不要紧，我下面给出实现的两个函数：
/*
n就是需要排序的数组，left和right是你需要排序的左界和右界，
如果要排序上面那个数组，那么left和right分别是0和9
*/
void quicksort(int n[], int left,int right)
{
int dp;
if (left<right) {
/*
这就是下面要讲到的函数，按照上面所说的，就是把所有小于53的数放
到它的左边，大的放在右边，然后返回53在整理过的数组中的位置。
*/
dp=partition(n,left,right);
quicksort(n,left,dp-1);
quicksort(n,dp+1,right); //这两个就是递归调用，分别整理53左边的数组和右边的数组
}
}
我们上面提到先定位第一个数，然后整理这个数组，把比这个数小的放到它的左边，大的放右边，然后
返回这中间值的位置，下面这函数就是做这个的。
int partition(int n[],int left,int right)
{
int lo,hi,pivot,t;
pivot=n[left];
lo=left-1;
hi=right+1;
while(lo+1!=hi) {
if(n[lo+1]<=pivot)
lo++;
else if(n[hi-1]>pivot)
hi--;
else {
t=n[lo+1];
n[++lo]=n[hi-1];
n[--hi]=t;
}
}
n[left]=n[lo];
n[lo]=pivot;
return lo;
}
这段程序并不难，应该很好看懂，我把过程大致讲一下，首先你的脑子里先浮现一个数组和三个指针，第一个指针称为p指针，在整个过程结束之前它牢牢的指向第一个数，第二个指针和第三个指针分别为lo指针和hi指针，分别指向最左边的值和最右边的值。lo指针和hi指针从两边同时向中间逼近，在逼近的过程中不停的与p指针的值比较，如果lo指针的值比p指针的值小，lo++，还小还++，再小再++，直到碰到一个大于p指针的值，这时视线转移到hi指针，如果 hi指针的值比p指针的值大，hi--，还大还--，再大再--，直到碰到一个小于p指针的值。这时就把lo指针的值和hi指针的值做一个调换。持续这过程直到两个指针碰面，这时把p指针的值和碰面的值做一个调换，然后返回p指针新的位置。
假设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一躺快速排序的算法是：
1）、设置两个变量I、J，排序开始的时候I：=0，J：=N-1；
2）以第一个数组元素作为关键数据，赋值给X，即X：=A[0]；
3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；
4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；
5）、重复第3、4步，直到I=J；
我们看一下：
A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7]
7 4 2 9 8 5 11 3
1、i=0,j=7
2、X=7
3、从j=7向前找，A[7]<X,A[7]与A[0]交换，j=6
A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7]
3 4 2 9 8 5 11 7
4、从i=0向后找，A[3]>X，A[7]与A[3]交换，i=1
A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7]
3 4 2 7 8 5 11 9
5、从j=6向前找，A[5]<X，A[3]与A[5]交换，j=5
A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7]
3 4 2 5 8 7 11 9
6、从i=1向后找，A[4]>X ,A[4]与A[5]交换，i=2
A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7]
3 4 2 5 7 8 11 9
7、从j=5向前找，A[3]<X,A[3]与A[4]交换，j=4
A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7]
3 4 2 7 5 8 11 9
8、从i=2向后找，i=3，没有
A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7]
3 4 2 7 5 8 11 9
9、从j=4向前找，，j=3，没有
A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7]
3 4 2 7 5 8 11 9
10、此时i=j，结束第一趟交换。
看着算法自己理解，欢迎批评指正。
楼主也也可以自己从网上查一下这个算法，也有例题可以参考。
楼上那位把整个理论与实现都搬过来了...够壮观，我就针对这题给你讲一下吧，假设数组A表示为：
无 7 4 2 9 0 5 11 3 ......值
-1 0 1 2 3 4 5 6 7 ......索引号
i,j key ......初始时三个变量的初始位置，置于是指针还是啥，随意
经典快排思想如下
1：首先选取最后一个值作为键值，即将key变量指向A[7]；
2：初始化遍历用的变量i，j为-1，即数组开头的前面一位；其中i是当前所遍历的数值，j+1是当前遍历过的所有数值中序号最小的比key值大的数值的索引号
3：开始从0-6逐个遍历数组：
i=0：a[0] = 7，>a[key]，即发现第一个大于key值的值，j不变
i=1：a[1] = 4，>a[key]，发现第二个大于key的值，j不变
i=2：a[2] = 2，<a[key]，发现小于key值得值，将其与目前所知道的数值大于key中索引号最小的值交换位置，即a[j+1]=a[0]，然后将j重新指向索引最小的比key值大的数，j++即j=0；
序列第一次发生变化：2 4 7 9 0 5 11 3 然后继续遍历
i=3：a[3] = 9，>a[key]，j不变
i=4：a[4] = 0， <a[key]，同i=2时的操作之后
序列第二次发生变化：2 0 7 9 4 5 11 3 此时j++后j=1
i=5：a[5] = 5，不变
i=6：a[6] = 11，不变
i=key：遍历结束，将key值与当前比其大的数值中索引最小的值交换，即a[j+1]=a[2]
序列第三次发生变化：2 0 3 9 4 5 11 7
返回j+1，即2，完成第一次排序，所作的事情就是将比a[2]=3小的值全放到其左边，比其大的值全在右边，所以位于a[2]的值的序号就是最终序号
楼上那位是选的a[0]作为key，不过原理是一样的，你可以结合一起来看，他就是把所有比a[3]=7小的放其左边，其余右边
绛旓細绗竴棰橀塂锛氶『搴忓瓨鍌ㄧ粨鏋 棣栧厛璇存槑涓涓嬩粈涔堟槸鏁版嵁鐨勫瓨鍌ㄧ粨鏋勶紝瀹冩槸鎵鏁版嵁缁撴瀯鍦ㄨ绠楁満涓殑琛ㄧず锛堢墿鐞嗙粨鏋勶級锛屼富瑕佹湁鍥涚锛氶『搴忓瓨鍌ㄣ侀摼寮忓瓨鍌ㄣ佺储寮曞瓨鍌ㄥ拰鏁ｅ垪瀛樺偍銆傞『搴忓瓨鍌ㄧ殑鐗圭偣鏄細閫昏緫涓婄浉閭荤殑鍏冪礌瀛樺偍鍦ㄧ墿鐞嗕綅缃笂涔熺浉閭荤殑瀛樺偍鍗曞厓閲岋紝绗1棰橀噷闂滃彲鐢ㄥ瓨鍌ㄩ『搴忎唬琛ㄩ昏緫椤哄簭鐨勬暟鎹粨鏋勨濊嚜鐒舵槸D椤哄簭...
绛旓細鐢ㄩ掑綊锛歛=褰撳墠鑺傜偣鏄惁涓烘帓搴忔爲锛屾槸涓1锛屼笉鏄负0 f(x)=1 褰搙涓哄彾鑺傜偣 f(x)= a&&f(x->lchid)&&f(x-rchild) 褰搙闈炲彾鑺傜偣 --- int IsAVTree(BiTree t){ int a=1;if(t->Child==NULL&&t->Rchild==NULL) return 1; //鍙跺瓙鑺傜偣鍒ゆ柇 if((t->Lchild->data>t->data)||...
绛旓細蹇熸帓搴忓氨鏄掑綊璋冪敤姝よ繃绋嬧斺斿湪浠49涓轰腑鐐瑰垎鍓杩欎釜鏁版嵁搴忓垪锛屽垎鍒鍓嶉潰涓閮ㄥ垎鍜屽悗闈竴閮ㄥ垎杩涜绫讳技鐨勫揩閫熸帓搴忥紝浠庤屽畬鎴愬叏閮ㄦ暟鎹簭鍒楃殑蹇熸帓搴忥紝鏈鍚庢妸姝ゆ暟鎹簭鍒楀彉鎴愪竴涓湁搴忕殑搴忓垪锛屾牴鎹繖绉嶆濇兂瀵逛簬涓婅堪鏁扮粍A鐨勫揩閫熸帓搴忕殑鍏ㄨ繃绋嬪鍥6鎵绀猴細鍒濆鐘舵 {49 38 65 97 76 13 27}...
绛旓細1锛 绾挎缁撴瀯 鏍戠粨鏋 鍥剧粨鏋 2 锛氶『搴忓瓨鍌ㄧ粨鏋勶細鎶婇昏緫涓婄浉閭荤殑鑺傜偣瀛樺偍鍦ㄧ墿鐞嗕綅缃笂鐩搁偦鐨勫瓨鍌ㄥ崟鍏冧腑锛岀粨鐐逛箣闂寸殑閫昏緫鍏崇郴鐢卞瓨鍌ㄥ崟鍏冪殑閭绘帴鍏崇郴鏉ヤ綋鐜般傞摼寮忓瓨鍌ㄧ粨鏋勶細鍦ㄨ绠楁満涓敤涓缁勪换鎰忕殑瀛樺偍鍗曞厓瀛樺偍绾挎ц〃鐨鏁版嵁鍏冪礌(杩欑粍瀛樺偍鍗曞厓鍙互鏄繛缁殑,涔熷彲浠ユ槸涓嶈繛缁殑).姣忎釜缁撶偣鏄敱鏁版嵁鍩熷拰鎸囬拡鍩熺粍鎴...
绛旓細浜屽弶鏍戠殑鍓嶅簭搴忓垪鏄爲鏍瑰湪鍓嶉潰锛屼腑搴忓簭鍒楅噷闈㈡爲鏍瑰湪涓棿銆傞昏緫鏄噸澶嶇殑鎸夌収锛屽厛閫氳繃鍓嶅簭纭畾鏍戞牴锛屽啀閫氳繃涓簭纭畾宸﹀彸瀛愭爲銆傚墠搴 ABDGCEF 涓 DGBAECF銆 鍙互鐪嬪嚭 鏍戞牴鏄紝A銆傛帹鍑哄乏鏍戠殑鍓嶅簭BDG 涓簭 DGB锛涘彸鏍戠殑鍓嶅簭鏄疌EF 涓簭鏄疎CF锛涙帴鐫鍒嗗埆鎵惧嚭宸︽爲鐨勬爲鏍瑰拰宸﹀彸瀛愭爲锛屽彸鏍戠殑鏍戞牴鍜屽乏鍙...
绛旓細涓荤▼搴忓啓涓涓惊鐜紝寰幆瀹炵幇鐨勬槸鍔熻兘閫夋嫨锛岀敤switch case璇彞瀹炵幇 鎻掑叆鍑芥暟閲岄潰鍐欎竴涓惊鐜紝寰幆閲岄潰鍔ㄦ佸垎閰嶏紝鎺ュ彈鐢ㄦ埛杈撳叆鍚庯紝灏嗚妭鐐规彃鍏ュ埌閾捐〃涓 鏌ユ壘鍜屽垹闄よ仈绯讳汉灏辨槸閬嶅巻閾捐〃 鏇存柊鍔熻兘闇瑕佺敤鎴疯緭鍏ュ緟鏇存柊浜虹殑鍚嶅瓧锛岀劧鍚庨亶鍘嗛摼琛紝鎵惧埌鍚庢帴鍙楃敤鎴疯緭鍏ワ紝瑕嗙洊鍘熸湁淇℃伅鍗冲彲銆傛湁闂鐨勮瘽鍐嶉棶鎴戙
绛旓細鐢ㄤ竴涓缁撴瀯浣撴妸濮撳悕鍜屾垚缁╂斁鍦ㄤ竴璧凤紝鐒跺悗瀵规垚缁╁叧閿瓧鎺掑簭灏卞彲浠ヤ簡锛岃緭鍑虹洿鏂瑰浘涓嶆竻妤氫綘鐨勫叿浣撹姹傦紝鏄笉鏄粺璁″悇鍒嗘暟娈典汉鏁帮紵灏卞缓涓暟缁勬瘡涓厓绱犲搴斾竴涓垎鏁版锛岀劧鍚庡鏁版嵁妫绱竴閬嶏紝姣忎釜瀛︾敓鎴愮哗鍦ㄥ摢涓垎鏁版鍝釜鍒嗘暟娈靛搴旂殑鍏冪礌+1
绛旓細杩欓噷for寰幆寰幆浜嗕笁娆★紝寰幆绗竴娆★紝灏嗙3涓厓绱犵殑鍊兼浛鎹负绗5涓厓绱犵殑鍊硷紝寰幆绗簩娆″氨鏄皢绗4涓厓绱犵殑鍊兼浛鎹负绗6涓厓绱犵殑鍊笺傚惊鐜涓夋锛屽皢绗5涓厓绱犵殑鍊兼浛鎹负绗7涓厓绱犵殑鍊笺俧or寰幆鍚庨潰涓鏉¤鍙ョ殑鎰忔濇槸a鍒楄〃鐨勯暱搴﹀噺2銆傜粨璁猴細杩欎釜閫昏緫鏄湁闂鐨勶紝鐨勭‘鏄湁浣犳墍璇寸殑绌洪殭瀛樺湪銆傛纭殑...
绛旓細浣犲ソ 锛歲->next = p->next;//灏 q鑺傜偣鎸囧悜p鑺傜偣鍚庨潰鍏冪礌 p->next=q;// 灏唒鑺傜偣鎸囧悜鑺傜偣鏀逛负q銆傝繖鏍风粨鏋滃氨鏄痯-銆媞鈥斻媝鍘熸湰鎸囧悜鐨勪笅涓涓妭鐐癸紝灏辨妸q鎻掑叆鍒皃鑺傜偣涔嬪悗浜嗐傚笇鏈涘浣犳湁鎵甯姪锛屽鏋滄湁閿欒娆㈣繋鎸囧嚭銆
绛旓細鍩烘湰涓婃槸瀵圭殑锛屼絾i涓嶈兘绛変簬s->last+2锛屾墍浠ュ紑濮嬬殑if鏉′欢瑕佹敼涓嬶細 int insert_seqlist(seqlist *s, int i, int x){ int k; if(s->last>=MAX-1 || is->last+1) return 0; for(k=s->last+1; k>=i; k--) s->data[k]=s->data[k-1]; s->data[k]=x; s->last +=...
