数据结构--各种排序的实现(排序小结 希尔排序 快排 堆排序 归并排序)

 

对各种排序算法的实现

1.冒泡排序:

 1 #include "stdio.h"

 2 #define N 100005

 3 

 4 void Swap(int *x,int *y){ int k=*x; *x=*y; *y=k; }

 5 

 6 void Bubble_sort(int st,int en,int *a)  //冒泡排序

 7 {

 8     int i,j;

 9     for(i=en; i>st; i--)

10     {

11         for(j=st; j<i; j++)  //每次j循环结束,保证a[i]是a[st]~a[i]中最小的

12             if(a[j]>a[j+1]) Swap(&a[j],&a[j+1]);

13     }

14 }

15 

16 int main()

17 {

18     int n;

19     int a[N];

20     scanf("%d",&n);

21     for(int i=0; i<n; i++)  scanf("%d",&a[i]);

22     Bubble_sort(0,n-1,a);

23     for(int i=0; i<n; i++)  printf("%d ",a[i]);

24     printf("\n");

25 }
Bubble_sort

2.快速排序:

 1 #include "stdio.h"

 2 #define N 100005

 3 

 4 void T_sort(int st,int en,int *a)  //快速排序

 5 {

 6     if(st>=en) return ;

 7     int l=st,r=en;

 8     int temp = a[st];  //以子表的首记录作为支点记录,放入temp变量

 9     while(l<r)

10     {

11         while(l<r && a[r]>=temp)

12             --r;

13         if(l<r)

14             a[l++] = a[r];  //将比支点小的记录交换到低端

15         while(l<r && a[l]<=temp)

16             ++l;

17         if(l<r)

18             a[r--] = a[l];  //将比支点大的记录交换到高端

19     }

20     a[l] = temp;

21     T_sort(st,l-1,a);  //递归排序

22     T_sort(l+1,en,a);  //递归排序

23 }

24 

25 int main()

26 {

27     int n;

28     int a[N];

29     scanf("%d",&n);

30     for(int i=0; i<n; i++)  scanf("%d",&a[i]);

31     T_sort(0,n-1,a);

32     for(int i=0; i<n; i++)  printf("%d ",a[i]);

33     printf("\n");

34 }
T_sort

3.希尔排序:

 1 #include "stdio.h"

 2 #define N 100005

 3 

 4 void Shell_sort_in_k(int *a,int n,int dk)

 5 {

 6     int i,j,k;

 7     for(i=1; i<=dk; ++i)

 8     {

 9         for(j=i+dk; j<=n; j+=dk)

10         {

11             a[0] = a[j];

12             for(k=j-dk; k>0&&a[0]<a[k]; k-=dk)

13                 a[k+dk] = a[k];

14             a[k+dk] = a[0];

15         }

16     }

17 }

18 

19 void Shell_sort(int *a,int n)

20 {

21     int k = n/2;

22     while(k)

23     {

24         Shell_sort_in_k(a,n,k); //按增量k对顺序表进行希尔排序~

25         k = k/2;  //k每次变为原来的一半

26     }

27 }

28 

29 int main()

30 {

31     int n;

32     int a[N];

33     scanf("%d",&n);

34     for(int i=1; i<=n; i++)  scanf("%d",&a[i]); //堆排序要从下标1开始存起

35     Shell_sort(a,n);

36     for(int i=1; i<=n; i++)  printf("%d ",a[i]);

37     printf("\n");

38 }
Shell_sort

4.堆排序:

 1 #include "stdio.h"

 2 #define N 100005

 3 

 4 void Swap(int *x,int *y) { int k=*x; *x=*y; *y=k; }

 5 

 6 void Heap_sort_k(int *a,int st,int en)  //将a[st]~a[en]建成大根堆

 7 {

 8     int j;

 9     int temp = a[st];

10     for(j=2*st; j<=en; j*=2)

11     {

12         if(j<en && a[j]<a[j+1]) j++;

13         if(temp >= a[j]) break;

14         a[st] = a[j];

15         st = j;

16     }

17     a[st] = temp; //将temp插入到s位置上

18 }

19 

20 void Heap_sort(int *a,int n)

21 {

22     for(int i=n/2; i>0; i--)

23         Heap_sort_k(a,i,n); //将a[1]~a[n]建成大根堆

24     for(int i=n; i>1; i--)

25     {

26         Swap(&a[1],&a[i]);  //将堆顶记录与当前未排序的子序列a[]中最后一个记录相互交换

27         Heap_sort_k(a,1,i-1); //将a[1..i-1]重新调整为大根堆

28     }

29 }

30 

31 int main()

32 {

33     int n;

34     int a[N];

35     scanf("%d",&n);

36     for(int i=1; i<=n; i++)  scanf("%d",&a[i]); //堆排序要从下标1开始存起

37     Heap_sort(a,n);

38     for(int i=1; i<=n; i++)  printf("%d ",a[i]);

39     printf("\n");

40 }
Heap_sort

5.归并排序:

 1 #include "stdio.h"

 2 #define N 100005

 3 int c[N]; //辅助空间

 4 

 5 void Merge(int *a,int st,int mid,int en)

 6 {

 7     int i=st,j=mid+1,k=0;

 8     while(i<=mid && j<=en)  //将两段区间由小到大并入c[];

 9     {

10         if(a[i]<=a[j])

11             c[k++]=a[i++];

12         else

13             c[k++]=a[j++];

14     }

15     if(i<=mid)  //将剩余的a[i..mid]复制到c[];

16         while(i<=mid) c[k++]=a[i++];

17     if(j<=en)  //将剩余的a[j..en]复制到c[];

18         while(j<=en)  c[k++]=a[j++];

19     for(i=st; i<=en; i++)

20         a[i]=c[i-st];

21 }

22 

23 void Merge_sort(int *a,int st,int en)  //归并排序

24 {

25     if(st==en) return ;

26     int mid = (st+en)/2;

27     Merge_sort(a,st,mid);    //递归的对a[st~mid]进行归并排序

28     Merge_sort(a,mid+1,en);  //递归的对a[mid+1~en]进行归并排序

29     Merge(a,st,mid,en); //两子数组归并为有序

30 }

31 

32 int main()

33 {

34     int n;

35     int a[N];

36     scanf("%d",&n);

37     for(int i=0; i<n; i++)  scanf("%d",&a[i]);

38     Merge_sort(a,0,n-1);

39     for(int i=0; i<n; i++)  printf("%d ",a[i]);

40     printf("\n");

41 }
Merge_sort

6.基数排序:

排序合集:

  1 #include "stdio.h"

  2 #include "string.h"

  3 

  4 #define N 10005

  5 

  6 void Swap(int *x,int *y)  //交换

  7 {

  8     int t;

  9     t = *x;

 10     *x = *y;

 11     *y = t;

 12 }

 13 

 14 void Shell_sort_in_k(int *a,int n,int dk) //对顺序表a进行一趟增量为dk的Shell排序,dk为步长因子

 15 {

 16     int i,j,k;

 17     for(i=1; i<=dk; ++i)  //当前有dk个子序列,共插入排序dk次

 18     {

 19         for(j=i+dk; j<=n; j+=dk)  //对每一个子序列进行插入排序

 20         {

 21             a[0] = a[j];  //当前要插入的元素为a[j];

 22             for(k=j-dk; k>0&&a[0]<a[k]; k-=dk)

 23                 a[k+dk] = a[k];

 24             a[k+dk] = a[0];

 25         }

 26     }

 27 }

 28 

 29 void Shell_sort(int *a,int n)

 30 {

 31     int k=n/2;

 32     while(k)

 33     {

 34         Shell_sort_in_k(a,n,k);  //按增量k对顺序表进行希尔排序~

 35         k = k/2;  //k每次变为原来的一半

 36     }

 37 }

 38 

 39 void T_sort(int l,int r,int *a) //快速排序

 40 {

 41     int temp=a[l];   //以子表的首记录作为支点记录,放入temp变量

 42     if(l>=r) return ;

 43     int start = l;

 44     int end = r;

 45     while(l<r)  //从表的两端交替地向中间扫描

 46     {

 47         while(l<r && a[r]>=temp)

 48             --r;

 49         if(l<r)

 50             a[l++] = a[r];   //将比支点小的记录交换到低端

 51         while(l<r && a[l]<=temp)

 52             ++l;

 53         if(l<r)

 54             a[r--] = a[l];   //将比支点大的记录交换到高端

 55     }

 56     a[l] = temp;

 57     T_sort(start,l-1,a);  //递归排序

 58     T_sort(l+1,end,a);    //递归排序

 59 }

 60 

 61 void Heap_sort_k(int *a,int start,int end)

 62 {

 63     int j;

 64     int temp = a[start];  //temp暂存待插入的记录

 65     for(j=2*start; j<=end; j*=2)  //沿a[j],a[j+1]中较大的孩子结点向下筛选

 66     {

 67         if(j<end && a[j] < a[j+1])

 68             j++;

 69         if(temp >= a[j]) break;

 70         a[start] = a[j];

 71         start = j;

 72     }

 73     a[start] = temp;  //将temp插入到s位置上

 74 }

 75 

 76 void Heap_sort(int *a,int n)  //堆排序

 77 {

 78     int i;

 79     for(i=n/2; i>0; i--)

 80         Heap_sort_k(a,i,n);  //将a[1]~a[n]建成大根堆

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

 82     {

 83         Swap(&a[1],&a[i]);   //将堆顶记录与当前未排序的子序列a[]中最后一个记录相互交换

 84         Heap_sort_k(a,1,i-1);  //将a[1..i-1]重新调整为大根堆

 85     }

 86 }

 87 

 88 int c[N];  // 辅助空间

 89 

 90 void Merge(int *a,int start,int mid,int end)  //将a[start~mid]与a[mid+1~end]合并;

 91 {

 92     int m,n;

 93     int i,j,k;

 94     i = start; m = mid;

 95     j = mid+1; n = end;

 96     k = 0;

 97     for( ; i<=m && j<=n; ++k)  //将两段区间由小到大并入c[];

 98     {

 99         if(a[i]<a[j]) c[k] = a[i++];

100         else

101             c[k] = a[j++];

102     }

103     if(i<=m)  ////将剩余的a[i..m]复制到c[];

104     {

105         for( ; i<=m; ++i)

106             c[k++] = a[i];

107     }

108     if(j<=n)  ////将剩余的a[j..n]复制到c[];

109     {

110         for( ; j<=n; ++j)

111             c[k++] = a[j];

112     }

113     for(i=start; i<=end; ++i)

114         a[i] = c[i-start];

115 }

116 

117 void M_sort(int *a,int start,int end)  //归并排序

118 {

119     if(start==end) return ;

120     int mid = (start+end)/2;

121     M_sort(a,start,mid);  //递归的对a[start~mid]进行归并排序

122     M_sort(a,mid+1,end);  //递归的对a[mid+1~end]进行归并排序

123     Merge(a,start,mid,end);

124 }

125 

126 int In_put(int *a);  //初始化顺序表

127 void Out_put(int *a,int n);  //输出顺序表

128 

129 int main()

130 {

131     int n;

132     int a[N];

133 //

134     printf("\n\t/******************下面进行希尔排序:************************/\n");

135     n = In_put(a);

136     Shell_sort(a,n);  //希尔排序

137     printf("希尔排序的结果如下:\n");

138     Out_put(a,n);

139 //

140     printf("\n\t/******************下面进行快速排序:************************/\n");

141     n = In_put(a);

142     T_sort(1,n,a);

143     printf("快速排序的结果如下:\n");

144     Out_put(a,n);

145 //

146     printf("\n\t/*******************下面进行堆排序:*************************/\n");

147     n = In_put(a);

148     Heap_sort(a,n);

149     printf("堆排序的结果如下:\n");

150     Out_put(a,n);

151 //

152     printf("\n\t/******************下面进行归并排序:************************/\n");

153     n = In_put(a);

154     M_sort(a,1,n);

155     printf("归并排序的结果如下:\n");

156     Out_put(a,n);

157 //

158     //printf("\n\t/******************下面进行基数排序:************************/\n");

159     //n = In_put(a);

160     //Radix_sort(a,1,n);

161     //printf("基数排序的结果如下:\n");

162     //Out_put(a,n);

163 //

164     return 0;

165 }

166 

167 int In_put(int *a)

168 {

169     int i,n;

170     memset(a,0,sizeof(a));

171     printf("请输入顺序表的元素个数n:\n");

172     scanf("%d",&n);

173     printf("接下来输入顺序表:\n");

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

175         scanf("%d",&a[i]);

176     return n;

177 }

178 

179 void Out_put(int *a,int n)   //输出排序后的顺序表

180 {

181     int i;

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

183         printf("%d ",a[i]);

184     printf("\n");

185 }
View Code

你可能感兴趣的:(数据结构)