排序算法汇总

直接插入排序算法

#include <iostream>

#define N 10
int main()
{
int a
= {14,12,72,56,32,10,97,67,25,48};

for (int j=1; j<N; ++j)
{
int key = a[j];
int i = j-1;

while (i>=0 && a[i]>key)
{
a[i+1] = a[i];
i--;
}

a[i+1] = key;
}

for (int k=0; k<N; ++k)
{
std::cout << a[k] << std::endl;
}

system("pause");
return 0;
}

折半插入排序算法

#include <iostream>

#define N 10

int main()
{
int a
= {14,12,72,56,32,10,97,67,25,48};

for (int j=1; j<N; ++j)
{
int key  = a[j];
int low  = 0;
int high = j-1;

while (low <= high)
{
int mid = (low+high)/2;
if (a[mid] > key) //落在低半区
{
high = mid - 1;
}
else
{
low = mid + 1;
}
}

for (int i=j-1; i>high; --i)
{
a[i+1] = a[i];
}

a[high+1] = key;
}

for (int k=0; k<N; ++k)
{
std::cout << a[k] << std::endl;
}

system("pause");
return 0;
}

2路插入排序算法，基于折半插入排序算法的基础上改进的

#include <iostream>

#define N 12

enum direction
{
forward,
backward
};

void BInsertSort(int* d, int low_, int high_, int key, direction dir)
{
int low  = low_;
int high = high_;

while (low <= high)
{
int mid = (low+high)/2;
if (d[mid] > key) //落在低半区
{
high = mid - 1;
}
else
{
low = mid + 1;
}
}

if (dir==forward)
{
int i=high_+1;
for (; i>high+1; --i)
{
d[i] = d[i-1];
}
d[i] = key;
}
else
{
int i=low_-1;
for (; i<low-1; ++i)
{
d[i] = d[i+1];
}
d[i] = key;
}
}

int main()
{
int a
= {86,97,96,14,12,72,56,32,10,25,48,79};
int d
= {0};

int first = 0;
int final = 0;

d[0] = a[0];
for (int i=1; i<N; i++)
{
if (a[i]<d[0]) //小于中间值 插在后面
{
first = (first + N - 1) % N;
BInsertSort(d, first+1, N-1, a[i], backward);//将a[i]元素插入d[first+1]-d[N-1]区间,元素前移

/*
int j = 0;
first = (first + N - 1) % N;
for (j=first+1; j<N && a[i]>d[j]; j++)
{
d[j-1]=d[j];
}
d[j-1] = a[i];
*/
}
else //插入前面
{
final++;
BInsertSort(d, 0, final-1, a[i], forward);//将a[i]元素插入d[0]-d[final-1]区间,元素后移

/*
int j = 0;
for (j=final; j>0 && a[i]<d[j]; j--)
{
d[j+1]=d[j];
}
final++;
d[j+1]=a[i];
*/
}
}

for (int k=0; k<N; k++)
{
a[k] = d[(k+first)%N];
}

system("pause");
return 0;
}

表插入排序算法

#include <iostream>

#define N 12

struct ListNode
{
int       data;
ListNode* next;
};

//将p值插入pre和cur区间, 将last指针指向p->next
void sort(ListNode*& root)
{
ListNode* p    = root;
ListNode* last = root;
while (p)
{
ListNode* pre = NULL;
ListNode* cur = root;

for (; cur!=p && cur->data < p->data; cur=cur->next) //寻找比p小的最大值的位置
{
pre = cur;
}

if (cur == p)
{
last = p;
p = p->next;
continue;
}

//先保存p 然后将p移动至下一个指针
ListNode* q = p;
p = p->next;
last->next = p;//保存指针防止链表中断

if (pre==NULL)
{
root = q;
q->next = cur;
}
else
{
pre->next = q;
q->next   = cur;
}
}
}

void remove(ListNode*& root, int* a)
{
ListNode* p = root;

int i = 0;
while (p)
{
a[i++] = p->data;
p = p->next;
}
}

int main()
{
int a
= {86,17,96,14,12,72,56,32,10,25,48,79};
ListNode* root = new ListNode
;
ListNode* head = root; //保存原始数组指针 便于释放 因为在sort过程中对root会改动

for (int i=0; i<N; i++)
{
root[i].data = a[i];
root[i].next = (i==N-1) ? NULL : &root[i+1];
}

sort(root);
remove(root, a); //将数据从有序链表中拷贝回数组中

for (int i=0; i<N; ++i)
{
std::cout << a[i] << std::endl;
}

delete [] head;
system("pause");
return 0;
}

希尔插入排序算法，和直接插入算法的区别在于步长由原来的1改成了len，右边注释的是直接插入排序算法的步骤

#include <iostream>

#define N 10

int main()
{
int a
= {12,27,82,24,77,79,54,36,90,21};

for (int len=N/2; len>0; len=len/2) //步长
{
//这里的for循环为直接插入排序
for (int j=len; j<N; ++j)   //j=1
{
int key = a[j];
int i = j-len;          //int i=j-1

while (i>=0 && a[i]>key)
{
a[i+len] = a[i];  //a[i+1] = a[i]
i=i-len;            //i--
}

a[i+len] = key;       //a[i+1] = key
}
}

for (int i=0; i<N; ++i)
std::cout << a[i] << std::endl;

system("pause");
return 0;
}

冒泡交换排序算法

#include <iostream>

#define N 10

int main()
{
int a
= {12,14,72,56,32,10,97,67,25,48};

for (int i=0; i<N-1; ++i)
{
for (int j=0; j<N-i-1;j++)
{
if (a[j]>a[j+1])
{
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}

for (int k=0; k<N; ++k)
{
std::cout << a[k] << std::endl;
}

system("pause");
return 0;
}

快速交换排序算法

#include <iostream>

#define N 10

/*
int partition(int* a, int low, int high)
{
int pivotkey = a[low];
while (low<high)
{
while (low<high && a[high]>pivotkey) --high;
int temp1 = a[low];
a[low]    = a[high];
a[high]   = temp1;
while (low<high && a[low]<pivotkey) ++low;
int temp2 = a[low];
a[low]    = a[high];
a[high]   = temp2;
}
return low;
}
*/

int partition(int* a, int low, int high)
{
int key      = a[low];
int pivotkey = a[low];
while (low<high)
{
while (low<high && a[high]>pivotkey) --high;
a[low]  = a[high];
while (low<high && a[low]<pivotkey) ++low;
a[high] = a[low];
}
a[low] = key;
return low;
}

void qsort(int* a, int low, int high)
{
if (low<high)
{
int pivotloc = partition(a, low, high);
qsort(a, low, pivotloc-1);
qsort(a, pivotloc+1, high);
}
}

int main()
{
int a
= {12,27,82,24,77,79,54,36,90,21};

qsort(a, 0, N-1);

for (int i=0; i<N; ++i)
std::cout << a[i] << std::endl;

system("pause");
return 0;
}

简单选择排序算法

#include <iostream>

#define N 10

int selct_min_key(int* a, int idx)
{
int pos = idx;
int min = a[idx];
for (int i=idx+1; i<N; ++i)
{
if (a[i]<min)
{
min = a[i];
pos = i;
}
}

return pos;
}

void selset_sort(int* a)
{
for (int i=0; i<N; ++i)
{
int j=selct_min_key(a, i);
if (i != j)
{
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}

int main()
{
int a
= {12,27,82,24,77,79,54,36,90,21};

selset_sort(a);

for (int i=0; i<N; ++i)
std::cout << a[i] << std::endl;

system("pause");
return 0;
}

树形选择排序算法

#include <iostream>
#include <math.h>

#define N 10

int selct_min_key(int* d, int k, int count)
{
int low  = k;       //第一个节点
int high = count-1; //最后一个节点

while (low<high)
{
for (int i=low; i<high; i=i+2)
{
d[i/2] = d[i] > d[i+1] ? d[i+1] : d[i];
}

high = low-1;
low  = low/2;
}

return d[0];
}

void tree_select_sort(int* a)
{
//构造完全而二叉树
int lay = (int)ceil(log(double(N))/log(double(2))+1);//二叉树层数
int count = (int)pow(double(2),lay)-1;//总共二叉树节点个数
int k = (int)pow(double(2), lay-1)-1;//第一个叶子节点的序号

int* d = new int[count];//申请完全二叉树空间
for (int i=0;i<N; ++i)//给二叉树叶子节点赋值
{
d[k+i] = a[i];
}
for (int i=k+N; i<count; ++i) //给其他的叶子节点赋最大值0x7FFFFFFF
{
d[i] = 0x7FFFFFFF;
}

//树形选择排序算法具体实现
for(int i=0; i<N; i++)
{
a[i]=selct_min_key(d, k, count);//查找并返回最小的节点
for(int j=k; j<count; j++)
{
if(a[i]==d[j])
{
d[j]=0x7FFFFFFF;//更改为最大值
break;
}
}
}

delete [] d;
}

int main()
{
int a
= {12,27,82,24,77,79,54,36,90,21};

tree_select_sort(a);

for (int i=0; i<N; ++i)
std::cout << a[i] << std::endl;

system( "pause" );
return 0;
}

堆选择排序算法，对于大顶堆和小顶堆的不同实现，只需要更改heapadjust函数中的a[s]<a[left]、a[s]<a[right]中的比较符号就可以实现了。

#include <iostream>

#define N 10

void swap(int& a, int& b)
{
int temp = a;
a = b;
b = temp;
}

void heapadjust(int* a, int s, int m)
{
int left  = 2*s+1;
int right = 2*s+2;

if (left<=m-1 && a[s]<a[left]) //说明当前节点有左孩子节点，对左孩子节点递归heapadjust
{
swap(a[s],a[left]);
heapadjust(a,left,m);
}

if (right<=m-1 && a[s]<a[right]) //说明当前节点有右孩子节点，对右孩子节点递归heapadjust
{
swap(a[s],a[right]);
heapadjust(a,right,m);
}
}

void heapsort(int* a)
{
for (int i=N/2-1; i>=0; i--)
{
heapadjust(a, i, N);//N个元素
}

for (int i=N-1;i>=0;--i) //输出堆顶元素，对剩余元素重新构建堆
{
swap(a[0],a[i]);
heapadjust(a, 0, i);
}
}

int main()
{
int a
= {12,27,82,24,77,79,54,36,90,21};

heapsort(a);

for (int i=0; i<N; ++i)
std::cout << a[i] << std::endl;

system( "pause" );
return 0;
}

归并排序算法

#include <iostream>

#define N 10

void merge(int* a, int start, int mid, int end)
{
int* d = new int[end-start+1];

int i = start;
int j = mid+1;
int k = 0;

while (i<=mid && j<=end)
{
if (a[i]<a[j])
d[k++] = a[i++];
else
d[k++] = a[j++];
}

while (i<=mid)
{
d[k++] = a[i++];
}
while (j<=end)
{
d[k++] = a[j++];
}

for (int c=0; c<end-start+1;c++)//将d中的元素拷贝回至a中
{
a[start+c] = d[c];
}

delete [] d;
}

void mergesort(int* a, int start, int end)
{
if (start<end)
{
int mid = (start+end)/2;
mergesort(a, start, mid);
mergesort(a, mid+1, end);
merge(a, start, mid, end);
}
}

int main()
{
int a
= {12,27,82,24,77,79,54,36,90,21};

mergesort(a, 0, N-1);

for (int i=0; i<N; ++i)
std::cout << a[i] << std::endl;

system( "pause" );
return 0;
}

桶排序算法

#include <iostream>

#define N   10
#define MID 50

int partition(int* a, int low, int high)
{
int key      = a[low];
int pivotkey = a[low];
while (low<high)
{
while (low<high && a[high]>pivotkey) --high;
a[low]  = a[high];
while (low<high && a[low]<pivotkey) ++low;
a[high] = a[low];
}
a[low] = key;
return low;
}

void qsort(int* a, int low, int high)
{
if (low<high)
{
int pivotloc = partition(a, low, high);
qsort(a, low, pivotloc-1);
qsort(a, pivotloc+1, high);
}
}

void bucketsort(int* a)
{
int* b1 = new int[N/2];int bi1 = 0;
int* b2 = new int[N/2];int bi2 = 0;

for (int i=0;i<N;i++)
{
if (a[i]<MID)
b1[bi1++] = a[i];
else
b2[bi2++] = a[i];
}

qsort(b1, 0, N/2-1);
qsort(b2, 0, N/2-1);

for (int i=0;i<N/2; ++i)
{
a[i]     = b1[i];
a[i+N/2] = b2[i];
}

delete [] b1;
delete [] b2;
}

int main()
{
int a
= {12,27,82,24,77,79,54,36,90,21};//100以内的数

bucketsort(a);

for (int i=0; i<N; ++i)
std::cout << a[i] << std::endl;

system( "pause" );
return 0;
}