数据结构算法-排序算法

排序算法

直接插入排序

算法描述

• 1、从第一个元素开始，默认首元素已排序
• 2、取出下一元素，在已排序的元素序列中从后向前比较
• 3、若已排序元素大于该元素，则将已排序元素与该元素交换位置或向后移动一位
• 4、重复步骤3，直到找到已排序元素小于或者等于该元素的位置
• 5、将该元素插入到该位置后
• 6、重复步骤2-5

代码实现

• public static void sort(int[] a) {
  for (int i = 0; i < a.length - 1; i++) {
  for (int j = i + 1; j > 0; j–) {
  if (a[j] < a[j - 1]) {
  int temp = a[j];
  a[j] = a[j - 1];
  a[j - 1] = temp;
  }
  }
  }
  }
• public static void sort2(int[] a) {
  for (int i = 1; i < a.length; i++) {
  int num = a[i];
  int j;
  for (j = i; j > 0 && num < a[j - 1]; j–) {
  a[j] = a[j - 1];
  }
  a[j] = num;
  }
  }

希尔排序

算法描述

• 将待排序列根据所选步长分组后利用直接插入排序的方法进行排序；每次再将步长折半减小，循环上述操作；当步长为1时，利用直接插入排序完成最终排序；

  当步长为3时，将待排序列分为
  0、3、6、9…
  1、4、7、10…
  2、5、8、11…
  三个序列

• 1、选择一个步长，一般步长取值是待排数组长度的一半

• 2、根据所选的步长k，对序列进行k趟排序，完成后k折半减小

• 3、循环步骤2，直到步长为1时，进行一次直接插入排序完成最终排序

代码实现

• public static void sort(int[] a) {
  int length = a.length;
  int h = 1;
  while (h < length / 3) h = 3 * h + 1;
  for (; h >= 1; h /= 3) {
  for (int i = 0; i < a.length - h; i += h) {
  for (int j = i + h; j > 0; j -= h) {
  if (a[j] < a[j - h]) {
  int temp = a[j];
  a[j] = a[j - h];
  a[j - h] = temp;
  }
  }
  }
  }
  }

简单选择排序

算法描述

• 1、从未排序的序列中，找到关键字最小（最大）的元素
• 2、如果该元素不是未排序序列的第一个元素，则将其与未排序序列的第一个元素交换位置
• 3、重复1、2步骤，排序结束

代码实现

• public static void sort(int[] a) {
  for (int i = 0; i < a.length; i++) {
  int min = i;
  //选出之后待排序中值最小的位置
  for (int j = i + 1; j < a.length; j++) {
  if (a[j] < a[min]) {
  min = j;
  }
  }
  //最小值不等于当前值时进行交换
  if (min != i) {
  int temp = a[i];
  a[i] = a[min];
  a[min] = temp;
  }
  }
  }

堆排序

算法描述

• 将待排序列构造成一个堆，选出堆中最大的与堆中无序区的最后一个记录交换位置
• 1、先将初始序列构建成一个大顶堆，此时堆顶元素最大，此堆为初始的无序区
• 2、再将关键字最大的与无序区的最后一个记录交换，由此得到除去已交换位置的新的无序区
• 3、将新得到的无序区调整为堆后重复步骤2，直到无序区只有一个元素时排序完成

代码实现

• public static void sort(int[] a) {
  for (int i = a.length - 1; i > 0; i–) {
  max_heapify(a, i);
  //堆顶元素(第一个元素)与Kn交换
  int temp = a[0];
  a[0] = a[i];
  a[i] = temp;
  }
  }
  public static void max_heapify(int[] a, int n) {
  int child;
  for (int i = (n - 1) / 2; i >= 0; i–) {
  //左子节点位置
  child = 2 * i + 1;
  //右子节点存在且大于左子节点，child变成右子节点
  if (child != n && a[child] < a[child + 1]) {
  child++;
  }
  //交换父节点与左右子节点中的最大值
  if (a[i] < a[child]) {
  int temp = a[i];
  a[i] = a[child];
  a[child] = temp;
  }
  }
  }

冒泡排序

算法描述

• 1、比较相邻的两个元素，如果第一个比第二个大，则交换位置；如果第二个比第一个大，则使用第二个向后比较
• 2、步骤1完成后，最后的元素会是最大的数，对剩下的元素重复步骤1
• 3、重复上述步骤到最后没有任何一对数字需要比较，排序完成

代码实现

• public static void sort(int[] a) {
  //外层循环控制比较的次数
  for (int i = 0; i < a.length - 1; i++) {
  //内层循环控制到达位置
  for (int j = 0; j < a.length - i - 1; j++) {
  //前面的元素比后面大就交换
  if (a[j] > a[j + 1]) {
  int temp = a[j];
  a[j] = a[j + 1];
  a[j + 1] = temp;
  }
  }
  }
  }