【华科复试】【贪心算法】最优二路归并树&二路归并排序

二路归并模式：每次仅作两个文件的归并；当有多个文件时，采用两两归并的模式，最终得到一个完整的记录文件。
二元归并树：二路归并模式的归并过程可以用一个二元树的形式描述，称之为二元归并树。

贪心求解： 任意两个文件的归并所需的元素移动次数与这两个文件的长度之和成正比。度量规则：每次选择需要移动次数最少的两个集合进行归并。处理规则：每次选择长度最小的两个文件进行归并。
为得到归并树根结点表示的归并文件，外部结点中每个文件记录需要移动的次数＝该外部结点到根的距离，即根到该外部结点路径的长度，如：下列F₄在整个归并过程中的移动量为4。

带权外部路径长度：记d_i是由根到代表文件F_i的外部结点的距离，q_i是F_i的长度。
最优的二路归并模式：与一棵具有最小外部带权路径长度的二元树相对应。

二路归并排序

#include <iostream>
#include <vector>
using namespace std;
void Merge(vector<int> &arr,int left,int mid,int right){
    int *help=new int(right-left+1);
    int p1=left,p2=mid+1,i=0;
    while(p1<=mid&&p2<=right){
        help[i++]=arr[p1]>arr[p2]?arr[p2++]:arr[p1++];
    }
    while(p1<=mid)
        help[i++]=arr[p1++];
    while(p2<=right)
        help[i++]=arr[p2++];
    for(int i=0;i<right-left+1;i++){
        arr[left+i]=help[i];
    }
}
void Sort(vector<int> &arr,int left,int right){
    if(left<right){
        int mid=(left+right)/2;
        Sort(arr,left,mid);
        Sort(arr,mid+1,right);
        Merge(arr,left,mid,right);
    }
}
void mergeSort(vector<int> &arr,int left,int right){
    if(arr.size()<2)
        return;
    Sort(arr,left,right);
}
int main()
{
    vector<int> arr;
    arr.push_back(5);
    arr.push_back(4);
    arr.push_back(7);
    arr.push_back(9);
    arr.push_back(3);
    arr.push_back(8);
    arr.push_back(2);
    arr.push_back(1);
    mergeSort(arr,0,arr.size()-1);
    for(int i=0;i<arr.size();i++){
        cout<<arr[i]<<" ";
    }
    return 0;
}

最优二路归并树（哈夫曼树）

struct HuffmanNode{
    int weight;
    int parent;
    int lchild,rchild;
};
class HuffmanTree{
public:
    HuffmanNode *Node;
    Tree(int n,vector<int> arr);//构造哈夫曼树
    selectMin(vector<int> arr,int &s1,int &s2);//选取两个最小数
};
HuffmanTree::selectMin(vector<int> arr,int &s1,int &s2){
    int Min1=10000,Min2=10000;
    int index1,index2;
    for(int i=0;i<arr.size();i++){
        if(arr[i]<Min1){
            if(Min1<Min2){
                Min2=Min1;
                index2=index1;
            }
            Min1=arr[i];
            index1=i;
        }else if(arr[i]<Min2){
            Min2=arr[i];
            index2=i;
        }else
            continue;
    }
    s1=index1;
    s2=index2;
}
HuffmanTree::Tree(int n,vector<int> arr){//arr是升序排序的数组
    Node=new HuffmanNode[2*n-1];
    for(int i=0;i<2*n-1;i++){//初始化，所有结点没有双亲和孩子
        Node[i].parent=-1;
        Node[i].lchild=-1;
        Node[i].rchild=-1;
    }
    for(int i=n;i<2*n-1;i++){
        int i1,i2;
        selectMin(arr,i1,i2);
        int mid=Node[i1]+Node[i2];
        Node[i1].parent=i;
        Node[i2].parent=i;
        Node[i].lchild=i1;
        Node[i].rchild=i2;
        Node[i].weight=mid;
        arr.erase(i1);
        arr.erase(i2);
        arr.insert(i,mid);
    }
}