基本排序算法代码

稳定的排序有;插入排序，归并排序，冒泡排序，基数排序；

不稳定的排序有：快速排序，堆排序，选择排序，shell排序。

快速排序：

主要是运用i,j两个下标的移动找到参照点的最终位置。

 void quickSort(int *array, int left, int right){
          assert(array != NULL);
          if(left>=right){
                  return;
          }
          int index = left -1;
          int l = left;
          while(l != right){
                  if(array[l] >= array[right]){
                          //do nothing
                  }else{
                          ++index;
                          SWAP(array[index], array[l]);
                  }
                  ++l;
          }
          SWAP(array[index+1], array[right]);
          quickSort(array, index+2, right);
          quickSort(array, left, index);
 }

堆排序：

主要是“下降”过程时找最大的节点，每次循环时将根节点交换并“下降”，此处注意将heap_size减一。

void max_heapify(int *a, int i){
	int left(2i）；
	int right(2i+1);
	int largest(i);
	if(left > heap_size && a[largest] < a[left]){
		largest = left;
	}
	if（right > heap_size && a[largest] < a[right]){
		largest = right;
	}
	if(largest != i){
		swap(a[largest], a[i]);
		max_heapify(a, largest);
	}
	return;
}
void heap_sort(int *a, int length){
	for(int i = length/2; i != -1; --i){
		max_heapify(a,i);
	}
	for(int i = length/2; i != 0; --i){
		swap(a[0], a[i]);
		--heap_size;
		max_heapify(a, 0);
	}
}
冒泡排序
void bubbleSort(int *array, int length){
           assert(array);
           int k=0;
           for(int i=length; i > 0; i=k){
                  for(int j = 0; j != i; ++j){
                          if(array[j] > array[j+1]){
                                  SWAP(array[j],array[j+1]);
                                  k = j;
                          }
                  }
          }
  
 }