---
# System prepended metadata

title: '**排序演算法簡明運動**'

---

# **排序演算法簡明運動**

## Bubble sort 氣泡排序
```c
void bubble_sort(int nums[], unsigned int pass)
{
    for (pass = 1; pass < 10 ; pass++)
    {
        for (size_t i = 0; i < 10 - pass; i++)
        {                     
            if (nums[i] > nums[i + 1])
	    {                        
                int temp = nums[i];                 
                nums[i] = nums[i + 1];                      
                nums[i + 1] = temp;                      
            }                   
         }            
     }
}
```
### 修改說明
* 將 bubblesort 單獨拉出作為函式使用
* a[i] 更改為更直覺的 nums[i]
* hold 更改為個人較為熟悉之 temp
### Leetcode結果
![](https://i.imgur.com/xwzBUWe.png)

## Selection sort 選擇排序
```c=
void selectionSort(int array[], int array_size)
{
    int i, nums, min;

    for (i = 0; i < array_size - 1; i++)
    {
	min = i;
		
	for (nums = i + 1; nums < array_size; nums++)
	{
	    if (array[nums] < array[min])
            {
		min = nums;
            }
	}
		
	swap(&array[min], &array[i]);
    }
}

void printArray(int array[], int size)
{
	int i;
	
	for (i = 0; i < size; i++)
	{
		printf("%d", array[i]);
		
		if(i < size - 1)
                {
      		    printf(" ");
	  	}
	}
	
	printf("\n");
}
```
### 修改說明
* j, min_idx 分別更改為 nums, min
* arr[i] 更改為個人較熟悉之 array[i]
* 更改函式 printArray 內容為最後一數後不列印空格
### Leetcode結果
![](https://i.imgur.com/PJ6RRNL.png)

## Insertion sort 插入排序
```c=
void insertionSort(int array[], int array_size)
{
    int i, lock, comparison;
    for (i = 1; i < array_size; i++)
    {
	lock = array[i];
	comparison = i - 1;

	while (comparison >= 0 && array[comparison] > lock)
	{
	    array[comparison + 1] = array[comparison];
	    comparison = comparison - 1;
        }
	array[comparison + 1] = lock;
    }
}

void printArray(int array[], int array_size)
{
    int i;
	
    for (i = 0; i < array_size; i++)
    {
        printf("%d", array[i]);
		
        if(i < array_size - 1)
      	{
            printf(" ");
	}
     }
     printf("\n");
}
```
### 修改說明
* key, j 分別更改為 lock, comparison
* arr[i], n 更改為個人較熟悉之 array[i], array_size
* 更改函式 printArray 內容為最後一數後不列印空格
### Leetcode結果
![](https://i.imgur.com/zjT6pVw.png)
## Quick sort 快速排序
```c=
int partition (int array[], int low, int high)
{ 
    int datum = array[high];
    int i = (low - 1);
    int num = 0;
    
    for (num = low; num <= high - 1; num++)
    {
        if (array[num] < datum)
        {
            i++;
            swap(&array[i], &array[num]);
        }
    }
    swap(&array[i + 1], &array[high]);
    
    return (i + 1);
}

void quickSort(int array[], int low, int high) 
{ 
    if (low < high)
    {
        int pi = partition(array, low, high);
        
        quickSort(array, low, pi - 1); 
        quickSort(array, pi + 1, high); 
    }
}

void printArray(int array[], int array_size)
{
    int i;
    
    for (i = 0; i < array_size; i++)
    {
    	printf("%d", array[i]);
    	
    	if(i < array_size - 1)
      	{
      	    printf(" ");
	}
    }
    printf("\n");
}
```
### 修改說明
* pivot, j 分別更改為 datum, num
* arr[i], n 更改為個人較熟悉之 array[i], array_size
* 更改函式 printArray 內容為最後一數後不列印空格
### Leetcode結果
![](https://i.imgur.com/iS2aGNA.png)