C++实现7种基本排序

#include <iostream>

using namespace std;

void printData(int data[],int n) {
    for(int i =0 ; i < n; ++i) {
        cout <<data[i]<<"\t";
    }
    cout<<endl;
}
void SSort(int data[] ,int n) {
    for(int i = n-1; i > 0; --i) {
        int  t  = i;
        for(int j = 0; j < i; ++j ) {
            if(data[j] > data[t]) {
                t = j;
            }
        }
        swap(data[i], data[t]);
    }
}


void InsertSort(int data[], int n) {
    for(int i = 1; i < n ; ++i) {
        int key = data[i];
        int j ;
        for( j = i-1; j >= 0; --j) {
            if(key < data[j]) {
                data[j+1] = data[j];
            } else
                break;
        }
        data[j+1] = key;
    }
}

void BubbleSort(int data[], int n) {
    int flag = n -1;
    while(flag != 0) {
        int t = 0;
        for(int i = 0; i < flag  ; ++i) {
            if( data[i] > data[i+1] ) {
                swap(data[i], data[i+1]);
                t = i;
            }

        }
        flag = t;
    }
}


void ShellSort(int data[], int n) {
    int gap = n ;
    int i ;
    while( gap >0) {
        gap = gap /2;
        for( i = 0; i < gap; ++i) {
            int key;
            int t;
            for(int j = i + gap;  j < n ; j += gap) {
                key = data[j];
                t = j -gap;
                while(key < data[t]) {
                    data[t+gap] = data[t];
                    t = t- gap;
                    if( t < i)
                        break;
                }
                data[t+gap] = key;
            }
        }
    }

}

int partition(int data[], int length, int start , int end) {

    if( data== NULL || length <= 0 || end >= length ||start < 0 || start >= end) {
        return -1;
    }

    int i = start;
    int j = end +1;
    int  middle = (i+j) /2;

    if( data[start] > data[middle])
        swap(data[start], data[middle]);
    if( data[start] > data[end])
        swap(data[start], data[end]);
    if( data[middle] > data[end])
        swap(data[middle], data[end]);

    swap(data[start],data[middle]);

    int key = data[start];

    while( i < j ) {
        ++i;
        while( data[i] < key ) ++i;

        --j ;
        while( data[ j] > key) --j;

        if( i < j ) {
            swap(data[i], data[j]);
        }
    }
    swap(data[j], data[start]);
    return j;

}

void QuickSort(int data[], int length ,int start, int end) {
    if( data == NULL || length <= 0 || start == end)
        return ;

    int index = partition(data, length, start, end );
    if( index > start) {
        QuickSort(data,length, start, index -1);
    }
    if( index < end) {
        QuickSort(data,length, index +1, end );
    }

}

void QuickSort_1(int data[], int length, int start, int end) {
    if( start < end) {

        int i = start;
        int j = end +1;
        int key = data[start];
        while( i < j) {
            ++i ;
            while( data[i] < key) i++;

            --j;
            while( data[j] > key) j--;

            if( i < j) {
                swap(data[i], data[j]);
            }

        }
        swap(data[j], data[start]);

        QuickSort_1(data,length,start,j-1);
        QuickSort_1(data,length,j+1, end);
    }

}

void  restore(int data[], int start, int end) {
    int j = start;
    while( j <= end /2) {
        int m = 0;
        if( 2*j <  end  && (data[2*j] <data[2*j +1])  ) {
            m = 2*j + 1;

        } else {
            m = 2*j;
        }

        if( data[j] < data[m]) {
            swap(data[j],data[m]);
            j= m;
        } else {
            j = end;
        }
    }
}

void HeapSort(int data[], int n) { // data[1] ....data[n]
    if(data== NULL || n < 1)
        return;

    cout<<"restore: "<<endl;

    for(int  i = n /2; i > 0; -- i) {
        restore(data,i,n);
    }
    printData(data,10);
    cout<<"sort: "<<endl;

    for(int j= n; j > 1; j--) {
        swap(data[j],data[1]);
        restore(data,1,j-1);
    }
}

void merge(int data[], int temp[], int start1, int end1, int end2) {
    if(data== NULL || temp == NULL )
        return;

    int i = start1;
    int j = end1 +1;
    int k = start1;
    while( i <= end1 && j <= end2 ) {
        if(data[i] < data[j]) {
            temp[k++] = data[i++];
        } else {
            temp[k++] = data[j++];
        }
    }

    if( i > end1) {
        while( j <= end2) {
            temp[k++] = data[j++];
        }
    } else {
        while( i <= end1) {
            temp[k++] = data[i++];
        }
    }
}

void mpass(int data[], int temp[], int n , int length) {
    int j;
    for( j = 0 ; j < n - 2*length +1; j += 2*length) {
        merge(data,temp,j,j+length -1, j+2*length -1);
    }
    if( j + length -1 < n) {
        merge(data,temp, j , j+length -1, n-1);
    } else {
        int p = j;
        while( p < n) {
            temp[p++] = data[j++];
        }
    }
}

void MergeSort(int data[], int length) {
    int temp[length] ;

    for(int j =1; j < length; j *= 2) {
        mpass(data,temp,length, j);

        j*= 2;
        mpass(temp, data,length, j);
    }
}

bool sequenceFind(int data[], int length, int key) {
    bool result = false;
    for(int i = 0; i < length; ++i) {
        if( data[i] == key)
            return true;
    }

    return result;
}

bool binaryFind(int data[], int length , int key) {


    bool result = false;
    int start = 0;
    int end = length -1;

    while( start <=  end ) {
        int middle = (start + end )/2;

        if( key == data[middle]) {

            return true;
        }
        else if( key > data[middle])
        {
            start = middle +1;
        }
        else if( key < data[middle])
        {
            end = middle -1;
        }
    }



    return result;
}
int main() {
    cout << "Hello world!" << endl;

    int length = 10;
    int data[] = {23,5,1,2,42,32,67,24,79,14};
    printData(data,length);
    SSort(data,length);
    // BubbleSort(data, length);
    //ShellSort(data, length);
    //InsertSort(data, length);
    //QuickSort(data,length,0,9);
    //QuickSort_1(data,length,0,9);
    //MergeSort(data,10);


   // HeapSort(data,length-1);  // data[1] ....data[n]
    printData(data,length);

    cout <<sequenceFind(data,10,23)<<endl;

    cout <<binaryFind(data,10,22)<<endl;

    return 0;
}