c语言实现各种排序,c语言实现各种排序算法
以下是我用c語言實現(xiàn)的各種排序算法#pragma?once;
#define?MAXSIZE?20000
typedef?int?KeyType;
typedef?char?Infomation;
typedef?int?LESSTNAN;
typedef?int?ShellData[];
static?const?char?info='0';
#ifndef?_SDTLIB_H
#define?_STDLIB_H
#include?
#include?
#endif
#ifndef?_DEBUG_H
#define?_DEBUG_H
#include?
#include?
#endif
#ifndef?_TYPE_H
#define?_TYPE_H
typedef?struct
{
KeyType?Key;
Infomation?Other;
}Type;
#endif
typedef?void(*Function)(Type);
#ifndef?_LIST_H
#define?_LIST_H
typedef?struct
{
Type?r[MAXSIZE?+?1];
int?Length;
}List;
#endif
#pragma?once;
#include?"stdafx.h"
void?InitList(List?&L);
void?Random(List?&L);
bool?LessThan(LESSTNAN?LParam,LESSTNAN?WParam);
void?InsertSort(List?&L);
void?ShellSort(List?&L,ShellData?Data,int?DataLength);
void?ShellInsert(List?&L,int?dk);
void?BubbleSort(List?&L);
void?QuickSort(List?&L,?int?Low,?int?High);
int?Partition(List?&L,?int?Low,?int?High);
void?SelectSort(List?&L);
int?SelectMinKey(List?&L,?int?Start);
void?HeapSort(List?&L);
void?HeapAdjust(List?&L,?int?s,?int?m);
void?RadixSort(List?&L);
Type*?MergeSort(List?&L);
void?MergingSort(Type?SR[],?Type?TR[],?int?s,?int?t);
void?Merge(Type?SR[],?Type?TR[],?int?i,?int?m,?int?n);
void?ListTranverse(List?&L,Function?p_function);
bool?IsType(List?&L,int?Length,?KeyType?param);
#include?"SortList.h"
void?InitList(List?&L)
{
int?i;
L.Length?=?0;
for?(i?=?0;?i?
{
L.r[i].Key?=?0;
L.r[i].Other?=?info;
}
}
void?Random(List?&L)
{
srand((unsigned)time(NULL));
int?i=1;
while?(i?
{
int?temp?=?rand();
if?(IsType(L,?i,?temp)?==?false)
{
L.r[i].Key?=?temp;
i++;
}
}
L.Length?=?MAXSIZE;
}
bool?IsType(List?&L,int?Length,?KeyType?param)
{
int?i;
for?(i?=?1;?i?
{
if?(L.r[i].Key?==?param)
return?true;
}
return?false;
}
bool?LessThan(LESSTNAN?LParam,?LESSTNAN?WParam)
{
if?(LParam?
return?true;
else
return?false;
}
void?ListTranverse(List?&L,?Function?p_function)
{
int?i;
for?(i?=?1;?i?
{
(*p_function)(L.r[i]);
}
}
void?InsertSort(List?&L)
{
int?i,?j;
for?(i?=?2;?i?
{
if?(LessThan(L.r[i].Key,?L.r[i?-?1].Key)?==?true)
{
L.r[0]?=?L.r[i];
L.r[i]?=?L.r[i?-?1];
for?(j?=?i?-?2;?LessThan(L.r[0].Key,?L.r[j].Key);?j--)
{
L.r[j?+?1]?=?L.r[j];
}
L.r[j?+?1]?=?L.r[0];
}
}
}
void?ShellInsert(List?&L,?int?dk)
{
int?i,?j;
for?(i?=?dk?+?1;?i?
{
if?(LessThan(L.r[i].Key,?L.r[i?-?dk].Key)?==?true)
{
L.r[0]?=?L.r[i];
for?(j?=?i?-?dk;?j>0?&&?LessThan(L.r[0].Key,?L.r[j].Key);?j?-=?dk)
{
L.r[j?+?dk]?=?L.r[j];
}
L.r[j?+?dk]?=?L.r[0];
}
}
}
void?ShellSort(List?&L,?ShellData?Data,?int?DataLength)
{
int?i;
for?(i?=?0;?i?
{
ShellInsert(L,?Data[i]);
}
}
void?BubbleSort(List?&L)
{
int?i,?j;
Type?temp;
for?(i?=?1;?i?
{
for?(j?=?1;?j?
{
if?(L.r[j].Key>L.r[j?+?1].Key)
{
temp?=?L.r[j];
L.r[j]?=?L.r[j?+?1];
L.r[j?+?1]?=?temp;
}
}
}
}
void?QuickSort(List?&L,?int?Low,?int?High)
{
if?(Low?
{
int?Piv?=?Partition(L,?Low,?High);
QuickSort(L,?Low,?Piv?-?1);
QuickSort(L,?Piv?+?1,?High);
}
}
int?Partition(List?&L,?int?Low,?int?High)
{
KeyType?PivotKey?=?L.r[Low].Key;
Type?temp;
while?(Low?
{
while?(Low?=?PivotKey)
{
High--;
}
temp?=?L.r[Low];
L.r[Low]?=?L.r[High];
L.r[High]?=?temp;
while?(Low?
{
Low++;
}
temp?=?L.r[Low];
L.r[Low]?=?L.r[High];
L.r[High]?=?temp;
}
return?Low;
}
void?SelectSort(List?&L)
{
int?i,j;
Type?temp;
for?(i?=?1;?i?
{
j?=?SelectMinKey(L,?i);
if?(i?!=?j)
{
temp?=?L.r[i];
L.r[i]?=?L.r[j];
L.r[j]?=?temp;
}
}
}
int?SelectMinKey(List?&L,?int?Start)
{
KeyType?temp=L.r[Start].Key;
int?Min=Start;
while?(Start?
{
if?(temp>L.r[Start].Key)
{
temp?=?L.r[Start].Key;
Min?=?Start;
}
Start++;
}
return?Min;
}
void?Merge(Type?SR[],?Type?TR[],?int?i,?int?m,?int?n)
{
int?k,j;
for?(j?=?m?+?1,?k?=?i;?i?<=?m&&j?<=?n;?k++)
{
if?(LessThan(SR[i].Key,?SR[j].Key)?==?true)
TR[k]?=?SR[i++];
else
TR[k]?=?SR[j++];
}
while?(i?<=?m)
{
TR[k]?=?SR[i];
i++;
k++;
}
while?(j?<=?n)
{
TR[k]?=?SR[j];
j++;
k++;
}
}
void?MergingSort(Type?SR[],?Type?TR[],?int?s,?int?t)
{
if?(s?==?t)
TR[s]?=?SR[s];
else
{
int?m?=?(s?+?t)?/?2;
MergingSort(SR,?TR,?s,?m);
MergingSort(SR,?TR,?m?+?1,?t);
Merge(SR,?TR,?s,?m,?t);
}
}
Type*?MergeSort(List?&L)
{
Type?*?temp=new?Type[MAXSIZE+1];
MergingSort(L.r,?temp,?1,?L.Length);
return?temp;
}
void?HeapAdjust(List?&L,?int?s,?int?m)
{
Type?RC?=?L.r[s];
int?j;
for?(j?=?2?*?s;?j?<=?m;?j?*=?2)
{
if?(j?
j++;
if?(LessThan(RC.Key,?L.r[j].Key)?==?false)
break;
L.r[s]?=?L.r[j];
s?=?j;
}
}
void?HeapSort(List?&L)
{
int?i;
Type?temp;
for?(i?=?L.Length?/?2;?i?>?0;?i--)
{
HeapAdjust(L,?i,?L.Length);
}
for?(i?=?L.Length;?i?>?1;?i--)
{
temp?=?L.r[1];
L.r[1]?=?L.r[i];
L.r[i]?=?temp;
HeapAdjust(L,?1,?i?-?1);
}
}
總結(jié)
以上是生活随笔為你收集整理的c语言实现各种排序,c语言实现各种排序算法的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 二叉排序数的构造-理论
- 下一篇： 计算机在娱乐中的应用有哪些,多媒体技术在