c++中一些常用排序算法的实现

冒泡排序

#include<iostream>
using namespace std;
int main() {
    int n;
    cin >> n;
    int* p = new int[n];
    int t;
    for (int i = 0; i < n; ++i) {
        cin >> p[i];
    }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n - i - 1; ++j) {//注意一下j=0
            if (p[j] > p[j + 1]) {
                swap(p[j], p[j + 1]);
            }
        }
    }
    for (int i = 0; i < n; ++i) {
        cout << p[i] << " ";
    }
    cout << endl;
}

选择排序

#include<iostream>
#include<algorithm>
using namespace std;

int main() {
	  
	int n;
	cin >> n;
	int* arr = new int[n];
	for (int i = 0; i < n; ++i) {
		cin >> arr[i];
	}
	for (int i = 0; i < n; ++i) {
		int min = arr[i];
		int index = i;
		for (int j = i; j < n; ++j) {
			if (arr[j] < min) {
				min = arr[j];
				index = j;
			}

		}
		swap(arr[i], arr[index]);
	}
	for (int i = 0; i < n; ++i) {
		cout << arr[i] << " ";
	}
	cout << endl;
}

插入排序

#include<iostream>
#include<algorithm>
using namespace std;
int main(void) {

	int n,j =0;
	cin >> n;
	int* arr = new int[n];
	for (int i = 0; i < n; ++i) {
		cin >> arr[i];
	}

	for (int i = 1; i < n; ++i) {
		for (int j = i - 1; j >= 0&&arr[j]>arr[j+1]; j--){
				swap(arr[j], arr[j + 1]);	
		}
	}
	    for (int i = 0; i < n; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;
	return 0;
}

希尔排序

#include<iostream>
#include<algorithm>
using namespace std;
int main(void) {

	int n, j = 0;
	int i = 0;
	cin >> n;
	int* arr = new int[n];
	for (int i = 0; i < n; ++i) {
		cin >> arr[i];
	}
	int increasment = n;
	do{
		//确定分组的增量(就是间隔几个取一次数)
		increasment = increasment / 3 + 1;
		//每次分组有几个组就循环几次
		for ( i = 0; i < increasment; i++) {
			//这里就到了大伙都熟悉的插入排序部分（i+increasment)的含义为比如就是第一组隔3个1 4 7  然后第二组就是2 5 8这样
			for (j = i + increasment; j < n; j += increasment) {
				for (int k = j - increasment; k >= 0 && arr[k] > arr[k + increasment]; k -= increasment) {
					swap(arr[k], arr[k + increasment]);
				}
			}
		}

	} while(increasment>1);

	
	for (int i = 0; i < n; ++i) {
		cout << arr[i] << " ";
	}
	cout << endl;
	return 0;
}

快排

#include<iostream>
#include<algorithm>
using namespace std;
void QuickSort(int left,int right, int arr[]) {
	//递归终止条件
	if (left > right) {
		return;
	}
	int i, j;
	i = left;
	j = right;
	int t = arr[left];
	while (i < j) {
		while (arr[j] >= t && i < j)
			--j;
		while (arr[i] <= t && i < j)
			++i;
		if (i < j) {
			swap(arr[i], arr[j]);
		}
	}
	//把找到的值和一开始的基值进行交换
	arr[left] = arr[i];
	arr[i] = t;
	//递归调用
	QuickSort(left, i - 1, arr);//每次right的值改变
	QuickSort(i+1, right, arr);//每次left的值改变

}
int main() {
	int n, j = 0;
	int i = 0;
	cin >> n;
	int* arr = new int[n];
	for (int i = 0; i < n; ++i) {
		cin >> arr[i];
	}
	QuickSort(0, n - 1, arr);

	for (int i = 0; i < n; ++i) {
		cout << arr[i] << " ";
	}
	cout << endl;


}

归并排序

#include<iostream>
#include<algorithm>
using namespace std;
//合并算法
void Mege(int arr[], int start, int end, int mid, int temp[]) {
     //左边
    int i_start = start;
    int i_end = mid;
     //右边
    int j_start = mid + 1;
    int j_end = end;

    //表示temp辅助空间有多少元素
    int len = 0;

    //合并
    while (i_start <= i_end && j_start <= j_end) {//注意这里的<= 一定要是<=才行
        if (arr[i_start] < arr[j_start]) {
            temp[len] = arr[i_start];
            ++len;
            ++i_start;
        }
        else {
            temp[len] = arr[j_start];
            ++len;
            ++j_start;
        }
    }
    //把剩下的也放进temp中 比如1 2 7    3 6就会把7剩下
    //i中剩余
    while (i_start <= i_end) {
        temp[len] = arr[i_start];
        ++i_start;
        ++len;
    }
    //j中剩余
    while (j_start <= j_end) {
        temp[len] = arr[j_start];
        ++j_start;
        ++len;
    }
    //吧temp中的数据覆盖到源空间
    for (int i = 0; i < len; ++i) {
        arr[start + i] = temp[i];
    }
}
//归并
void MergeSort(int arr[], int start, int end, int temp[]) {
   //递归结束条件
    if (start >= end) {
        return;
    }
    int mid = (start + end) / 2;
    //左边
    MergeSort(arr, start, mid, temp);
    //右边
    MergeSort(arr, mid + 1, end, temp);
    //合并
    Mege(arr, start, end, mid, temp);
}


int main() {
    int n;
    cin >> n;
    int* arr = new int[n];
    int* temp = new int[n];
    for (int i = 0; i < n; ++i) {
        cin >> arr[i];
    }
    MergeSort(arr, 0, n - 1, temp);

    for (int i = 0; i < n; ++i) {
        cout << arr[i] << " ";

    }
    cout << endl;
    delete[]arr;
    arr = NULL;
    delete[]temp;
    temp = NULL;
}

堆排序

#include<iostream>
#include<algorithm>
using namespace std;
//arr等待调整的数组（二叉树）
//i 下标
//数组的长度
void HeadAdjust(int arr[],int index,int len) {
	//先保存下标（当前结点）
	int temp = index;
	//保存左右孩子下标  这里加一是因为数组是从0开始为下标的
	int lchild = 2 * index + 1;
	int rchild = 2 * index + 2;

	if (lchild<len && arr[lchild]>arr[temp]) {
		temp = lchild;
	}
	if (rchild<len && arr[rchild]>arr[temp]) {
		temp = rchild;
	}
	//如果temp不等于原来传入的结点，那说明孩子结点跟父结点发生了改变
	if (temp > index) {
		swap(arr[temp], arr[index]);
		//等后续结点发生变化后，可能会变得不符合大顶堆，所以还需要调整
		HeadAdjust(arr, temp, len);
	}

}
void HeadSort(int arr[],int len) {
	//从最后一个非叶子节点开始  初始化堆
	for (int i = len / 2 - 1; i >= 0; --i) {
		//len代表有几个结点
		HeadAdjust(arr,i,len);
	}
	//堆顶元素和最后一个元素进行交换
	for (int j = len - 1; j >= 0; --j) {
		swap(arr[0], arr[j]);
		//交换完再调整
		HeadAdjust(arr, 0, j);
	}
}
int main() {
	int arr[5] = { 3,4,1,5,9 };

		HeadSort(arr, 5);
	
	    for (int i = 0; i < 5; ++i) {
	        cout << arr[i] << " ";
	
	    }
	    cout << endl;
}