数据结构---排序算法总结

一、插入排序

1、直接插入排序

2、折半插入排序

3、希尔排序

---

1.1直接插入排序

是最简单直接的排序方法。它的基本思想是将新的关健值插入到排好序的前序记录中，所要做的就是找到该关键值应该处的位置（关于找位置可以用折半查找法提高效率，下面介绍）。

具体做法：原始数组长度为N的序列，插入索引为i(i <Ｎ)的关健值。前提是前面i个关健值a[0].a[1],a[2]…a[i-1]已经排好序，找到a[i]应所处的位置将其插入，原来位置上的元素则往后移动。

void InsertSort(int a[],int len)
{
    for(int i =1,i<len;i++)
    {
        int index = i;
        while(a[index] < a[index-1] && index > 0)
        {
            swap(a[index],a[index-1]);
            index--;
        }
    }
    for(int i = 0; i< len; i++)
        {
            cout<<setw(3)<<a[i];
        }
}

---

1.2折半插入排序

折半插入和直接插入思想一致，只是在查找a[i]应该插入位置时，用折半查找法减少了比较次数。直接上代码：

void ZBInsertSort(int a[], int len)
{
    for (int i = 1; i < len; i++)
    {
        int low, high, mid;
        low = 0;
        high = i;       
        while (low < high)
        {
            mid = (low + high) / 2;
            if (a[high] < a[mid])
            {
                int temp = a[high];
                for (int k = high ; k > mid; k--)
                {
                    a[k] = a[k-1];
                }
                a[mid] = temp;
                high = mid;
            }
            else
                low = mid + 1;
        }   

        for (int k = 0; k <len; k++)
            cout << setw(3)<< a[k];
    }
}

---

1.3希尔排序

又名“缩小增量排序法“，它的主要思想是不断把待排序的一组记录按照间隔值分成若干小组，对每一组采用直接插入排序。

void ShellSort(int a[],int len)
{
    for (int gap = len / 2; gap >= 1; gap /= 2)
    {
        for (int i = gap; i < len; i++)
        {
            if (a[i] < a[i - gap])
            {
                swap(a[i],a[i-gap]);
            }
        }
        for (int i = 0; i < len; i++)
            cout << setw(3) << a[i];
    }
}

继续更新。。。

二、交换排序

2.1、冒泡排序

2.2、快速排序

---

2.1冒泡排序

冒泡排序很简单，将待排序数组看成是垂直树立的，将较大值或较小值从底部不断“涌”上来，与索引为“0,1，。。。N”的记录交换。记将“气泡”不断涌出“水面”。

void BubbleSort(int a[],int size)
{

    for (int i = 0; i < size - 1; i++)
    {
        for (int j = size -1;j >= i;j--)
        {
            if (a[i] > a[j])
                swap(a[i],a[j]);

        }
        cout << endl;
    for (int k = 0; k < size; k++)
        cout << setw(3) << a[k];

    }
}

2.2快速排序

快速排序是基于冒泡改进而得。基本思想是：在待排序数组中随机选择一个记录（当然可以是第一个），将该记录放入关键位置。以升序排序为例，将该记录放入关键位置后，把所有小于该记录的放到该记录前面，大的放到该记录后面。因此该记录将会被分成2段“记录”，之后对两段数组采取同样的策略（递归）。快速排序如其名称一样，以快速为特点，时间复杂度低，也是常用几种排序方法之一，因此要重点掌握。

int QuickSort1(int s[], int low, int high)
{
    int temp = s[low];//取第一个记录为基准记录
    int i = low, j = high;
    while (i < j)
    {
        while (i < j && s[j] >= temp)
            j--;//从后往前找到小于基准记录的索引
        if (i < j)
        {
            s[i++] = s[j];//将该索引上的记录赋值给原基准记录位置
        }
        while (i < j && s[i] < temp)//从前往后找大于基准记录的索引
            i++;
        if (i < j)
        {
            s[j--] = s[i];//同上
        }
    }
    s[i] = temp;//该基准记录最终位置
    return i;//返回“两段”中间的索引方便递归
}
void QuickSort2(int s[], int low, int high)
{
    if (low < high)
    {
        int pos = QuickSort1(s, low, high);
        QuickSort2(s,low,pos - 1);
        QuickSort2(s,pos + 1,high);
    }
}

三、选择排序

3.1、直接选择排序

3.2、堆排序

---

3.1直接选择排序

这是一种简单的排序方式，速度较慢。其思想是： 将整个待排序数组分成有序区和无序区，有序区位于左端，无序区位于右端。以正序排序为例，将最小值找出放在最左端，以此类推。。。
（貌似与冒泡排序有点类似，注意它们细微的区别，虽然都是复杂度有点高的算法）

void SelectSort(int s[],int len)
{
    for (int i = 0; i < len - 1; i++)
    {
        int pos = i,temp = s[pos];
        for (int j = i + 1; j < len; j++)
        {
            if (temp > s[j])
            {
                pos = j;
                temp = s[pos];
            }
        }
        s[pos] = s[i];
        s[i] = temp;
    }
}

3.2堆排序

堆排序的意义在于，利用堆的结构来减少了重复比较的次数，使得速度提升。当然构建堆的过程也是time consuming的过程。不论是正序还是逆序，堆排序都是从数组尾部开始构建。因为堆排序总是需要用最上层的父节点和最后的子节点交换来排序。

void ArrayAdjust(int a[], int k, int size)
{
    int ChildL = k * 2 + 1;
    int ChildR = k * 2 + 2;
    int temp = k;
    if (ChildL <= (size - 1) && a[temp] < a[ChildL])//之所以要这样是因为不确定节点数是奇数还是偶数，即最后一个父节点是有几个子节点。
        temp = ChildL;
    if (ChildR <= (size - 1) && a[temp] < a[ChildR])
        temp = ChildR;
    if (temp != k)//上层节点发生交换必然引起下层节点不符合堆的结构，因此要重新调整。
    {
        swap(a[temp],a[k]);
        ArrayAdjust(a,temp,size);//
    }

}
void BuildHeap(int a[],int size)//将[a[k]...a[size]]置为大根堆
{
    for (int k = (size - 1) / 2; k >= 0; k--)//从最下面的子节点开始构建堆
        ArrayAdjust(a,k,size);

}

三、归并排序

所谓“归并”，就是把多个有序表合成新的有序表。文字说明不如code,好吧。

void Merge(int s[], int low,int high)
{
    int mid = (low + high) / 2;
    int temp[len] = { 0 },k = 0;
    int i = low, j = mid + 1;
    while (i <= mid && j <= high)
    {
        if (s[i] < s[j])//正序
            temp[k++] = s[i++];
        else
            temp[k++] = s[j++];
    }
    while (i <= mid)
    {
        temp[k++] = s[i++];
    }
    while (j <= high)
    {
        temp[k++] = s[j++];
    }
    for (k = 0, i = low; i <= high; k++, i++)
        s[i] = temp[k];

}
void MergeSort(int s[],int low,int high)
{
    int mid;
    if (low < high)
    {
        mid = (low + high) / 2;
        MergeSort(s,low,mid);//递归的调用将真个数组分成最小的长度为2的数组
        MergeSort(s, mid + 1, high);
        Merge(s, low, high);
        cout << endl;
        for (int i = 0; i < len; i++)
            cout << setw(3) << s[i];
    }
}

持续更新。。。