算法基础--快排序，堆排序，归并排序

这是笔记;

快速排序的思想：先说一趟划分：一个数组a[0...(length-1)]，把数组的第一个元素当作枢轴v（是vlaue，不是下标），将数组中所有比k小的元素都移动到k的左侧，将所有比v大的元素都移动到元素的右边。

　　　　　　　　我们需要得到一个数组划分后，枢轴v现在的位置下标（这是下一步进行划分的边界）;

　　　　　　　　长度为n的数组，平均需要log（n）次划分。

代码实现：

///quick sort
    void quick_sort(int a[],int s,int t){//这是算法的开始，我们看到，输入s	都是下标，下标和长度从一开始一定要区分开
        if(s<t){///那么这个算法什么时候结束呢？这是一个很常见的问题？----------》只要可划分数组a[]的长度大于1，就是说s<t，我们就对它进行划分。
            int k = Partition(a,s,t);///一趟划分，返回下一次划分的边界，这个k上的元素就排好了。我们可以利用了这个性质，做很多有意义的事情。，比如找到数组a中最小的k个数字;
            quick_sort(a,s,k-1);
            quick_sort(a,k+1,t);
        }
    }


    int Partition(int a[],int s,int e){///这就是划分算法，下面的while很经典。
        int temp = a[s];///store the a[s] ，先创建一个临时变量来保存当前位置的元素值。
        while(s<e){///只要多于一个元素，我们就运行划分算法
            while(s<e && a[e]>=temp) e--;///从数组的后面向前开始找，先找第一个小于tmp的元素-->
            a[s] = a[e];///-->将这个元素与a[s]交换
            while(s<e && a[s]<=temp) s++;///从数组的前面向后开始找第一个大于tmp的元素
            a[e] = a[s];///将这个元素和a[s]交换
        }///while
        a[s] = temp;///将tmp值放到最终的位置上，
        return s;///返回找到元素的下标
    }//Partition

堆排序：

堆排序思想：

　　什么大根堆？完全二叉树中的每个节点元素  大于等于 它的孩子节点值 ;左右孩子节点间没有任何关系

　　我们首先需要将一个数组a[]按照大根堆的标准建堆，　

　　　　　（1）　建好堆---》将数组a的第一个元素和最后一个元素调换，-----》再修复堆

　　     步骤（1） 我们需要迭代size(a)-1次，才能排好序。

这个思想很重要，因为 它能在一趟排好序的过程中，能在O（n）时间内建好堆; 但是建好堆后，对剩余的(n-i)的每个元素在log(n-i)时间内完成排序了;

代码:

///heap_sort algorithm
    void HeapSort(int a[],int n){///n is the index ,not the length
        for(int i = n/2;i>=0;i--){///build a big root heap
            Shift(a,i,n);
            for(int p = 0;p<=n;p++){
                cout<<a[p]<<" ";
            }cout<<endl;
        }

        for(int i = n;i>0;i--){
            int temp = a[0];
            a[0] = a[i];
            a[i] = temp;
            Shift(a,0,i-1);///build the a[0..(i-1)] as a big-root heap
        }
    }
    void Shift(int a[],int i,int m){///m is the index ,not the length
        ///这个算法假设a[i+1...m]中的各个元素满足堆的定义,本算法调整a[i]使得序列a[i..m]中的元素满足堆的性质
        ///要求不高,只是每次使大根堆的  元素数量多一个
        ///调堆的过程,每次只在一个子树中操作,调换;
        ///那么什么时候调换截止呢,就是说a[i]找到了要找的位置,就行了,我们这个函数的任务就结束了.
        int temp = a[i];///暂存a[i]到temp
        if(i==1){
            cout<<"start"<<endl;
        }
        for(int j = 2*i+1;j<=m;j=2*i+1){///a[i]的左右孩子的下标分别是[2i],[2i+1]
            if(j<m && a[j]<a[j+1]) j++;///若a[i]的右孩子存在,且关键字比较大,沿右孩子筛选
                                        ///找当前a[i]最大的孩子节点和a[i]相比较即可,
                                        ///大根堆的定义:只有节点和孩子节点的比较,没有孩子节点之间比较的意思
            if(temp<a[j]){///这个孩子的key比较大
                a[i] = a[j];///将这个孩子节点放到双亲的位置
                i = j;///修改当前被调整的节点
            }else{
                break;///调整完毕
            }
        }///for
        a[i] = temp;///将最初被调整节点放到正确位置
    }

　　梳理一边数组建堆的过程：

　建堆也是不断调堆Shift的过程，shift(int a[],int i,int m)函数所作的工作就是将数组a[i...m]  （都是下标）。

归并排序：

归并排序思想：

代码：

    ///merger_sort algorithm
void mergeArray(int * arrs, int * tempArr, int left, int middle, int right){
    int i = left, j = middle ;
    int m = middle + 1, n = right;
    int k = 0;

    while(i <= j && m <= n){
        if(arrs[i] <= arrs[m])
            tempArr[k++] = arrs[i++];
        else
            tempArr[k++] = arrs[m++];
    }
    while(i <= j)
        tempArr[k++] = arrs[i++];
    while(m <= n)
        tempArr[k++] = arrs[m++];

    for(i=0; i < k; i++)
        arrs[left + i] = tempArr[i];
}

void mergeSort(int * arrs, int * tempArr, int left, int right){
    if(left < right){
        int middle = (left + right)/2;
        mergeSort(arrs, tempArr, left, middle);
        mergeSort(arrs, tempArr, middle + 1, right);
        mergeArray(arrs, tempArr, left, middle, right);
    }
}

};