数据结构的排序用直接插入、折半插入、希尔排序、快速排序

数据结构的排序是数据结构中的一大难点，也是一个比较重要的组成部分，里面有多种排序方法，有直接插入排序，折半插入排序，希尔排序，快速排序，堆排序等多种排序方法，这里将直接排序，折半插入排序，希尔排序以及快速排序的方法，首先讲下直接排序，对于这几种排序来说，其中很重要的，也是每一种排序方式都要涉及到的一个小程序，就是一个数的插入操作，在一组有序的数字中插入一个数，这对于我们都不是那么的陌生，将要插入的地方的数据之后全部向后移动一个位置，将要插入的数据插入进去就行啦，好啦，现在来说排序。

直接插入排序：10个数，从第二个数开始，先比较第一个数，如果小的话，第一个数向后移动，然后将要插入的数放在第一位，然后循环，第三个数，小的话，找到要插入的位置，将比它大的数字向后移动一位，将这个数字插入就行。

折半插入排序：这个与直接插入排序多了一个巧妙的方法，直接排序找要插入位置是一点一点的找的，折半插入排序找位置的时候是折半查找的，找到中间的位置，看是否比要插入的数大，大的话在中间位置的左边，小的话在右边，一直折半，增加效率!

希尔排序：是通过间距来交换，就是说10个数，从间距为5开始，比较第一个数字与第六个数字，取第六个为标记，存在数组0的空间中，与第一个比较，小的话第一个数放在第六个位置，然后将标记的放在第一个位置，然后间距为3，知道间距为1，这里不懂的话，可以在循环中输出数据，这样比较的好理解，间距为1的时候就是两两比较，小的放在前面，但为什么要从5开始，这是减少循环，加一个输出语句就能看出来。

快速排序，这个比较的难，毕竟是10大算法之一，快速排序，要用到递归，取第一个数为标记的数字，将比这个数小的放在前面，比这个数大的放在后面，然后在这个数的位置开始，左面一直这样循环，知道排好序列，在排右面的。不懂的话可以加上输出函数，观察数据的变化！

代码如下：

main.cpp：

#include <iostream>
#include "han.h"
using namespace std;


int main()
{
SqList L;
int i = 0;
int j = 0;
int c[11];
cout<<" please cin 10 ge shu "<<endl;
for(i = 1;i<=10;i++)
{
cin>>c[i];
}
CreateList(L,c,10);
cout<<"pai xu qian: ";
ListTraverse(L);
zhijiepaixu(L);
cout<<"zhijie pai xu hou: ";
ListTraverse(L);
CreateList(L,c,10);
cout<<"pai xu qian: ";
ListTraverse(L);
chaizhuangpaixu(L);
cout<<"chaizhuang pai xu hou: ";
ListTraverse(L);
CreateList(L,c,10);
cout<<"pai xu qian: ";
ListTraverse(L);
for(j = 5;j>=1;j-=2)
xierpaixu(L,j);
cout<<"xier pai xu hou: ";
ListTraverse(L);
CreateList(L,c,10);
cout<<"pai xu qian: ";
ListTraverse(L);
kuaisupaixu(L);
cout<<"kuaisu pai xu hou: ";
ListTraverse(L);
}

han.h:

#include <iostream>
using namespace std;


typedef struct 
{
int key;
}RedType;


typedef struct 
{
RedType *r;
int length;
}SqList;




void CreateList(SqList &L,int c[],int n)
{
int i;
L.r=new RedType[n+1];
for(i=1;i<=n;i++)
{
L.r[i].key=c[i];
}
L.length=n;
}


void ListTraverse(SqList L)
{
int i;
for(i=1;i<=L.length;i++)
cout<<L.r[i].key<<'\t';
cout<<endl;
}


void zhijiepaixu(SqList &L)
{
int i = 2;
int j;
for(i = 2;i<=L.length;i++)
{
if(L.r[i].key<L.r[i-1].key)
{
L.r[0] = L.r[i];
for(j = i-1;L.r[0].key < L.r[j].key;j--)
{
L.r[j+1] = L.r[j];
}
L.r[j+1] = L.r[0];
}
}


}


void chaizhuangpaixu(SqList &L)
{
int i = 2;
int low,high,m,j;
for(i = 2;i<=L.length;i++)
{
L.r[0] = L.r[i];
low = 1;
high = i-1;
while(low<=high)
{
m = (low+high)/2;
if(L.r[0].key <L.r[m].key)
high = m-1;
else
low = m+1;
}
for(j = i-1;j>=high+1;--j)
{
L.r[j+1] = L.r[j];
}
L.r[high+1] = L.r[0];
}
}


void xierpaixu(SqList &L,int n)
{
int i,j;
for(i = n+1;i<=L.length;i++)
{
L.r[0] = L.r[i];
for(j = i-n;j>0&&L.r[0].key<L.r[j].key;j-=n)
{
L.r[j+n] = L.r[j];
}
L.r[j+n] = L.r[0];
}
}


int partition(SqList &L,int low,int high)
{
int pivotkey;
L.r[0] = L.r[low];
pivotkey = L.r[low].key;
while(low<high)
{
while(low<high&&L.r[high].key >= pivotkey)
--high;
L.r[low] = L.r[high];
while(low<high&&L.r[low].key <= pivotkey)
++low;
L.r[high] = L.r[low];
}
L.r[low] = L.r[0];
return low;
}


void QSort(SqList &L,int low,int high)
{
int pivotloc;
if(low<high)
{
pivotloc = partition(L,low,high);
QSort(L,low,pivotloc-1);
QSort(L,pivotloc+1,high);
}
}


void kuaisupaixu(SqList &L)
{
QSort(L,1,L.length);
}
运行结果：

 please cin 10 ge shu 
12 2 16 30 28 10 16 20 6 18
pai xu qian: 12 2       16      30      28      10      16      20      6      18
zhijie pai xu hou: 2    6       10      12      16      16      18      20     28       30
pai xu qian: 12 2       16      30      28      10      16      20      6      18
chaizhuang pai xu hou: 2        6       10      12      16      16      18     20       28      30
pai xu qian: 12 2       16      30      28      10      16      20      6      18
xier pai xu hou: 2      6       10      12      16      16      18      20     28       30
pai xu qian: 12 2       16      30      28      10      16      20      6      18
kuaisu pai xu hou: 2    6       10      12      16      16      18      20     28       30