C语言数据结构各种排序算法(选择,直接,希尔,起泡等排序)

#include <stdio.h>

#include<stdlib.h>

#include <time.h>

#define MAX 20         /*线性表中最多元素个数*/

typedef int KeyType;

typedef char InfoType[10];

typedef struct

{

KeyType key;

InfoType data;

}RecType;

void InsertSort(RecType R[],int n)

{

int i,j,k;

RecType temp;

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

{

temp=R[i];

j=i-1;

while(j>=0 && temp.key<R[j].key)

{

R[j+1]=R[j];

j--;

}

R[j+1]=temp;

printf("   i=%d   ",i);

for(k=0;k<n;k++)

printf("%3d",R[k].key);

printf("\n");

}

}

void ShellSort(RecType R[],int n)

{

int i,j,d,k;

RecType temp;

d=n/2;

while(d>0)

{

for(i=d;i<n;i++)

{

j=i-d;

while(j>0 && R[j].key>R[j+d].key)

{

temp=R[j];

R[j]=R[j+d];

R[j+d]=temp;

j=j-d;

}

}

printf("   d=%d:   ",d);

for(k=0;k<n;k++)

printf("%3d",R[k].key);

printf("\n");

d=d/2;

}

}

void BubbleSort(RecType R[],int n)

{

int i,j,k;

RecType temp;

for(i=0;i<n-1;i++)

{

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

if(R[j].key<R[j-1].key)

{

temp=R[j];

R[j]=R[j-1];

R[j-1]=temp;

}

printf("   i=%d   ",i);

for(k=0;k<n;k++)

printf("%3d",R[k].key);

printf("\n");

}

}

void QuickSort(RecType R[],int s,int t,int n)

{

int i=s,j=t,k;

RecType temp;

if(s<t)

{

temp=R[s];

while(i!=j)

{

while(j>i && R[j].key>temp.key)

j--;

if(i<j)

{

R[i]=R[j];

i++;

}

while(i<j && R[i].key<temp.key)

i++;

if(i<j)

{

R[j]=R[i];

j--;

}

}

R[i]=temp;

printf("      ");

for(k=0;k<n;k++)

if(k==i)

printf(" [%d]",R[k].key);

else

printf("%4d",R[k].key);

printf("\n");

QuickSort(R,s,i-1,n);

QuickSort(R,i+1,t,n);

}

}

void SelectSort(RecType R[],int n)

{

int i,j,k,l;

RecType temp;

for(i=0;i<n-1;i++)

{

k=i;

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

if(R[j].key<R[k].key)

k=j;

if(k!=i)

{

temp=R[i];

R[i]=R[k];

R[k]=temp;

}

printf("    i=%d   ",i);

for(l=0;l<n;l++)

printf("%3d",R[l].key);

printf("\n");

}

}

void DispHeap(RecType R[],int i,int n)    /*以括号表示法输出建立的堆*/

{

if(i<=n)

printf("%d",R[i].key);

if(2*i<=n)

{

printf("(");

DispHeap(R,2*i,n);

printf(",");

if(2*i+1<=n)

DispHeap(R,2*i+1,n);

printf(")");

}

}

void Sift(RecType R[],int low,int high)         /*调整堆*/

{

int i=low,j=2*i;

RecType temp=R[i];

while(j<=high)

{

if(j<high && R[j].key<R[j+1].key)

j++;

if(temp.key<R[j].key)

{

R[i]=R[j];

i=j;

j=2*i;

}

else

break;

}

R[i]=temp;

}

void HeapSort(RecType R[],int n)        /*对R[1]到R[n]元素实现堆排序*/

{

int i;

RecType temp;

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

Sift(R,i,n);

printf("初始堆:");

DispHeap(R,1,n);

printf("\n");

for(i=n;i>=2;i--)

{

printf("交换%d与%d,输出%d\n",R[i].key,R[1].key,R[1].key);

temp=R[1];

R[1]=R[i];

R[i]=temp;

Sift(R,1,i-1);

printf("筛选调整得到堆:");

DispHeap(R,1,i-1);

printf("\n");

}

}

void PrintArray(RecType R[],int n)

{

int i;

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

printf("%3d",R[i].key);

printf("\n");

}

void main()

{

int i,n=10,cord;

RecType R[MAX],S[MAX];

srand(time(0));              /*用系统时间作为随机数种子*/

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

S[i].key=100*rand()/RAND_MAX;     /*利用随机函数产生10个100以内的随机整数*/

do

{

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

printf("1-直接插入排序\n");

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

printf("3-冒泡排序\n");

printf("4-快速排序\n");

printf("5-简单选择排序\n");

printf("6-堆排序\n");

printf("7-退出\n");

printf("请输入你的选择:");

scanf("%d",&cord);

switch(cord)

{

case 1:

printf("初始关键字:");

PrintArray(S,n);

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

R[i].key=S[i].key;

InsertSort(R,n);

printf("最后结果 :");

PrintArray(R,n);

break;

case 2:

printf("初始关键字:");

PrintArray(S,n);

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

R[i].key=S[i].key;

ShellSort(R,n);

printf("最后结果 :");

PrintArray(R,n);

break;

case 3:

printf("初始关键字:");

PrintArray(S,n);

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

R[i].key=S[i].key;

BubbleSort(R,n);

printf("最后结果 :");

PrintArray(R,n);

break;

case 4:

printf("初始关键字:");

PrintArray(S,n);

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

R[i].key=S[i].key;

QuickSort(R,0,n-1,n);

printf("最后结果 :");

PrintArray(R,n);

break;

case 5:

printf("初始关键字:");

PrintArray(S,n);

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

R[i].key=S[i].key;

SelectSort(R,n);

printf("最后结果 :");

PrintArray(R,n);

break;

case 6:

printf("初始关键字:");

PrintArray(S,n);

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

R[i].key=S[i-1].key;

HeapSort(R,n);

printf("最后结果 :");

PrintArray(R,n);

break;

case 7:

exit(0);

default:

printf("选择错误,请重新输入!\n");

}

}while(1);

}

时间: 2024-10-03 13:29:59

C语言数据结构各种排序算法(选择,直接,希尔,起泡等排序)的相关文章

经典排序算法 - 选择排序Selection sort

经典排序算法 - 选择排序Selection sort 顾名思意,就是直接从待排序数组里选择一个最小(或最大)的数字,每次都拿一个最小数字出来, 顺序放入新数组,直到全部拿完 再简单点,对着一群数组说,你们谁最小出列,站到最后边 然后继续对剩余的无序数组说,你们谁最小出列,站到最后边 再继续刚才的操作,一直到最后一个,继续站到最后边,现在数组有序了,从小到大 举例 先说看每步的状态变化,后边介绍细节,现有无序数组[6 2 4 1 5 9] 第一趟找到最小数1,放到最前边(与首位数字交换) 交换前

白话排序算法--选择排序

前言: 继续排序方法,紧接早上的插入排序,紧跟其后,现在跟新上选择排序算法 选择排序:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾.以此类推,直到所有元素均排序完毕. 情景描述: 新学期换了新体育老师,面对同样的排队情景,他说道:“我不管之前是怎么教的,之后都按照我的来做,大家自己进行选择排序”. 从第一位同学开始,和第二位同学比较,谁矮了,谁就记着目前自己是最矮的(可以站前面,嘿嘿), 然后再和第三位

排序(选择、希尔、二分插入)

选择排序法                                                                                    第1趟,在待排序记录r[1]~r[n]中选出最小的记录,将它与r[1]交换:第2趟,在待排序记录r[2]~r[n]中选出最小的记录,将它与r[2]交换:以此类推,第i趟在待排序记录r[i]~r[n]中选出最小的记录,将它与r[i]交换,使有序序列不断增长直到全部排序完毕. 初始序列:{ 49 27 65 97 76 12

【排序算法】用C++实现各种排序算法

1. 在平时的学习中,很经常听到各种排序算法,各自有其优缺点.尝试自己用C++实现各排序算法,作为对算法的基础学习. 常见的内部排序: 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序 [排序算法]用C++实现各种排序算法

排序算法——选择排序(js语言实现)

选择排序:顾名思义选择,选择排序属于O(N^2)的排序算法,意思就是选择数组中的最小的拿出来放在第一位,然后再剩下的数里面,选择最小的,排在第二位,以此类推. 例如:8  3  4  5  6  2  1  7 第一次:寻找数组中最小的数1,然后和8替换,得到 1 3 4 5 6 2 8 7 第二次:因为1的位置已经确定,所以只需要找剩下数组中最小的就行了,2和3互换得到1 2 4 5 6 3 8 7 第三次:1和2的位置已经确定,就看剩下的数中最小的数,3和4互换,结果是1 2 3 5 6 4

数据结构与算法 4:排序算法,选择/插入/冒泡/希尔/快速/归并

[本文谢绝转载,原文来自http://990487026.blog.51cto.com] 排序算法 平均复杂度 冒泡排序    O(n2) 选择排序     O(n2) 插入排序     O(n2) 希尔排序     O(n1.5) 快速排序    O(N*logN) 归并排序     O(N*logN) 堆排序     O(N*logN) 基数排序     O(d(n+r)) 选择排序: [email protected]://990487026.blog.51cto.com~/sort$ c

数据结构(四)常用排序算法-选择、插入、希尔

选择排序 实现思路: 1.将需排序的集合设为A,已经排好顺的集合为B(在未排序前B集合为空). 2.每次从A集合中查找出最大或者最小的元素后放入集合B中 3.同时将该元素从集合A中移除. 4.循环执行以上两步直到集合A为空,B集合中的元素就有序了. 缺点: 效率低,时间复杂度为 O(n*n),是一种只适合小数据集的原地排序算法.   示范代码 1  public class CommSort { 2      // 比较大小 3      @SuppressWarnings({ "rawtype

算法 排序算法--选择排序

选择排序是排序算法的一种,这里以从小到大排序为例进行讲解. 基本思想及举例说明 选择排序(从小到大)的基本思想是,首先,选出最小的数,放在第一个位置:然后,选出第二小的数,放在第二个位置:以此类推,直到所有的数从小到大排序. 在实现上,我们通常是先确定第i小的数所在的位置,然后,将其与第i个数进行交换. 下面,以对 3  2  4  1 进行选择排序说明排序过程,使用min_index 记录当前最小的数所在的位置. 第1轮 排序过程 (寻找第1小的数所在的位置)3  2  4  1(最初, mi

排序算法--选择排序

# 选择排序##本小节知识点:1. [了解]选择排序2. [掌握]选择排序的基本思想3. [了解]练习 --- ##1.选择排序- 选择排序(Selection sort)是一种简单直观的排序算法.它的工作原理如下.首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元 素,然后放到排序序列末尾.以此类推,直到所有元素均排序完毕. --- ##2.选择排序的基本思想- 第一趟排序在所有待排序的n个记录中选出关键字最小的记录,将它与数据表中的第一个记录交

经典排序算法——选择排序

对于一个int数组,请编写一个选择排序算法,对数组元素排序. 给定一个int数组A及数组的大小n,请返回排序后的数组. 测试样例: [1,2,3,5,2,3],6 [1,2,2,3,3,5] class SelectionSort { public: int* selectionSort(int* A, int n){ // write code here int k=0; for(int i=0;i<n;++i) { k=i; for(int j=i+1;j<n;++j)//找到最小元素 {