基本排序算法c++

 

冒泡排序 
基本思想：兩兩比較待排序的數，發現反序時交換，直到沒有反序為止。
public static void BubbleSort(int[] R)
{
    for (int i = 0; i < R.Length - 1; i++)
    {
        bool noswap = true;
        for (int j = 0; j < R.Length - 1-i; j++)
        {
            if (R[j] > R[j + 1])
            {
                int temp = R[j];
                R[j] = R[j + 1];
                R[j + 1] = temp;
                noswap = false;
            }
        }
        if (noswap)
        {
            break;
        }
    }
}

快速排序 
基本思想：在待排序數列中任選出一個數作為基准，用這個基准將數列划分為左右兩個子區，使得左子區的數都不大於基准數，而右子區的數都不小於基准數,稱為完成第一次划分。如果左子區或右子區不為空，則對它進行同樣的划分，直至為空為止。 
public static void QUICKSORT(int[] N,int left,int right)
{
    //數組元素如果不大於一個就無需排序。
    if (left < right)
    {
        int p = PARTITION(N, left, right);  //第一次划分
        QUICKSORT(N, left, p-1);    //遞歸處理左子區
        QUICKSORT(N, p+1, right);   //遞歸處理右子區
    }     
}
//划分
public static int PARTITION(int[] R, int left,int right)
{
    int i = left;
    int j = right;
    int temp = R[i];
    while (i != j)
    {
        //從左往右掃描，查找第一個比基准數小的數
        while ((R[j] >= temp) && (i<j))
        { 
            j--; 
        }
        if (i < j)                
        { 
            //交換找到的數和基准數，由於基准數還需交換多次，所以暫時不用將temp->R[j]
            R[i] = R[j];
            i++;
        }

        while ((R[i] <= temp) && (i < j))
        { 
            i++; 
        }
        if (i< j)
        { 
            R[j] = R[i];
            j--;
        }
    }
    //定位基准數
    R[i] = temp;
    return i;    
}

直接選擇排序 
基本思想：每次從無序數組中選出一個最小的出來，放到已排好序的數組的最后。
public static void SELECTSORT(int[] R)
{   
    for (int i = 0; i < R.Length-1; i++)
    {
        int index = i;
        for (int j = i + 1; j < R.Length; j++)
        {
            if (R[j] < R[index])
            {
                index = j;
            }
        }
        //交換R[i]和R[index]
         if (index != i)
        {
            int t = R[i]; R[i] = R[index]; R[index] = t;
        }
    }    
}

插入排序 
基本思想：首先將數組的第一個數sortArray[0]看成是有序的，然后從第二個元素開始和它前面的元素進行比較，如果比前面的某一個數大，就交換。由於前面的元素是有序的，所以就使有序元素的個數逐漸增大，直到等於n。
public void Sort(int[] sortArray)
{
    int j = 0;
    int key = 0;   // key為哨兵 
    for (int i = 1; i < sortArray.Length; i++)     //[0..i-1]已經排好的有序列 
    {
        if (sortArray[i] < sortArray[i - 1])
        {
            key = sortArray[i];
            j = i - 1;
            while (j >= 0 && key < sortArray[j]) //當sortArray[i] ≥sortArray[j] 時終止 
            { 
                sortArray[j + 1] = sortArray[j];
                j--;
            }     
            sortArray[j + 1] = key;  //插入到j的后面 
        } 
    } 
}

希爾排序 
基本思想：通過一個逐漸減小的增量使一個數組逐漸趨近於有序從而達到排序的目的。
public void SortShell(int [] list)
 {
     int i;
     for(i=1;i<=list.Length/9;i=3*i+1);
     for(;i>0;i/=3)
     {
         for(int i=i+1;i<=list.Length;i+=inc)
        {
            int t=list[i-1];
            int j=i;
            while((j>inc)&&(list[j-inc-1]>t))
            {
                list[j-1]=list[j-inc-1];
                j-=inc;
            } 
            list[j-1]=t;
        } 
    } 
}

堆排序 
基本思想：記錄區的分為無序區和有序區前后兩部分；用無序區的數建大根堆，得到的根（最大的數）和無序區的最后一個數交換，也就是將該根歸入有序區的最前端；如此重復下去，直至有序區擴展至整個記錄區。

堆排序步驟：
第一步，根據初始輸入數據，利用堆的調整算法形成初始堆。
第二步，通過一系列的記錄交換和重新調整堆進行排序。
最大堆的向下調整算法：
調用了O(n)次Adjust()算法，堆排序的時間復雜性為O(nlog2n)。
該算法的附加存儲主要是執行記錄交換時所用的一個臨時記錄。
因此，該算法的空間復雜性為O(1)。
堆排序是一個不穩定的排序方法。
 
#include <stdio.h>
void swap(int &x, int &y)
{
    int temp = x;
    x = y;
    y = temp;
}
void Adjust(int *a, int parent, int high)
{
    int l = 2 * parent + 1;
    int r = l + 1;
    int flag = parent;
 
    if (l<=high && a[l]>a[flag]) 
    {
        flag = l;
    }
    if (r<=high && a[r]>a[flag]) 
    {
        flag = r;
    }
    if (flag != parent)
    {
        swap(a[parent], a[flag]);
        Adjust(a, flag, high);
    }
} 
void HeapSort(int *a, int n)
{
    int i;
 
    for (i=n-1; i>=0; i--) 
    {
        Adjust(a, i, n - 1);
    }
    for (i=n-1; i>=0; i--) 
    {
        swap(a[0], a[i]);
        Adjust(a, 0, i - 1);
    }
}
void Output(int *a, int n)
{
    int i;
    for (i=0; i<n; i++) 
    {
        printf("\t%d", a[i]);
    }
    printf("\n");
}
int main()
{
    int a[] = { 49, 38, 65, 97, 76, 13, 27, 49 };
    int n = 8;
 
    Output(a, n);
    HeapSort(a, n);
    Output(a, n);
 
    return 0;
}
 
/*
        49      38      65      97      76      13      27      49
        13      27      38      49      49      65      76      97
*/