各种排序算法全集

 001#include<stdio.h>

002#include<stdlib.h>

003struct node

004{

005    int key;

006}r[20];

007  

008struct rnode

009{

010    int key;

011    int point;

012};

013  

014main()

015{

016    void print(struct node a[20],int n);

017    int creat();

018    void shell(struct node a[20],int n);

019    int hoare(struct node a[20],int l,int h);

020    void quick1(struct node a[20],int n);

021    void quick2(struct node a[20],int l,int h);

022    void heap(struct node a[20],int i,int m);

023    void heapsort(struct node a[20],int n);

024    void merges(struct node a[20],struct node a2[20],int h1,int mid,int h2);

025    void mergepass(struct node a[20],struct node a2[20],int l,int n);

026    void mergesort(struct node a[20],int n);

027    int yx(int m,int i);

028    int radixsort(struct rnode a[20],int n);

029    int num,l,h,c;

030    struct rnode s[20];

031    c=1;

032    while(c!=0)

033    {

034        printf("        主菜单                       \n");

035        printf("   1    输入关键字，以-9999表示结束。\n");

036        printf("   2    希尔排序                     \n");

037        printf("   3    非递归的快速排序             \n");

038        printf("   4    递归的快速排序               \n");

039        printf("   5    堆排序                       \n");

040        printf("   6    归并排序                     \n");

041        printf("   7    基数排序                     \n");

042        printf(" 输入选择    (1--7,0表示结束):         ");

043        scanf("%d",&c);

044        switch(c)

045        {

046        case 1:num=creat();print(r,num);break;

047        case 2:shell(r,num);print(r,num);break;

048        case 3:quick1(r,num);print(r,num);break;

049        case 4:l=0;h=num-1;quick2(r,l,h);

050            printf("output quick2sort result:\n");

051            print(r,num);break;

052        case 5:heapsort(r,num);break;

053        case 6:mergesort(r,num);print(r,num);break;

054        case 7:radixsort(s,num);

055        }

056    }

057}//main end

058  

059void print(struct node a[20],int n)

060{

061    int i;

062    for(i=0;i<n;i++)

063        printf("%5d",a[i ].key);

064    printf("\n");

065}//print end

066  

067int creat()

068{

069    int i,n;

070    n=0;

071    printf("input keys");

072    scanf("%d",&i);

073    while(i!=-9999)

074    {

075        r[n].key=i;

076        n++;

077        scanf("%d",&i);

078    }

079    return(n);

080}//creat end

081  

082void shell(struct node a[20],int n)//希尔排序

083{

084    int i,j,k;

085    for(i=n;i>=1;i--)

086        a[i].key=a[i-1].key;

087    k=n/2;

088    while(k>=1)

089    {

090        for(i=k+1;i<=n;i++)

091        {

092            a[0].key=a[i].key;

093            j=i-k;

094            while((a[j].key>a[0].key)&&(j>=0))

095            {

096                a[j+k].key=a[j].key;

097                j=j-k;

098            }

099            a[j+k]=a[0];

100        }

101        k=k/2;

102    }

103    for(i=0;i<n;i++)

104        a[i].key=a[i+1].key;

105    printf("输出希尔排序的结果:\n");

106}//shell end

107  

108////////////////////快速排序///////////////////////////

109  

110int hoare(struct node a[20],int l,int h)//分区处理函数

111{

112    int i,j;

113    struct node x;

114    i=l;

115    j=h;

116    x.key=a[i].key;

117    do

118    {

119        while((i<j)&&(a[j].key>=x.key))

120            j--;

121        if(i<j)

122        {

123            a[i].key=a[j].key;

124            i++;

125        }

126        while((i<j)&&(a[i].key<=x.key))

127            i++;

128        if(i<j)

129        {

130            a[j].key=a[i].key;

131            j--;

132        }

133    }while(i<j);

134    a[i].key=x.key;

135    return(i);

136}//hoare end

137  

138void quick1(struct node a[20],int n)

139{

140    int i,l,h,tag,top;

141    int s[20][2];

142    l=0;h=n-1;tag=1;top=0;

143    do

144    {

145        while(l<h)

146        {

147            i=hoare(a,l,h);

148            top++;

149            s[top][0]=i+1;

150            s[top][1]=h;

151            h=h-1;

152        }

153        if(top==0)

154            tag=0;

155        else

156        {

157            l=s[top][0];

158            h=s[top][1];

159            top--;

160        }

161    }while(tag==1);

162    printf("输出非递归快速排序结果:\n");

163}//quick end

164  

165void quick2(struct node a[20],int l,int h)//递归的快速排序

166{

167    int i;

168    if(l<h)

169    {

170        i=hoare(a,l,h);

171        quick2(a,l,i-1);

172        quick2(a,i+1,h);

173    }

174}//quick2 end

175  

176////////////////////快速排序结束////////////////////////

177  

178////////////////////堆排序函数//////////////////////////

179  

180void heap(struct node a[20],int i,int m)//调整堆的函数

181{

182    struct node x;

183    int j;

184    x.key=a[i].key;

185    j=2*i;

186    while(j<=m)

187    {

188        if(j<m)

189            if(a[j].key>a[j+1].key)

190                j++;

191        if(a[j].key<x.key)

192        {

193            a[i].key=a[j].key;

194            i=j;

195            j=2*i;

196        }

197        else

198            j=m+1;

199    }

200    a[i].key=x.key;

201}//heap end

202  

203void heapsort(struct node a[20],int n)//堆排序的主体函数

204{

205    int i,v;

206    struct node x;

207    for(i=n;i>0;i--)

208        a[i].key=a[i-1].key;

209    for(i=n/2;i>=1;i--)

210        heap(a,i,n);

211    printf("输出堆排序结果:\n");

212    for(v=n;v>=2;v--)

213    {

214        printf("%5d",a[1].key);

215        x.key=a[1].key;

216        a[1].key=a[v].key;

217        a[v].key=x.key;

218        heap(a,1,v-1);

219    }

220    printf("%5d",a[1].key);

221    for(i=0;i<n;i++)

222        a[i].key=a[i+1].key;

223}//heapsort end

224  

225/////////////////堆排序函数结束///////////////////

226  

227//////////////////归并函数////////////////////////

228  

229void merges(struct node a[20],struct node a2[20],int h1,int mid,int h2)

230//归并排序的核心算法

231{

232    int i,j,k;

233    i=h1;j=mid+1;k=h1-1;

234    while((i<=mid)&&(j<=h2))

235    {

236        k=k+1;

237        if(a[i].key<=a[j].key)

238        {

239            a2[k].key=a[i].key;

240            i++;

241        }

242        else

243        {

244            a2[k].key=a[j].key;

245            j++;

246        }

247    }

248    while(i<=mid)

249    {

250        k++;

251        a2[k].key=a[i].key;

252        i++;

253    }

254    while(j<=h2)

255    {

256        k++;

257        a2[k].key=a[j].key;

258        i++;

259    }

260}//merges end

261  

262void mergepass(struct node a[20],struct node a2[20],int l,int n)

263//一趟归并

264{

265    int j,i,h1,mid,h2;

266    i=0;

267    while((n-i)>=2*l)

268    {

269        h1=i;

270        mid=h1+l-1;

271        h2=i+2*l-1;

272        merges(a,a2,h1,mid,h2);

273        i=i+2*l;

274    }

275    if((n-i)<=l)

276        for(j=i;j<=n;j++)

277            a2[j].key=a[j].key;

278    else

279    {

280        h1=i;

281        mid=h1+l-1;

282        h2=n-1;

283        merges(a,a2,h1,mid,h2);

284    }

285}//mergepass end

286  

287void mergesort(struct node a[20],int n)

288{

289    int l;

290    struct node a2[20];

291    l=1;

292    while(l<n)

293    {

294        mergepass(a,a2,l,n);

295        l=2*l;

296        mergepass(a2,a,l,n);

297        l=2*l;

298    }

299    printf("输出归并排序的结果:\n");

300}//mergesort end

301  

302///////////////归并函数结束///////////////

303  

304///////////////基数排序///////////////////

305  

306int yx(int m,int i)//分离关键字倒数第i位有效数字的算法

307{

308    int x;

309    switch(i)

310    {

311    case 1:x=m%10;break;

312    case 2:x=(m%100)/10;break;

313    case 3:x=(m%1000)/100;break;

314    case 4:x=(m%10000)/1000;break;

315    }

316    return(x);

317}//yx end

318  

319int radixsort(struct rnode a[20],int n)

320{

321    int f[11],e[11],i,j,k,l,p,d,t;

322    for(i=1;i<=n;i++)

323    {

324        a[i].key=r[i-1].key;

325        a[i].point=i+1;

326    }

327    a[n].point=0;

328    p=1;

329    printf("输出关键字有效位数 d\n");

330    scanf("%d",&d);

331    printf("输出基数排序的结果:\n");

332    for(i=1;i<=d;i++)

333    {

334        for(j=0;j<=10;j++)

335        {

336            f[j]=0;

337            e[j]=0;

338        }

339        while(p!=0)

340        {

341            k=yx(a[p].key,i);

342            if(f[k]==0)

343            {

344                f[k]=p;

345                e[k]=p;

346            }

347            else

348            {

349                l=e[k];

350                a[l].point=p;

351                e[k]=p;

352            }

353            p=a[p].point;

354        }

355        j=0;

356        while(f[j]==0)

357            j++;

358        p=f[j];t=e[j];

359        while(j<10)

360        {

361            j++;

362            while((j<10)&&(f[j]==0))

363                j++;

364            if(f[j]!=0)

365            {

366                a[t].point=f[j];

367                t=e[j];

368            }

369        }

370        a[t].point=0;

371        t=p;

372        while(t!=0)

373        {

374            printf("%5d",a[t].key);

375            t=a[t].point;

376        }

377        printf("\n");

378    }

379    return(p);

380}