数据结构与算法---4---冒泡排序

 

数据结构与算法1

数据结构与算法2--排序算法列表

数据结构与算法3---选择排序

数据结构与算法4--冒泡排序

---

目录

1.简介

1. 1 算法原理---这里从小到大排

1.2 算法性能

1.3基础版本

1.4 优化版本

1.5 算法基础版本排序--->验证稳定性

1.6 算法优化版本---验证稳定性---系统功能sort 对比验证功能

---

冒泡排序

1.简介

冒泡排序（Bubble Sort），重复的遍历要排序的数据，相邻数据按顺序（大->小、小->大）排列，如果不是则交换相邻两个数据，

最大最小的数据会浮动到一端的末尾位置[ 每次遍历末尾位置，存好数据，末尾待存数据位置会前移一位]； 数据浮动到端--->冒泡。

1. 1 算法原理---这里从小到大排

1.        找到待存放数据的端位置（左/右）---一般为末尾最右端
2.        从对端位置起始（左端），一次比较相邻数据符合（小->大）不变，不符交换顺序，直到尾端为此次排序最大数据
3.        尾端更新前移
4.        重复2,3 直到尾端更新到对端起始第一个数据位置，结束（ 更新尾端pos从 n-1 到1 ；  每次更新时排序比较数据次数为   （尾端位置下标）pos的次数 ）---》pos =[n-1, 0)   ,每次更新比较 [0,pos)

1.2 算法性能

中文名称	英文名称	平均时间复杂度	最坏时间复杂度	最好时间复杂度	空间复杂度	稳定性
冒泡排序	Bubble				1	稳

1.3基础版本

 int sort(int arg[], int len){
   for(int i=len-1;i>0;--i){
     for(int j=0; j<i;++j){
        if(arg[j]>arg[j+1]){
          swap(arg[j],arg[j+1]);  
        } 
      }  
    }
  return 0;
 }

1.4 优化版本

 设置flag ，最好场景： 原先顺序对的，因此只需一次检查数据时确定没发生交换即可退出循环

 int Sort(int arg[], int len){
 bool flag ;
   for(int i=len-1;i>0;--i){
     flag = true;
     for(int j=0; j<i;++j){
        if(arg[j]>arg[j+1]){  // 若需要倒叙将比较> 改为 <
          swap(arg[j],arg[j+1]); 
           flag =false; 
        } 
      }
     if(flag == true) break;
    }
  return 0;
 }

 

1.5 算法基础版本排序--->验证稳定性

#include<iostream>
#include<stdio.h>
#include<ctime>
#include<cstdlib>
#include<string.h>
#include<algorithm>
using namespace std;
class BubbleSort{
public:
BubbleSort(){};
~BubbleSort(){};


 
 int sort(int arg[], int len){
  for(int i=len-1;i>0;--i){
    for(int j=0; j<i;++j){
       if(arg[j]>arg[j+1]){
          swap(arg[j],arg[j+1]);  
        } 
      }  
  }
  return 0;
 }
  int sort(int arg[],int arg1[], int len){
  for(int i=len-1;i>0;--i){
    for(int j=0; j<i;++j){
       if(arg[j]>arg[j+1]){
          swap(arg[j],arg[j+1]);  
          swap(arg1[j],arg1[j+1]);
        } 
      }  
  }
  return 0;
 }

 
 void print(int arg[],int len){
  for(int i =0; i<len; ++i)
  {
    cout<< arg[i]<<" ";
  }
   cout<<endl;
}
void genRandArr(int arg[],int len ){
    srand(time(0));
    for(int i =0; i<len; ++i){
        arg[i]=rand()%10;
    }
}

void genArr(int arg[],int len ){
    for(int i =0; i<len; ++i){
        arg[i]=i;
    }
}


void compare(int arg[], int arg1[], int len){
    bool same =true;
    static int index =0;
    for(int i =0; i<len; ++i){        
        if(arg[i]!=arg1[i]) {same=false; index =i;  }
     }
   // cout<< arg[index] <<" "<< arg1[index] <<" "<< index <<endl;
   // cout<< (same==true ? "right":"wrong")<<endl;
   same==false ?  cout<<"wrong"<<endl: same =true;
}
void checkstab(int arg[], int arg1[] ,int len ){
    for(int i =0; i<len-1;++i){
        for(int j= i+1; j<len;j++){
            if(arg[i]==arg[j]){
                cout<<(arg1[i]<arg1[j] ? "right":"wrong")<<endl;
            }
        }
    }
}

private:
void swap(int &a,int &b){
  int tmp;
  tmp =a;
  a= b;
  b= tmp;
}
};
bool cmp(int a, int b){
    return a<b;
}

#define ARR_SIZE 100
int main(){
int arg[ARR_SIZE]={7,4,7,2};
int arg1[ARR_SIZE];

BubbleSort Bub;
 for(int i =0;i<1;++i){
     
    Bub.genRandArr(arg,sizeof(arg)/sizeof(int));
    Bub.genArr(arg1,sizeof(arg)/sizeof(int));
   // Bub.print(arg1,sizeof(arg)/sizeof(int));
   // Bub.print(arg,sizeof(arg)/sizeof(int));
   // Bub.sort(arg, sizeof(arg)/sizeof(int));
    Bub.sort(arg,arg1, sizeof(arg)/sizeof(int));
    Bub.checkstab(arg,arg1, sizeof(arg)/sizeof(int));    
   // Bub.print(arg1,sizeof(arg1)/sizeof(int));
   // Bub.print(arg,sizeof(arg)/sizeof(int));
 }
}

1.6 算法优化版本---验证稳定性---系统功能sort 对比验证功能

#include<iostream>
#include<stdio.h>
#include<ctime>
#include<cstdlib>
#include<string.h>
#include<algorithm>
using namespace std;
class BubbleSort{
public:
BubbleSort(){};
~BubbleSort(){};


 
 int sort(int arg[], int len){
   bool flag ;
   for(int i=len-1;i>0;--i){
     flag = true;
     for(int j=0; j<i;++j){
        if(arg[j]>arg[j+1]){  // 若需要倒叙将比较> 改为 <
          swap(arg[j],arg[j+1]); 
           flag =false; 
        } 
      }
     if(flag == true) break;
    }
  return 0;
 }
         
  int sort(int arg[],int arg1[], int len){
   bool flag ;
   for(int i=len-1;i>0;--i){
     flag = true;
     for(int j=0; j<i;++j){
        if(arg[j]>arg[j+1]){  // 若需要倒叙将比较> 改为 <
          swap(arg[j],arg[j+1]);   
          swap(arg1[j],arg1[j+1]);
           flag =false; 
        } 
      }
     if(flag == true) break;
    }
  return 0;
 }

 
 void print(int arg[],int len){
  for(int i =0; i<len; ++i)
  {
    cout<< arg[i]<<" ";
  }
   cout<<endl;
}
void genRandArr(int arg[],int len ){
    srand(time(0));
    for(int i =0; i<len; ++i){
        arg[i]=rand()%10;
    }
}

void genArr(int arg[],int len ){
    for(int i =0; i<len; ++i){
        arg[i]=i;
    }
}


void compare(int arg[], int arg1[], int len){
    bool same =true;
    static int index =0;
    for(int i =0; i<len; ++i){        
        if(arg[i]!=arg1[i]) {same=false; index =i;  }
     }
   // cout<< arg[index] <<" "<< arg1[index] <<" "<< index <<endl;
   // cout<< (same==true ? "right":"wrong")<<endl;
   same==false ?  cout<<"wrong"<<endl: same =true;
}
void checkstab(int arg[], int arg1[] ,int len ){
    for(int i =0; i<len-1;++i){
        for(int j= i+1; j<len;j++){
            if(arg[i]==arg[j]){
                cout<<(arg1[i]<arg1[j] ? "right":"wrong")<<endl;
            }
        }
    }
}

private:
void swap(int &a,int &b){
  int tmp;
  tmp =a;
  a= b;
  b= tmp;
}
};
bool cmp(int a, int b){
    return a<b;
}

#define ARR_SIZE 100
int main(){
int arg[ARR_SIZE];
int arg1[ARR_SIZE];
int arg3[ARR_SIZE];

BubbleSort Bub;
 for(int i =0;i<1;++i){
     
    Bub.genRandArr(arg,sizeof(arg)/sizeof(int));
    Bub.genArr(arg1,sizeof(arg)/sizeof(int));
    memcpy((void*)&arg3,(void*)&arg, sizeof(int)*ARR_SIZE);
   // Bub.print(arg3,sizeof(arg)/sizeof(int));
   // Bub.print(arg,sizeof(arg)/sizeof(int));
   // Bub.sort(arg, sizeof(arg)/sizeof(int));
    sort(arg3, arg3 +ARR_SIZE,cmp);
    Bub.sort(arg,arg1, sizeof(arg)/sizeof(int));
   // Bub.checkstab(arg,arg1, sizeof(arg)/sizeof(int)); 
    Bub.compare(arg,arg3, ARR_SIZE); 
   // Bub.print(arg1,sizeof(arg1)/sizeof(int));
   // Bub.print(arg,sizeof(arg)/sizeof(int));
 }
}