ALGO基础（一）—— 排序

ALGO基础（一）—— 排序

• 冒选插希快归堆，以下均为从小到大排

1 冒泡排序

• 描述：

  比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 针对所有的元素重复以上的步骤，除了最后一个；
• 重复步骤1~3，直到排序完成。

public void bubbleSort(int[] nums){   //每次从头开始把最大的放到最后
int len = nums.length;
for(int i = 0;i<len-1;i++){    [0，len-1)
for(int j = 0;j<len-i-1;j++){   [0，len-i-1)
if(nums[j]>nums[j+1]){
int tmp = nums[j];
nums[j] = nums[j+1];
nums[j+1] = tmp;
}
}
}
}

2 选择排序

• 在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

  public void select(int[] nums){
  int len = nums.length-1;
  for(int i = 0;i<len-1;i++){   [0.len-1)
  int index = i;  //最小值下标
  for(int j = i+1;j<len;j++)  [i+1,len)
  if(nums[j]<nums[index]) index = j;
  //交换
  int tmp = nums[i];
  nums[i] = nums[index];
  nums[index] = tmp;
  }
  }

3 插入排序

• 一次插一个，插一个排一次

  public void insert(int[] nums){
  int len = nums.length;
  
  // 从下标为1的元素开始选择位置插入，因为下标为0的只有一个元素，默认是有序的
  for (int i = 1; i < len; i++) {   [1,len)
  int temp = nums[i];  // 记录要插入的数据
  // 从已经排序的序列最右边的开始比较，找到比其小的数
  for (int j = i; j > 0&&nums[j-1] > temp; j--)  [i.0)  j-- &&         			nums[j] = nums[j-1];
  nums[j] = temp;
  }
  }

4 希尔排序(最小增量排序)

• 先将要排序的一组数按某个增量step（n/2,n为要排序数的 个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行插入排序，然后再用一个较小的增量（step/2）对它进行分组，在每组中再进行直接插入 排序。当增量减到1时，进行直接插入排序后，排序完成

• 希尔排序为什么效率高？

  插入排序如果在后面来了一个特别小的元素，需要全部移动，那么排序的效率特别低。
• 希尔排序最重要的就是步长，让步长不断地除以二，直到步长为1，优点是如果在数组最后加入一个小元素，他会被很快移到最前面。

public static void shellSort(int[] nums) {
int len = nums.length;
int temp;
for (int step = len / 2; step >= 1; step /= 2) {
// 从下标为step的元素开始选择位置插入，因为前面的魅族只有1个，默认是有序的
for (int i = step; i < len; i++) {   [step,len)
temp = nums[i];  // 记录要插入的数据
// 从已经排序的组序列最右边的开始比较，找到比其小的数
for (int j = i; j > 0&&nums[j-step] > temp; j-=step)  [i.0)  j- &&         				nums[j] = nums[j-step];
nums[j] = temp;
}
}
}

5 快速排序

• 选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。

  public void quick(int[] nums, int low, int high) {
  if (low < high) {
  int middle = getMiddle(nums, low, high);// 将数组进行一分为二
  quick(nums, low, middle - 1); // 对低字表进行递归排序
  quick(nums, middle + 1, high);// 对高字表进行递归排序
  }
  }
  
  private int getMiddle(int[] nums, int low, int high) {
  int tmp = nums[low]; // 数组的第一个作为中轴
  while (low < high) {
  while (low < high && nums[high] >= tmp) {
  high--;
  }
  nums[low] = nums[high]; // 比中轴小的记录移到低端
  while (low < high && nums[low] <= tmp) {
  low++;
  }
  nums[high] = nums[low]; // 比中轴大的记录移到高端
  }
  nums[low] = tmp; // 中轴记录到尾
  return low; // 返回中轴的位置
  }

6 归并排序

• 归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。自上而下的递归。

  public void mergeSort(int[] nums,int left,int right){
  if(left<right){
  //找出中间索引
  int center=(left+right)/2;
  //对左边数组进行递归
  mergeSort(nums,left,center);
  //对右边数组进行递归
  mergeSort(nums,center+1,right);
  //合并
  merge(nums,left,center,right);
  }
  }
  
  private void merge(int[] nums, int left, int center, int right) {
  int [] tmpArr=new int[nums.length];
  int mid=center+1;
  //third记录中间数组的索引
  int third=left;
  int tmp=left;
  while(left<=center&&mid<=right){
  //从两个数组中取出最小的放入中间数组
  if(nums[left]<=nums[mid]){
  tmpArr[third++]=nums[left++];
  }else{
  tmpArr[third++]=nums[mid++];
  }
  }
  //剩余部分依次放入中间数组
  while(mid<=right){
  tmpArr[third++]=nums[mid++];
  }
  while(left<=center){
  tmpArr[third++]=nums[left++];
  }
  //将中间数组中的内容复制回原数组
  while(tmp<=right){
  nums[tmp]=tmpArr[tmp++];
  }
  }

  

7 堆排序