c语言实现各种排序算法
以下是我用c语言实现的各种排序算法
#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 <stdlib.h>
#include <time.h>
#endif
#ifndef _DEBUG_H
#define _DEBUG_H
#include <stdio.h>
#include <iostream>
#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 < MAXSIZE + 1; i++)
{
L.r[i].Key = 0;
L.r[i].Other = info;
}
}
void Random(List &L)
{
srand((unsigned)time(NULL));
int i=1;
while (i < MAXSIZE + 1)
{
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 < Length+1; i++)
{
if (L.r[i].Key == param)
return true;
}
return false;
}
bool LessThan(LESSTNAN LParam, LESSTNAN WParam)
{
if (LParam < WParam)
return true;
else
return false;
}
void ListTranverse(List &L, Function p_function)
{
int i;
for (i = 1; i < L.Length + 1; i++)
{
(*p_function)(L.r[i]);
}
}
void InsertSort(List &L)
{
int i, j;
for (i = 2; i < L.Length + 1; 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 < L.Length + 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 < DataLength; i++)
{
ShellInsert(L, Data[i]);
}
}
void BubbleSort(List &L)
{
int i, j;
Type temp;
for (i = 1; i < L.Length + 1; i++)
{
for (j = 1; j < L.Length+1-i; 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 < High)
{
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 < High)
{
while (Low < High&&L.r[High].Key >= PivotKey)
{
High--;
}
temp = L.r[Low];
L.r[Low] = L.r[High];
L.r[High] = temp;
while (Low < High&&L.r[Low].Key <= PivotKey)
{
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 < L.Length + 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 < L.Length + 1)
{
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 < m&&LessThan(L.r[j].Key, L.r[j + 1].Key) == true)
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);
}
}