1.冒泡排序

算法原理：相邻的数据进行两两比较，小数放在前面，大数放在后面，这样一趟下来，最小的数就被排在了第一位，第二趟也是如此，如此类推，
直到所有的数据排序完成

void bubble_sort(int arr[], int len)  
{  
      for (int i = 0; i < len - 1; i++)  
      {  
          for (int j = len - 1; j >= i; j--)  
          {  
              if (arr[j] < arr[j - 1])  
              {  
                  int temp = arr[j];  
                  arr[j] = arr[j - 1];  
                  arr[j - 1] = temp;  
              }  
          }  
      }  
}  

2.选择排序   
算法原理：
先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

void select_sort(int arr[], int len)  
  {  
      for (int i = 0; i < len; i++)  
      {  
          int k = i;  
          for (int j = i + 1; j < len; j++)  
          {  
              if (arr[j] < arr[k])  
                  k = j;  
          }  
          if (k != i)  
          {  
              int temp = arr[i];  
              arr[i] = arr[k];  
              arr[k] = temp;   
          }  
      }  
  }  

插入排序 

将数据分为两部分，有序部分与无序部分，一开始有序部分包含第1个元素，依次将无序的元素插入到有序部分，直到所有元素有序。插入排序又分为直接插入排序、二分插入排序、链表插入等，这里只讨论直接插入排序。它是稳定的排序算法，时间复杂度为O(n^2)

void insert_sort(int arr[], int len)  
  {  
      for (int i = 1; i < len; i ++)  
      {  
          int j = i - 1;  
          int tmp = arr[i];  
          while (j > -1 && tmp  < arr[j] )  
          {  
              arr[j + 1] = arr[j];  
              j --;  
          }  
          arr[j + 1] = tmp ;  
      }  
  }  

快速排序 

快速排序是目前在实践中非常高效的一种排序算法，它不是稳定的排序算法，平均时间复杂度为O(nlogn)，最差情况下复杂度为O(n^2)。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

 int partition(int arr[], int left, int right)
{
      int i = left, j = right, tmp = arr[left];  
      while (i < j)  
      {  
          while (i < j && arr[j] > tmp)  
              j--;  
          if (i < j)  
              arr[i++] = arr[j];  
  
          while (i < j && arr[i] < tmp)  
              i++;  
          if (i < j)  
              arr[j] = arr[i];  
      }  
      arr[i] = tmp;  
      return i;
}


void quick_sort(int arr[], int left, int right)  
{  
      if(left<right)
      {
	int pos = partition(arr,left,right);
	quick_sort(arr, left, pos - 1);  
      	quick_sort(arr, pos + 1, right); 
      }
  }  
}  

**使用栈的非递归快速排序**/
void quicksort2(int *arr,int left,int right)
{
    stack<int> s;

    if(left<right)
    {
         s.push(left);
         s.push(right);
    }
        
        while(!s.empty())
    {
            int r=st.top();
            st.pop();
            int l=st.top();
            st.pop();
            pos=partition(arr,l,r);
            if(l<pos-1){
                st.push(l);
                st.push(pos-1);
            }
            if(pos+1<r){
                st.push(pos+1);
                st.push(r);
            }      
        }
    }
}

归并排序

/*归并排序*/
void merge(int *arr, int *brr, int left, int mid, int right)  
{  
	int i = left,j = mid+1;
	int k = 0;  

	while (i < mid + 1 && j < right + 1)  
	{  
	  if (arr[i] > arr[j])  
		  brr[k++] = arr[j++];  
	  else  
		  brr[k++] = arr[i++];  
	}  
	while (i < mid + 1)   
	  brr[k++] = arr[i++];  
	 
	while (j <right + 1)  
	  brr[k++] = arr[j++];  

	for (i = 0, j = left; j < right + 1; ++i,++j)  
	arr[j] = brr[i];  
}  

void merge_sort(int *arr, int *brr, int left, int right)  
{  
	if(left<right)
	{
		int mid = (left+right)/2;
		merge_sort(arr,brr,left,mid);
		merge_sort(arr,brr,mid+1,right);
		merge(arr,brr,left,mid,right);
	}
}