排序 - 台部落

排序

原創

2020-02-22 12:28

冒泡排序：內層爲j-i-1

void bubleSort(int data[], int n)
{
    int i,j,temp;
    //兩個for循環，每次取出一個元素跟數組的其他元素比較
    //將最大的元素排到最後。
    for(j=0; j<n-1; j++)
    {
        //外循環一次，就排好一個數，並放在後面，
        //所以比較前面n-j-1個元素即可
        for(i=0; i<n-j-1; i++)
        {
            if(data[i]>data[i+1])
            {
                temp = data[i];
                data[i] = data[i+1];
                data[i+1] = temp;
            }
        }
    }
}

選擇排序：用i循環size次，內循環先找到最小的元素，與i進行交換

void selectSort(int data[], int n)
{
    int i,j,mix,temp;
    //每次循環數組，找出最小的元素，放在前面，前面的即爲排序好的
    for(i=0; i<n-1; i++)
    {
        //假設最小元素的下標
        int mix = i;
        //將上面假設的最小元素與數組比較，交換出最小的元素的下標
        for(j=i+1; j<n; j++)
        {
            if(data[j] < data[mix])
            {
                mix = j;
            }
        }
        //若數組中真的有比假設的元素還小，就交換
        if(i != mix)
        {
            temp = data[i];
            data[i] = data[mix];
            data[mix] = temp;
        }
    }
}

插入排序：把一個序列看成有序和無序兩個，每次從無序序列中找到第一個元素插入有序序列應該插入的位置，插入後依次往後挪動

void bInsertSort(int data[], int n)
{
    int low,high,mid;
    int temp,i,j;
    for(i=1; i<n; i++)
    {
        low = 0;
        //把data[i]元素插入到它的前面data[0-(i-1)]中
        temp =data[i];
        high = i-1;
        //該while是折半，縮小data[i]的範圍(優化手段)
        while(low <= high)
        {
            mid = (low+high)/2;
            if(data[mid] > temp)
            {
                high = mid-1;
            }
            else
            {
                low = mid+1;
            }
        }
        int j = i;
        //讓data與已經排序好的數組的各個元素比較，小的放前面
        while((j > low) && data[j-1] > temp)
        {
            data[j] = data[j-1];
            --j;
        }
        data[low] = temp;
    }
}

快速排序：一次交換找到三個元素，基元素 a，從後往前數小於基元素 b，從前往後數大於基元素 c，交換順序是這樣的：b->a,c->b,a->c當然a提前會有備份，然後返回a的位置(即原本c的位置)，這樣a前小於a，a後大於a，注意b->a,c->b實在循環裏的，意味可能會在同一次調用中交換多次

int findPos(int data[], int low, int high)
{
    //將大於t的元素趕到t的左邊，大於t的元素趕到t的右邊
    int t = data[low];
    while(low < high)
    {
        while(low < high && data[high] >= t)
        {
            high--;
        }
        data[low] = data[high];
        while(low < high && data[low] <=t)
        {
            low++;
        }
        data[high] = data[low];
    }
    data[low] = t;
    //返回此時t在數組中的位置
    return low;
}
//在數組中找一個元素，對大於該元素和小於該元素的兩個數組進行再排序
//再對兩個數組分爲4個數組，再排序，直到最後每組只剩下一個元素爲止
void quickSort(int data[], int low, int high)
{
    if(low > high)
    {
        return;
    }
    int pos = findPos(data, low, high);
    quickSort(data, low, pos-1);
    quickSort(data, pos+1, high);
}

堆排序：關鍵在堆調整上，以數組儲存卻要以樹的結構來思

void swap(int *a,int i,int len)
{
	int temp = a[i];
	a[i]=a[len];
	a[len]=temp;
	//printf("from %d to %d \n",i,len); 
}
void HeapAdjust(int *arr,int i,int len)
{
	   int left,right,j ;
    while((left = 2*i+1) <= len){    //判斷當前父節點有無左節點（即有無孩子節點，left爲左節點）
        right = left + 1;  //右節點
        j = left;   //j"指針指向左節點"
        if(j < len && arr[left] < arr[right])    //右節點大於左節點
            j ++;     //當前把"指針"指向右節點
        if(arr[i] < arr[j])    //將父節點與孩子節點交換（如果上面if爲真，則arr[j]爲右節點，如果爲假arr[j]則爲左節點）
            swap(arr,i,j);
        else         //說明比孩子節點都大，直接跳出循環語句
            break;
        i = j;
    }
}

void HeapSort(int *a)
{
	int len = -2;
	for(int i = 0 ; a[i]!= '\0';i++)
		len++;

	for(int i = len/2-1;i>=0;i--)
		HeapAdjust(a,i,len);
//	printf("\n**************\n");
	while(len>=0)
	{
		swap(a,0,len);
		len--;
		HeapAdjust(a,0,len);
	}
}