插入、希尔、冒泡、快速、选择、堆、归并排序算法和性质

线上幽灵

已于 2022-08-03 09:12:05 修改

阅读量933

点赞数 1

分类专栏：面试题算法 C++ 文章标签：排序算法算法数据结构

于 2018-10-09 10:08:30 首次发布

本文链接：https://blog.csdn.net/chen134225/article/details/82978151

版权

C++ 同时被 3 个专栏收录

111 篇文章 9 订阅

订阅专栏

面试题

80 篇文章 7 订阅

订阅专栏

算法

40 篇文章 2 订阅

订阅专栏

一、插入排序

1、直接插入排序

void InsertSort(vector<int> &vec) {
  int length = vec.size();
  if (length < 2) {
    return;
  }
  for (int i = 1; i < length; ++i) {
    if (vec[i-1] <= vec[i]) {
      continue;
    }
    int j = i - 1;
    int tmp = vec[i];
    for (; j > -1 && tmp < vec[j]; --j) {
      vec[j+1] = vec[j];
    }
    vec[j+1] = tmp;
  }
}

2、希尔排序

void ShellSort(vector<int> &vec) {
  int length = vec.size();
  if (length < 2) {
    return;
  }
  for (int dk = length/2; dk > 0; dk /= 2) {
    for (int i = dk; i < len; ++i) {
      if (vec[i-dk] <= vec[i]) {
        continue;
      }
      int tmp = vec[i];
      int j = i - dk;
      for (; j > -1 && tmp < vec[j]; j -= dk) {
        vec[j+dk] = vec[j];
      }
      vec[j+dk] = tmp;
    }
  }
}

二、交换排序

1、冒泡排序

void BubbleSort(vector<int> &vec) {
  int length = vec.size();
  if (length < 2) {
    return;
  }
  for (int i = 0; i < length; ++i) {
    for (int j = length - 1; j > i; --j) {
      if (vec[j] < vec[j-1]) {
        swap(vec[j], vec[j-1]);
      }
    }
  }
}

2、快速排序

int Partition(vector<int> &vec, int low, int high) {
  int pivot = vec[low];
  while (low < high) {
    while (low < high && pivot <= vec[high]) --high;
    vec[low] = vec[high];
    while (low < high && pivot >= vec[low]) ++low;
    vec[high] = vec[low];
  }
  vec[low] = pivot;
  return low;
}

void QuickSort(vector<int> &vec, int low, int high) {
  if (low >= high) {
    return;
  }
  int pivotpos = Partition(vec, low, high);
  QuickSort(vec, low, pivotpos - 1);
  QuickSort(vec, pivotpos + 1, high);
}

三、选择排序

1、简单选择排序

void SelectSort(vector<int> &vec) {
  int length = vec.size();
  if (length < 2) {
    return;
  }
  for (int i = 0; i < length; ++i) {
    int min = vec[i];
    int index = i;
    for (int j = i + 1; j < length; ++j) {
      if (vec[j] >= min) {
        continue;
      }
      min = vec[j];
      index = j;
    }
    swap(vec[i], vec[index]);
  }
}

2、堆排序

void AdjustDown(vector<int> &vec, int k, int len) {
  int cur = vec[k];
  for (int i = 2*k+1; i <= len; i = 2*i+1) {
    if (i < len && vec[i] < vec[i+1]) {
      ++i;
    }
    if (cur >= vec[i]) {
      break;
    } else {
      vec[k] = vec[i];
      k = i;
    }
  }
  vec[k] = cur;
}

void BuildMaxHeap(vector<int> &vec, int len) {
  for (int i = len / 2; i > -1; --i) {
    AjustDown(vec, i, len);
  }
}

void HeapSort(vector<int> &vec) {
  int length = vec.size();
  if (length < 2) {
    return;
  }
  BuildMaxHeap(vec, length - 1);
  for (int i = length-1; i > -1; --i) {
    swap(vec[i], vec[0]);
    AdjustDown(vec, 0, i - 1);
  }
}

四、归并排序

1、二路归并排序

void Merge(vector<int> &vec, int low, int mid, int high) {
  vector<int> tmp_vec = vec;
  int i = low, j = mid + 1, k = low;
  while (i <= mid && j <= high) {
    if (tmp_vec[i] <= tmp_vec[j]) {
      vec[k++] = tmp_vec[i++];
    } else {
      vec[k++] = tmp_vec[j++];
    }
  }
  while (i <= mid) {
    vec[k++] = tmp_vec[i++];
  }
  while (j <= high) {
    vec[k++] = tmp_vec[j++];
  }
}

void MergeSort(vector<int> &vec, int low, int high) {
  if (low >= high) {
    return;
  }
  int mid = (low + high) / 2;
  MergeSort(vec, low, mid);
  MergeSort(vec, mid + 1, high);
  Merge(vec, low, mid, high);
}