排序

##冒泡排序##

思路：將相鄰的兩個數比較，將較小的數調到前頭；有n個數就要進行n-1趟比較，第一次比較中要進行n-1次兩兩比較，在第j趟比較中，要進行n-j次兩兩比較

####c語言實現####

<!-- lang: python -->

void bubble(int arry[], int count){
    int i, j, temp;
    
    for(i = 0; i < count-1; i++){ //比較n-1次
            for(j = 0; j < count-i-1; j++){
                if (arry[j] > arry[j+1]){ // 把值較大的數沉底
                        temp = arry[j];
                        arry[j] = arry[j+1];
                        arry[j+1] = temp;
                }
        }      
    }
}

void bubble_sort(int *a, int n)
{
int i, j, temp, k;
int flag;

for (i = 0; i < n; i++)
{   
    flag = 0;
    for (j = i + 1; j < n; j++)
    {   
        if (a[i] > a[j])
        {   
            flag = 1;
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }   
    }   
    for (k = 0; k < n; k++)
        printf("%d, ", a[k]);
    printf("flag=%d \n", flag);
    if (flag == 0)
        break;
    }   
}

####python實現#### <!-- lang: python --> def bubble(alist): for i in range(len(alist)-1): for j in range(len(alist)-i-1): if alist[j] > alist[j+1]: alist[j], alist[j+1] = alist[j+1], alist[j]

##插入排序##

思路：在獲得要排序的數組之後，講數組分爲兩個部分，數組的第一個元素爲一個部分，剩下的元素爲一部分，而後從數組的第二個元素開始，和該元素之前的全部元素比較，若是以前的元素沒有比該元素大的，那麼該元素的位置不變，若是有元素的值比該元素大，那麼記錄他所在的位置；＊該算法利用該元素前面是排好順序的＊

####c語言實現####

<!-- lang: python -->

void insert_sort(int arry[], int count){
    int i, j, k;

    for(i = 1; i < count; i++){
        k = arry[i];
        for(j = i; j > 0 && arry[j-1] > k; j--){
            arry[j] = arry[j-1];
        }
        arry[j] = k;
    }
}

####python實現####

<!-- lang: python -->

def insert_sort(alist):
    for i in range(1, len(alist)):
        k = alist[i]
        j = i
        while j > 0 and alist[j-1] > k:
            alist[j] = alist[j-1]
            j -= 1

        alist[j] = k

##快速排序##

思路：以第一個數爲基準（key），先從high（數組末端）開始往回循環， 當找到比key小的交換， 而後從low（數組開始）循環， 找到比能夠大的交換， 這是一次循環
而後在遞歸調用能夠的左邊和右邊

####c語言實現####

<!-- lang: python -->

void qsort(int *a, int left,u int right)
{
    int low = left;
    int high = right;
    int key = a[left];

    if (low >= high)return;
    while(low < high){
        while(low < high && a[high] > key)high--;
        if (low < high){
           a[low] = a[high];
           low++
        }
        while(low < high && a[low] < key)low++;
        if (low < high){
            a[high] = a[low];
            high--;
        }
    }
    a[low] = key;
    qsort(a, left, low-1);
    qsort(a, low+1, right);
}

####python實現####

<!-- lang: python -->

def quicksort(alist, left, right):
    if left >= right:
        return
    low, high = left, right
    key = alist[(left+right)//2]

    while 1:
        while alist[low] < key:low += 1
        while alist[high] > key:high -= 1

        if high <= low or alist[low] == alist[high]:
            break
        alist[low], alist[high] = alist[high], alist[low]
        print alist, low, high, key 

    quicksort(alist, left, low-1)
    quicksort(alist, high+1, right)

if __name__ == '__main__':
    alist = [0, 0, -1, 0, 2]
    print alist
    quicksort(alist, 0, len(alist)-1)
    #bubble_sort(alist)
    print alist

def qsort(L):
    if len(L) <=1 : 
        return L
    return qsort([lt for lt in L[1:] if lt < L[0]]) + L[0:1] + qsort([ge for ge in L[1:] if ge >= L[0]])