所有常用簡單排序算法的c++代碼

快速排序：

void QuickSort(int s[], int l, int r)  
{  
    if (l< r)  
    {        
        int i = l, j = r, x = s[l];  
        while (i < j)  
        {  
            while(i < j && s[j]>= x) // 從右向左找第一個小於x的數  
                j--;   
            if(i < j)  
              s[i++] = s[j];  
            while(i < j && s[i]< x) // 從左向右找第一個大於等於x的數  
                i++;   
            if(i < j)  
                s[j--] = s[i];  
        }  
        s[i] = x;  
        quickSort(s, l, i - 1); // 遞歸調用  
        quickSort(s, i + 1, r);  
    }  
}  

 

選擇排序：

void SelectSort(int s[], int n)  
{  
    int i,j,k;  
    for (i=0; i < n-1; i++)  
    {  
        k = i; 
        for (j=i+1; j < n; j++)  
        {  
            if (a[j] < a[k]) k = j;  
        }  
        if (k != i) swap(s[k],s[i]);
    }
}  

 

冒泡排序：

void BubbleSort(int s[], int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n - i - 1; j++)
        {
            if (s[j] > s[j + 1])
            {
                swap(s[j], s[j + 1]);
            }
        }
    }
}

 

希爾排序：

void ShellSort(int s[], int n)  
{  
    int gap; //gap爲增量，爲任意小於n的數
    for(gap = 3; gap >0; gap--)  
    {  
        for(int i=0; i<gap; i++)  //分成gap組
        {  
            for(int j = i+gap; j<n; j=j+gap)  //每組進行插入排序（gap=1即爲普通插入排序）
            {  
                int temp = s[j], k = j-gap;  
                while(k>=0&&s[k]>temp)  
                {  
                    s[k+gap] = s[k];  
                    k = k-gap;  
                }  
                s[k+gap] = temp;  
            }  
        }  
    }  
}  

 

插入排序：

void InsertSort(int s[], int n)
{
    for (int i = 1; i < n; i++) //默認第一個元素已經是有序的，因此從第二個元素開始
    {
        int j = i-1,temp=s[i];
        while (j >=0&&s[j] > temp) //前一個元素比待插元素大
        {
            s[j+1] = s[j]; //如果待插入元素比拍好元素大，則循環右移大的那部分元素
            //留出位置給待插元素
            j--;
        }
        s[j+1] = temp; //插入元素
    }
}

 

歸併排序：

/*該函數將數組下標範圍[l1,r1]和[l2,r2]的有序序列合併成一個有序序列*/  
void merge(int nums[], int l1, int r1, int l2, int r2 ) {  
    int i = l1;                                           //左半部分起始位置  
    int j = l2;                                           //右半部分起始位置  
    int n = (r1 - l1 + 1) + (r2 - l2 + 1);                //要合併的元素個數  
    vector<int> temp(n);                                  //輔助數組  
    int k = 0;                                            //輔助數組其起始位置  
    while (i <= r1&&j <= r2) {                           //挑選兩部分中最小的元素放入輔助數組中  
        if (nums[i] < nums[j])  
            temp[k++] = nums[i++];  
        else  
            temp[k++] = nums[j++];  
    }  
    //如果還有剩餘，直接放入到輔助數組中  
    while (i <= r1)  
        temp[k++] = nums[i++];  
    while (j <= r2)  
        temp[k++] = nums[j++];  
    //更新原始數組元素  
    for (int i = 0; i < n;i++)  
    {  
        nums[l1 + i] = temp[i];  
    }  
}  
 
/*二路歸併排序（遞歸實現）*/  
void MergeSort(int nums[],int start, int end) {  
    if (start < end) {  
        int mid = (start + end)/2;               //分割序列  
        MergeSort(nums, start, mid);                //對序列左半部分進行歸併排序  
        MergeSort(nums, mid + 1, end);              //對序列右半部分進行歸併排序  
        merge(nums, start, mid, mid + 1, end);      //合併已經有序的兩個序列  
    }  
}  

 

堆排序：

void adjust(int arr[], int len, int index)
{
	int left = 2 * index + 1;
	int right = 2 * index + 2;
	int maxIdx = index;
	if (left<len && arr[left] > arr[maxIdx]) maxIdx = left;
	if (right<len && arr[right] > arr[maxIdx]) maxIdx = right;  // maxIdx是3個數中最大數的下標
	if (maxIdx != index)                 // 如果maxIdx的值有更新
	{
		swap(arr[maxIdx], arr[index]);    
                adjust(arr, len, maxIdx);// 遞歸調整其他不滿足堆性質的部分
	}
}
void heapSort(int arr[], int size)
{
	for (int i = size / 2 - 1; i >= 0; i--)  // 對每一個非葉結點進行堆調整(從最後一個非葉結點開始)
	{
		adjust(arr, size, i);
	}
	for (int i = size - 1; i >= 1; i--)
	{
		swap(arr[0], arr[i]);           // 將當前最大的放置到數組末尾
		adjust(arr, i, 0);              // 將未完成排序的部分繼續進行堆排序
	}
}