归并排序

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <stack>
using namespace std;

template <typename T>
void merge(T *a , int first, int mid, int last)
{
T* temp = new T[last - first + 1];
int first1 = first, last1 = mid;
int first2 = mid + 1, last2 = last;
int index = 0;
while(first1 <= last1 && first2 <= last2){
if(a[first1 ] <= a[first2])
temp[index++] = a[first1++];
else
temp[index++] = a[first2++];
}
while(first1 <= last1){
temp[index++] = a[first1++];
}
while(first2 <= last2){
temp[index++] = a[first2++];
}
for(int i = first; i <= last; i++){
a[i] = temp[i - first];
}
delete [] temp;
return;
}
template<typename T>
void MergeSort(T *a, int first, int last){
if(last - first > 0){   //at least two element
int mid = (last + first) / 2;
MergeSort(a, first, mid);
MergeSort(a, mid + 1, last);
merge(a, first, mid, last);
}
return;
}
#define MAXN 100
int a[MAXN];
int main()
{
for(int i = 0; i < MAXN; i++){
a[i] = MAXN-i;
}
MergeSort(a, 0, MAXN-1);
for(int i = 0; i < MAXN; i++){
cout << a[i] << endl;
}
return 0;
}

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

template <typename Node_entry>
struct Node{
Node_entry entry;
Node* next;
Node(){
next = NULL;
}
Node(const Node_entry& newEntry, Node* add_on = NULL){
entry = newEntry;
next = add_on;
}
};
template<typename T>
void PrintList(Node<T>* l){
if(l != NULL) cout << l->entry;
l = l->next;
while(l != NULL){
cout << "->" << l->entry;
l = l->next;
}
cout << "->NULL\n";
return;
}
template <typename T>
Node<T>* divide(Node<T>* list){
Node<T> *position = list->next,// traversed the entire list
*second, *end_of_first = list;
while(position != NULL){
position = position->next;
if(position != NULL){
position = position->next;
end_of_first = end_of_first->next;
}
}
second = end_of_first->next;
end_of_first->next = NULL;  // add a NULL at the end of the first
/*
cout << "check divide\n";
cout << "first:\n"; PrintList(list);
cout << "second:\n"; PrintList(second);
*/
return second;
}
template <typename T>
Node<T>* merge(Node<T>* first, Node<T>* second){
Node<T> combined, *last_sorted = &combined;
while(first != NULL && second != NULL){
if(first->entry <= second->entry){
last_sorted->next = first;
last_sorted = first;
first = first->next;
}
else{
last_sorted->next = second;
last_sorted = second;
second = second->next;
}
}
if(first != NULL){
last_sorted->next = first; // there is a NULL at the end of the first, no need to add
}
else{ // second != NULL
last_sorted->next = second;// there is a NULL at the end of the second, no need to add
}
/*
cout << "check merge\n";
PrintList(combined.next);
*/
return combined.next;
}

template<typename T>
void MergeSort(Node<T>*& list){
if(list != NULL && list->next != NULL){ // at least two element
Node<T>* second_part = divide(list);// divide list into two parts
MergeSort(list);
MergeSort(second_part);
list = merge(list, second_part);   // that why use parameter [Node<T>*& list]
}
return;
}
template <typename T>
void MergeSort(Node<T> *&list, int len)
{
if(len > 1){                //at least there are two elements
Node<T> * second , *end_of_the_first_sublist = list;
for(int i = 0; i < (len - 1) / 2; i++){ // discuss for odd and for even
end_of_the_first_sublist = end_of_the_first_sublist -> next;
}
second = end_of_the_first_sublist -> next;
end_of_the_first_sublist -> next = NULL;   // add an end to the first part
int len_of_first_sublist = (len + 1)/ 2;   // second part is [len-len_of_first_sublist]
MergeSort(list, len_of_first_sublist);
MergeSort(second, len-len_of_first_sublist);
list = merge(list, second);
}
return;
}
#define MAXN 20
int main()
{
Node<int> *list = new Node<int>(1);
for(int i = 2; i <= MAXN; i++){
list = new Node<int>(i, list);
}
cout << "before sort:\n"; PrintList(list);
//MergeSort(list);
MergeSort(list, MAXN);
cout << "after sorted\n"; PrintList(list);
return 0;
}