【数据结构笔记】排序算法

排序

冒泡排序

最好情况事件时间度$O(n)$
最坏情况事件时间度$O(n^2)$
平均时间复杂度$O(n^2)$
稳定排序

void BubbleSort(int a[],int n){
	for(int i=0;i<n-1;i++)
		for(int j=0;j<n-i-2;j++)
		{
			if(a[j]>a[j+1]){
				a[j]=a[j+1]+a[j];
				a[j+1]=a[j]-a[j+1];
				a[j]=a[j]-a[j+1];
			}
		}
}

选择排序

所有情况下时间复杂度都是$O(n^2)$
不稳定排序

void selectSort(int arr[], int len)
{
	int i, j;
	int min; //待排序数组中最小值的下标
	int tmp;
	for (i = 0; i < len - 1; ++i)//i = 0,第一次待排数组为所有数
	{   
		min = i;
		for (j = i + 1; j < len; ++j)
			{
				if (arr[j] < arr[min])
					{
						min = j;//
					}
			}
		//将arr[i]与arr[min]交换位置
		tmp = arr[i];
		arr[i] = arr[min];
		arr[min] = tmp;
	}
}

插入排序

最好情况$O(n)$
最坏情况$O(n^2)$
平均情况$O(n^2)$
稳定排序

void InsertSort(int arr[],int n){
	for(int i=1;i<n;i++){
		int j=i-1;
		int temp=arr[i];
		while(j>=0 && arr[j]>temp){
			arr[j+1]=arr[j];
			j--;
		}
		arr[j+1]=temp;
	}
}

希尔排序

时间复杂度$O(n^{1.3})$
不稳定排序

void ShellSort(int a[],int n){
    int gap,i,j,temp;
    for(gap=n/2;gap>0;gap/=2){
        for(i=gap;i<n;i++){
            temp=a[i];
            for(j=i-gap;j>=0&&a[j]<temp;j-=gap){
                a[j+gap]=a[j];
            }
            a[j+gap]=temp;
        }
    }
}

快速排序

最坏情况O(n)在元素有序的时候最慢（不管是顺序还是反序都会在这时候退化成为冒泡排序）为O(n^2)
平均情况为$O(nlo{g}_2(n))$
不稳定排序

void QuickSort(int a[], int low, int high)
{
    if (low < high)
    {
        int i = low, j = high;
        int x = a[low];
        while (i < j)
        {
            while (i < j && a[j] >= x)
                j--;
            if (i < j)
                a[i++] = a[j];
            while (i < j && a[i] <= x)
                i++;
            if (i < j)
                a[j--] = a[i];
        }
        a[i] = x;
        QuickSort(a, low, i - 1);
        QuickSort(a, i + 1, high);
    }
}

堆排序

所有情况下都是$O(nlo{g}_2(n))$
不稳定排序

void HeapAdjust(int *arr, int i, int n)//建一个大顶堆的操作
{
    int temp = arr[i];//保留堆顶元素的值
    int child = 2 * i + 1;
    while (child < n/*小于n的原因:要保证所有子树上的情况都成立*/)
    {
        if (child + 1 < n && arr[child + 1] > arr[child])//找出左右子树中最大的一个
            child++;
        if (arr[child] > temp)
        {//如果子树中最大的比堆顶元素大，则交换
            arr[i] = arr[child];
            i = child;
            child = 2 * i + 1;//遍历这个顶点的子树，越向前的节点越有这个情况
        }
        else//否则，堆顶元素就是最大的
            break;
        
    }
    arr[i] = temp;
}
void HeapSort(int *arr, int n)
{
    for (int i = n / 2 - 1/*不叶子节点的位置开始*/; i >= 0; i--)
        HeapAdjust(arr, i, n);
    for (int i = n - 1; i > 0; i--)
    {//交换堆顶元素和最后一个元素
        swap(arr[0], arr[i]);
    //重新调整堆
        HeapAdjust(arr, 0, i);
    }
}

并归排序

所有情况下都是$O(nlo{g}_2(n))$
稳定排序

void TwoWayMergeSort(int *array, int size) {
  int *temp = new int[size];
  int *left = array;
  int *right = array + size / 2;
  int *end = array + size;

  while (left < right && right < end) {
    if (*left <= *right) {
      *temp++ = *left++;
    } else {
      *temp++ = *right++;
    }
  }

  while (left < right) {
    *temp++ = *left++;
  }

  while (right < end) {
    *temp++ = *right++;
  }

  for (int i = 0; i < size; i++) {
    array[i] = temp[i];
  }

  delete[] temp;
}