如果连排序都不写不不出来,不要去面试了,自己找难看 !!丢人!!
1.冒泡排序:
冒泡排序的原理:从第一个数开始,依次往后比较,如果前面的数比后面的数大就交换。
n个数据需要来回n-1趟,每将一个数归位我们将其称为“一趟”,时间复杂度: O(N^2),稳定排序。
如果有n个数进行排序,只需将n-1个数归位,也就是说要进行n-1趟操作。而“每一趟”都需要从第1位开始进行相邻两个数的比较,将较小的一个数放在后面,比较完毕后向后挪一位继续比较下面两个相邻数的大小,重复此步骤,直到最后一个尚未归位的数,已经归位的数则无需再进行比较(已经归位的数你还比较个啥,浪费表情)
2.选择排序
选择排序就是不断地从未排序的元素中选择最大(或者最下)的元素放入已经排好序的元素集合中,直到未排序中仅剩一个元素为止。
第一步:
第二步:
第三步:
第四步:
第五步:
3.插入排序
基本思想:每一步将一个待排序的数据插入到前面已经排好序的有序序列中,直到插完所有元素为止
4.归并排序
思路:
1.利用递归确保左边有序
2.利用递归确定右边有序
3.最后将两个有序的序列进行合并
5、堆排序
堆排序的基本思想是:将待排序序列构造成一个大顶堆,此时,整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换,此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆,这样会得到n个元素的次小值。如此反复执行,便能得到一个有序序列了
预备知识
堆排序
堆排序是利用堆这种数据结构而设计的一种排序算法,堆排序是一种选择排序,它的最坏,最好,平均时间复杂度均为O(nlogn),它也是不稳定排序。首先简单了解下堆结构。
堆
堆是具有以下性质的完全二叉树:每个结点的值都大于或等于其左右孩子结点的值,称为大顶堆;或者每个结点的值都小于或等于其左右孩子结点的值,称为小顶堆。如下图:
同时,我们对堆中的结点按层进行编号,将这种逻辑结构映射到数组中就是下面这个样子
该数组从逻辑上讲就是一个堆结构,我们用简单的公式来描述一下堆的定义就是:
大顶堆:arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]
小顶堆:arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]
ok,了解了这些定义。接下来,我们来看看堆排序的基本思想及基本步骤:
步骤一 构造初始堆。将给定无序序列构造成一个大顶堆(一般升序采用大顶堆,降序采用小顶堆)。
步骤二 将堆顶元素与末尾元素进行交换,使末尾元素最大。然后继续调整堆,再将堆顶元素与末尾元素交换,得到第二大元素。如此反复进行交换、重建、交换。
再简单总结下堆排序的基本思路:
a.将无需序列构建成一个堆,根据升序降序需求选择大顶堆或小顶堆;
b.将堆顶元素与末尾元素交换,将最大元素"沉"到数组末端;
c.重新调整结构,使其满足堆定义,然后继续交换堆顶元素与当前末尾元素,反复执行调整+交换步骤,直到整个序列有序。
构造堆
将无序数组构造成一个大根堆(升序用大根堆,降序就用小根堆)
假设存在以下数组
主要思路:第一次保证0~0位置大根堆结构(废话),第二次保证0~1位置大根堆结构,第三次保证0~2位置大根堆结构...直到保证0~n-1位置大根堆结构(每次新插入的数据都与其父结点进行比较,如果插入的数比父结点大,则与父结点交换,否则一直向上交换,直到小于等于父结点,或者来到了顶端)
插入6的时候,6大于他的父结点3,即arr(1)>arr(0),则交换;此时,保证了0~1位置是大根堆结构,如下图:
(友情提示:待交换的数为蓝色,交换后的数为绿色)
插入8的时候,8大于其父结点6,即arr(2)>arr(0),则交换;此时,保证了0~2位置是大根堆结构,如下图
插入5的时候,5大于其父结点3,则交换,交换之后,5又发现比8小,所以不交换;此时,保证了0~3位置大根堆结构,如下图
插入7的时候,7大于其父结点5,则交换,交换之后,7又发现比8小,所以不交换;此时整个数组已经是大根堆结构
2.2 固定最大值再构造堆
此时,我们已经得到一个大根堆,下面将顶端的数与最后一位数交换,然后将剩余的数再构造成一个大根堆
(友情提示:黑色的为固定好的数字,不再参与排序)
此时最大数8已经来到末尾,则固定不动,后面只需要对顶端的数据进行操作即可,拿顶端的数与其左右孩子较大的数进行比较,如果顶端的数大于其左右孩子较大的数,则停止,如果顶端的数小于其左右孩子较大的数,则交换,然后继续与下面的孩子进行比较
下图中,5的左右孩子中,左孩子7比右孩子6大,则5与7进行比较,发现5<7,则交换;交换后,发现5已经大于他的左孩子,说明剩余的数已经构成大根堆,后面就是重复固定最大值,然后构造大根堆
如下图:顶端数7与末尾数3进行交换,固定好7,
剩余的数开始构造大根堆 ,然后顶端数与末尾数交换,固定最大值再构造大根堆,重复执行上面的操作,最终会得到有序数组
最后说明:希尔排序参考插入排序,快速排序写臭,只给出代码。
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
//1.bubble
vector<int> bubblesort(vector<int>& arr)
{
int len=arr.size();
for(int i=0;i<len-1;i++){
for(int j=0;j<len-i-1;j++){ //从第1位开始比较直到最后一个尚未归位的数
if(arr[j]>arr[j+1]){
swap(arr[j],arr[j+1]);
}
}
}
return arr;
}
//基本思想:每一步将一个待排序的数据插入到前面已经排好序的有序序列中,直到插完所有元素为止。
/**
* @brief InsertSort()
* @param arr
* @return
*/
vector<int> InsertSort(vector<int>& arr)
{
int len=arr.size();
int i;
int j;
//defaule i=0 sorted
for( i=1;i<len;i++){ //外层是无序,待插入的数据,和选择排序相反
int temp=arr[i];
for( j=i-1;j>=0&&arr[j]>temp;j--){//内层是有序的
arr[j+1]=arr[j];
}
arr[j+1]=temp;//put the sorted arr tail
}
return arr;
}
/**
* @brief shellsort
* @param arr
* @return
*
*/
vector<int> shellsort(vector<int>& arr)
{
int i;
int j;
int len=arr.size();
for(int gap=len/2;gap>0;gap/=2)
{
for(i=gap;i<len;i++){
int temp=arr[i];
for(j=i-1;j>0&&arr[j]>temp;j--){
arr[j+1]=arr[j];
}
arr[j+1]=temp;
}
}
return arr;
}
/**
//===5---quicksort
* @brief quicksort
* @param arr
* @param left
* @param right
* @return
* 它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,
* 然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
*/
vector<int> quicksort(vector<int>& arr,int left,int right)
{
if(right<left) return arr;
int low=left;
int high=right;
int base=arr[low];
while(low<high){
while(low<high && arr[high]>=base){
high-- ;
}
arr[low]=arr[high];
while(low<high && arr[low]<=base){
low++;
}
arr[high]=arr[low];
}
arr[low]=base;
quicksort(arr,left,low-1);
quicksort(arr,low+1,right);
return arr;
}
//4.seclectsort
/**
* @brief selectsort
* @param arr
* @return
* @brief: 选择排序法是在要排序的一组数中,选出最小(或最大)的一个数与第一个位置的数交换;
* 在剩下的数当中找最小的与第二个位置的数交换,即顺序放在已排好序的数列的最后,如此循环,直到全部数据元素排完为止
*/
vector<int> selectsort(vector<int>& arr)
{
int i;
int j;
int len=arr.size();
for(i=0;i<len;i++){ /外层控制有序
int minIndex=i;
for(j=i+1;j<len;j++){ //在无序区间找出最小元素
if(arr[j]<arr[minIndex]){
minIndex=j;
}
}
swap(arr[i],arr[minIndex]);
}
return arr;
}
//=================6 mergesort====================================
static vector<int> merge(vector<int>& num,int l1,int r1,int l2,int r2)
{
int i=l1;
int j=l2;
int n=r1-l1+r2-l2+2;
int k=0;
vector<int> temp(num.size());
while(i<=r1&&j<=r2){
if(num[i]<num[j]){
temp[k++]=num[i++];
}else{
temp[k++]=num[j++];
}
}
while(i<=r1){
temp[k++]=num[i++];
}
while(j<=r2){
temp[k++]=num[j++];
}
for(int i=0;i<n;i++){
num[l1+i]=temp[i];
}
return num;
}
/**
* @brief mergesort
* @param arr
* @param left
* @param right
* @return
* 归并排序的算法我们通常用递归实现。
先把待排序区间 [s,t] 以中点二分;
接着把左边子区间排序;
再把右边子区间排序;
最后把左区间和右区间用一次归并操作合并成有序的区间 [s,t] 。
*/
vector<int> mergesort(vector<int>& arr,int left,int right)
{
if(left<right)
{
int mid=left+(right-left)/2;
mergesort(arr,left,mid); //左边有序
mergesort(arr,mid+1,right);//右边有序
merge(arr,left,mid,mid+1,right);//最后将两个有序的序列合并
}
return arr;
}
//==================7 heap=============================
/**
堆排序的基本思想是:1、将带排序的序列构造成一个大顶堆,根据大顶堆的性质,当前堆的根节点(堆顶)就是序列中最大的元素;
2、将堆顶元素和最后一个元素交换,然后将剩下的节点重新构造成一个大顶堆;
3、重复步骤2,如此反复,从第一次构建大顶堆开始,
每一次构建,我们都能获得一个序列的最大值,然后把它放到大顶堆的尾部。最后,就得到一个有序的序列了。
* @brief adjustHeap
* @param arr
* @param i
* @param length
* 大顶堆:每个结点的值都大于或等于其左右孩子结点的值,根结点的值一定是所有结点中最大的
小顶堆:每个结点的值都小于或等于其左右孩子结点的值,根结点的值一定是所有结点中最小的
*/
static void adjustHeap(vector<int>&arr ,int i ,int length){
int temp=arr[i]; //derive the current node
//k(i)>=k(2i)
//k(i)>=k(2i+1)
// 按照层序遍历,将上图中的大顶堆存入数组中
//循环遍历当前结点s的左右孩子j,因为是完全二叉树,所以所以左孩子的序号是2*k,右孩子的序号是2*k+1
for(int k=2*i+1;k<length;k=2*k+1){
//k<length-1说明当前的孩子结点不是完全二叉树的最后一个结点
if(k<length-1 && arr[k]<arr[k+1]){
k++;
}
if(arr[k]>temp){
arr[i]=arr[k];
i=k;
}else{
break;
}
}
arr[i]=temp;
}
vector<int> heapsort(vector<int>& arr)
{
int j;
int length=arr.size();
//从第最后一个非叶子节点开始,调整对结构
for(int i=length/2-1;i>=0;i--){
adjustHeap(arr,i,length);
}
for(int j=length-1;j>=0;j--){
swap(arr[j],arr[0]); //换堆顶元素与当前末尾元素
adjustHeap(arr,0,j); //重新调整堆结构
}
return arr;
}
//print vector
void printvec(vector<int> arr){
for(auto x:arr){
cout<<x<<" ";
}
}
int main()
{
vector<int> arr={3,6,8,5,7};
vector<int> temp=heapsort(arr);
printvec(temp);
return 0;
}
//print vector
void printvec(vector<int> arr){
for(auto x:arr){
cout<<x<<" ";
}
}
int main()
{
vector<int> arr={1,3,2,5,6,4};
vector<int> temp=heapsort(arr);
printvec(temp);
return 0;
}
链表归并排序
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
class Solution {
public:
/**
*
* @param head ListNode类
* @return ListNode类
*/
ListNode* sortList(ListNode* head) {
// write code here
if(head==NULL||head->next==NULL){
return head; //必须加
}
ListNode* mid=middle(head); 将左右分割开
ListNode* right=sortList(mid->next);
mid->next=NULL;
ListNode* left=sortList(head);
return mergesort(left, right);
}
ListNode *mergesort(ListNode* left,ListNode* right){
if(left==NULL) return right;
if(right==NULL) return left;
ListNode* temp=new ListNode(0);
ListNode* head=temp;
while(left!=NULL && right!=NULL){
if(left->val<right->val){
head->next=left;
left=left->next;
}else{
head->next=right;
right=right->next;
}
head=head->next;
}
if(left==NULL){
head->next=right;
}
if(right==NULL){
head->next=left;
}
return temp->next;
}
ListNode *middle(ListNode* head){
ListNode *slow=head;
ListNode *fast=head->next;
while(fast!=NULL && fast->next!=NULL){
slow=slow->next;
fast=fast->next->next;
}
return slow;
}
};