C++排序

冒泡排序：效率 O（n²）,适用于排序小列表。

void bubble_sort(int value[], int length) 
{ 

    int temp; 
    for(int i = 1; i < length ; i++) 
    { 
      for(int j = 0; j< length - i; j++) 
      { 
          if (value[j] > value[j+1]) 
         { 
             temp = value[j]; 
             value[j] = value[j + 1]; 
             value[j+1] = temp; 
        } 
 
     } 
  
    } 

}

 

快速排序：平均效率O（nlogn），适用于排序大列表。

template<typename T>
void quicksort(vector<T>& vin, int left, int right)
{
 if(left < right)
 {
  T temp = vin[left];
  int i = left, j = right;
  while(i < j)
  {
   while(i < j && vin[j] >= temp)
   {
    j--;
   }

   if(i < j)
   {
    vin[i++] = vin[j];
   }

   while(i < j && vin[i] < temp)
   {
    i++;
   }
   if(i < j)
   {
    vin[j--] = vin[i];
   }
  }
  vin[i] = temp;
  quicksort(vin, left, i - 1);
  quicksort(vin, i + 1, right); 
 }

}

 

插入排序：最佳效率O（n）；最糟效率O（n²）与冒泡、选择相同，适用于排序小列表

template<typename T>
void insertsort(vector<T>& va, int left, int right)
{
 int j;
 for(int p = 1; p <= right; p++)
 {
  T temp = va[p];
  for(j = p; j > 0 && va[j - 1] > temp; j--)
  {
   va[j] = va[j - 1]; 
  }
  va[j] = temp;
 }
}

 

选择排序：效率O（n²），适用于排序小的列表。

template<typename T>
void SelectSortArray(vector<T>& arr, int n)
{
    int min_index;
    for(int i=0;i<n-1;i++)
    {
         min_index=i;
         for(int j=i+1;j<n;j++)//每次扫描选择最小项
            if(arr[j]<arr[min_index])  min_index=j;
         if(min_index!=i)//找到最小项交换，即将这一项移到列表中的正确位置
         {
             T temp;
             temp=arr[i];  arr[i]=arr[min_index];  arr[min_index]=temp;
}
}
}

 

堆排序：堆排序的最坏时间复杂度为O(nlgn)

void adjust_heap(int* heap, int low, int high)
{
    assert(heap);

#if 1    // 循环实现

    int i = low;
    int j = 2 * i;
    int temp = heap[i];

    while (j <= high) {
        // 若有两个孩子，j 为孩子中大的那个的下标
        if (j < high && heap[j] < heap[j + 1]) {
            j = j + 1;
        }

        // 已是堆
        if (temp >= heap[j]) {
            break;
        }

        // 继续筛选
        else {
            heap[i] = heap[j];
            i = j;
            j = 2 * i;
        }
    }

    heap[i] = temp;

#else    // 递归实现

    int i = low;
    int j = 2 * i;
    int temp = heap[i];

    if (j >= high) {
        return;
    }

    // 若有两个孩子，j 为孩子中大的那个的下标
    if (j < high && heap[j + 1] > heap[j]) {
        j = j + 1;
    }

    // 已经为堆，无需调整
    if (heap[low] >= heap[j]) {
        return;
    }

    heap[i] = heap[j];
    heap[j] = temp;

    // 调整之后，[j, high] 可能不满足堆了，需继续调整
    adjust_heap(heap, j, high);

#endif
}

// 只有一个结点的树是堆，而在完全二叉树中，所有序号 i > n/2 的结点都是叶子，
// 因此以这些结点为根的子树均已是堆。这样，我们只需依次将以序号为
// n/2, n/2 - 1, …, 0 的结点作为根的子树都调整为堆即可。
void build_heap(int* heap, int length)
{
    assert(heap && length >= 0);

    int i;

    for(i = length / 2; i >= 0; --i) {
        adjust_heap(heap, i, length - 1);
    }
}

// 堆排序
//
void heap_sort(int* array, int length)
{
    assert(array && length >= 0);

    if (length <= 1) {
        return;
    }

    int i, temp;

    // 将 [0, length - 1] 建成初始堆
    build_heap(array, length);

    // 对当前无序区 [0, i - 1] 进行堆排序，共做 length - 1 趟。
    for(i = length - 1; i > 0; --i) {
        // 将堆顶和堆中最后一个记录交换
        temp = array[0];
        array[0] = array[i];
        array[i]= temp;

        // 将 [0, i - 1] 重新调整为堆，仅有 [0] 可能违反堆性质
        adjust_heap(array, 0, i - 1);
    }
}

 

 

int main()

{

 vector<int> iv;
 iv.push_back(32);
 iv.push_back(54);
 iv.push_back(23);
 iv.push_back(85);
 iv.push_back(78);
 iv.push_back(40);
 iv.push_back(61);
 iv.push_back(12);
 for(int i = 0; i < iv.size(); i++)
 {
  cout<<iv[i]<<" ";
 }
 cout<<endl;
// quicksort(iv, 0, 7);
 SelectSortArray(iv, 8);
// insertsort(iv, 0, 7);
 for(int i = 0; i < iv.size(); i++)
 {
  cout<<iv[i]<<" ";
 }
 cout<<endl;

  return 0;

}