精华内容
下载资源
问答
  •  1、第一步起泡排序、外层循环 必须循环n次;每循环一次大泡泡都会下沉 最大泡泡在最下  2、内层循环 循环 i次 判断上一个泡泡 是不是 大于 后一个泡泡 如果大就相互调换位置  3、特点:change 如果内...
    /*
      气泡法(bubble method)是指用气泡作为变形标志体,人为加
    入模型材料内部,以有限应变分析为基础的一种定量构造模拟方
    法。将由明胶、甘油和水按比例配制的明胶液倒入按模型几何形
    状、尺寸设计的加载装置中,并搅动使之形成气泡;当处于黏弹
    性状态、气泡已不能流动后加载;然后放大拍照、测量与计算,
    可得出整个模型的有限应变状态。因便于观测整个模型内部变形
    ,标志体反应灵敏,能够达到较精确要求,故具有广泛应用前景。
    */
    class SortDemo2
    {
        public static void main(String[] args)
        {
            System.out.println("Hello World!");
            int [] a=new int[]{1,2,21,1212,1212,111,12,1234,0,11};
            bubble_sort(a,10);
            for(int i=0;i<10;i++){
                System.out.print(a[i]+"\t");
            }
        }

        /*最坏情况
            1、第一步起泡排序、外层循环 必须循环n次;每循环一次大泡泡都会下沉 最大泡泡在最下
            2、内层循环 循环 i次 判断上一个泡泡 是不是 大于 后一个泡泡  如果大就相互调换位置
            3、特点:change  如果内层循环完没有 change=true 说明排序完成 以后外层也没必要继续循环了。
        */
        public static void  bubble_sort(int a[] ,int n){
            boolean change=true;
            for(int i=n-1;i>0&&change;i--){
                change=false;
                for(int j=0;j<i;j++){
                    if(a[j]>a[j+1]){
                        int temp = a[j];
                            a[j] = a[j+1];
                            a[j+1] =temp;
                        change=true;
                    }
                }
            }
        }
    }

    展开全文
  • 起泡排序 https://www.bilibili.com/video/av49361421?p=75 初始版本时间复杂度O(n^2)。 改进:考虑到向量中的前段和后段是不是已经是有序的。前段有的话就不再继续排序,后段有的话就把hi点放到前段最大值那里。 ...

    起泡排序
    https://www.bilibili.com/video/av49361421?p=75
    初始版本时间复杂度O(n^2)。
    改进:考虑到向量中的前段和后段是不是已经是有序的。前段有的话就不再继续排序,后段有的话就把hi点放到前段最大值那里。
    在这里插入图片描述

    算法是否稳定?

    在这里插入图片描述
    归并排序
    https://www.bilibili.com/video/av18980253/
    时间复杂度O(nlogn)。
    先分,再merge归并。分而治之的算法。
    在这里插入图片描述
    C代码实现:

    
    #include <stdio.h>
    
    void merge_sort_recursive(int arr[], int reg[], int start, int end) {
        if (start >= end)
            return;
        int len = end - start, mid = (len >> 1) + start;
        int start1 = start, end1 = mid;
        int start2 = mid + 1, end2 = end;
        merge_sort_recursive(arr, reg, start1, end1);
        merge_sort_recursive(arr, reg, start2, end2);
        int k = start;
        while (start1 <= end1 && start2 <= end2)
            reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
        while (start1 <= end1)
            reg[k++] = arr[start1++];
        while (start2 <= end2)
            reg[k++] = arr[start2++];
        for (k = start; k <= end; k++)
            arr[k] = reg[k];
    }
    
    void merge_sort(int arr[], const int len) {
        int reg[len];
        merge_sort_recursive(arr, reg, 0, len - 1);
    }
    
    int main() {
    
        int a[]={1,2,3,3,2,4,5,6,7,8,3,4,5,6,22,33,44,22,11};
        int i= 19;
        merge_sort(a, i);
        while(i--)
            printf("%d    ",a[i]);
    
        return 0;
    }
    
    
    展开全文
  • void BubbleSort(int A[],int n) {  int i,j;  int flag;  int temp;  for(i=n-1,flag=1;i>0 && flag; i--)  {  flag = 0;  for(j=0;j  if(A[j+1]  {  flag = 1;  temp = A[j+1];... 

    void BubbleSort(int A[],int n)
    {
     int i,j;
     int flag;
     int temp;

     for(i=n-1,flag=1;i>0 && flag; i--)
     {
      flag = 0;
      for(j=0;j<i;j++)
       if(A[j+1] < A[j])
       {
         flag = 1;
         temp = A[j+1];
         A[j+1] = A[j];
         A[j] = temp;
       }
     
     }
    }

    int main()
    {
     int A[] = {10,50,2,65,31,145};
     BubbleSort(A,6);
     int i;
     for(i=0;i<6;i++)
      printf("%d ",A[i]);
     printf("\n");
     return 0;
    }

    展开全文
  • 初次基于向量实现起泡排序与归并排序,以为有所得,故记录下来。 2 整体程序 #include <iostream> #include <vector> using namespace std; bool bubble( int* A, int lo, int hi); void bubbleSort( ...

    1 绪论

    初次基于向量实现起泡排序与归并排序,以为有所得,故记录下来。

    2 整体程序

    #include <iostream>
    #include <vector>
    using namespace std;
    
    bool bubble( int* A, int lo, int hi);
    void bubbleSort( int* A, int lo, int hi);
    void mergeSort ( int *A, int lo, int hi);
    void merge( int *&A, int lo, int mi, int hi );
    
    int main()
    {
        int A[] = { 4, 5, 3, 7, 12, 13, 0, 15};
        int size = sizeof(A)/sizeof(A[0]);
        int (&AA)[8] = A; //数组的引用
        //bubbleSort(A, 0, 7); 
        mergeSort (AA, 0, size);
    
        //输出排序结果
        for (int i = 0; i < size - 1;i++){
            cout << A[i] << ", ";
        }
        cout << A[size - 1] <<endl;
    
       
    }
            
    //起泡排序
    void bubbleSort( int* A, int lo, int hi){
        while ( !bubble (A, lo, hi--));
    }
    
    bool bubble( int* A, int lo, int hi){
        bool sorted = true; //整体有序标志
        while (++lo < hi){
            if (A[lo - 1] > A[lo]){
                sorted = false;
                swap (A[lo -1 ], A[lo]);
            }
        }
        return sorted;
    }
    
    
    //归并排序
    void mergeSort (int *A, int lo, int hi){
        if (hi - lo < 2) return;
        int mi = (lo + hi) / 2;
        mergeSort ( A, lo, mi); 
        //展示递归的过程(1)
        for (int i = lo; i < mi ;i++){
            cout << A[i] << ", ";
        }
        cout << "end0" << endl;
    
        mergeSort(A, mi, hi);
        //展示递归的过程(2)
        for (int i = mi; i < hi ;i++){
            cout << A[i] << ", ";
        }
        cout << "end1" << endl;
    
        merge(A, lo, mi, hi); //归并
    
    }
    
    void merge(int *&A, int lo, int mi, int hi ){//各自有序的向量[lo,mi)和[mi,hi)
        int* A1 = A + lo;              
        int lb = mi - lo;
        int* B1 = new int[lb];//前子向量B1[0,lb) = A[lo,mi)
        for ( int i = 0; i < lb; i++) B1[i] = A1[i];  //不能写成for ( int i = 0; i < lb; B1[i] = A1 [i++])
        int lc = hi - mi; int* C1 = A + mi;//后子向量C1[0, lc) = A[mi, hi)        
        for ( int i = 0, j = 0, k = 0; (j < lb)||(k < lc);){
            if((j < lb )&&(!(k < lc)||( B1[j] <= C1[k]))) A1[i++] = B1[j++];
            if((k < lc )&&(!(j < lb)||( C1[k] < B1[j]))) A1[i++] = C1[k++];
        }
        delete [] B1;
    }
    
    
    
    

    3 起泡排序

    • 作为最简单的排序方式之一,起泡排序采用减而治之的策略。每一个轮回之后,最大的值都会回到最末端,以此可以不断减小问题的规模。
    //起泡排序
    void bubbleSort( int* A, int lo, int hi){
        while ( !bubble (A, lo, hi--));
    }
    
    bool bubble( int* A, int lo, int hi){
        bool sorted = true; //整体有序标志
        while (++lo < hi){
            if (A[lo - 1] > A[lo]){
                sorted = false;
                swap (A[lo -1 ], A[lo]);
            }
        }
        return sorted;
    }
    

    4 归并排序

    • 归并排序的思想朴素而深沉,分而合之,正如“将欲取之,必须与之”,化整为零,然后可以成你所想
    //归并排序
    void mergeSort (int *A, int lo, int hi){
        if (hi - lo < 2) return;
        int mi = (lo + hi) / 2;
        mergeSort ( A, lo, mi); 
        //展示递归的过程(1)
        for (int i = lo; i < mi ;i++){
            cout << A[i] << ", ";
        }
        cout << "end0" << endl;
    
        mergeSort(A, mi, hi);
        //展示递归的过程(2)
        for (int i = mi; i < hi ;i++){
            cout << A[i] << ", ";
        }
        cout << "end1" << endl;
    
        merge(A, lo, mi, hi); //归并
    
    }
    
    void merge(int *&A, int lo, int mi, int hi ){//各自有序的向量[lo,mi)和[mi,hi)
        int* A1 = A + lo;              
        int lb = mi - lo;
        int* B1 = new int[lb];//前子向量B1[0,lb) = A[lo,mi)
        for ( int i = 0; i < lb; i++) B1[i] = A1[i];  //不能写成for ( int i = 0; i < lb; B1[i] = A1 [i++])
        int lc = hi - mi; int* C1 = A + mi;//后子向量C1[0, lc) = A[mi, hi)        
        for ( int i = 0, j = 0, k = 0; (j < lb)||(k < lc);){
            if((j < lb )&&(!(k < lc)||( B1[j] <= C1[k]))) A1[i++] = B1[j++];
            if((k < lc )&&(!(j < lb)||( C1[k] < B1[j]))) A1[i++] = C1[k++];
        }
        delete [] B1;
    }
    
    • 下面是该程序运行出的结果,通过展示递归过程,可以帮助对归并的理解
      4, end0
      5, end1
      4, 5, end0
      3, end0
      7, end1
      3, 7, end1
      3, 4, 5, 7, end0
      12, end0
      13, end1
      12, 13, end0
      0, end0
      15, end1
      0, 15, end1
      0, 12, 13, 15, end1
      0, 3, 4, 5, 7, 12, 13, 15

    5 总结

    归并排序借鉴了邓俊辉老师的代码,没有用其中的模板。遇到了总是输出出错的问题。自己化整为零地分析一行行代码,来分析整个代码逻辑,最终终于找到了有问题的语句。通过这个过程,我对于归并的思想理解得更加深刻。

    展开全文
  • 数据结构各种算法

    2011-12-22 11:13:05
    数据结构里面的多种算法 老师总结的 过来和大家分享一下 包含:堆排序,归并排序,起泡排序,筛选排序。。。等等一共十四种排序集合
  • 北京工业大学,电控学院,《数据结构算法》。本资源是北工大电控学院大一下学期课程《数据结构算法》的课程作业。 本资源为数据结构算法第三章(排序)的作业程序代码。包含以下的两个程序: 3.4 rk作哨兵直接...
  • 数据结构排序算法

    2019-09-19 08:26:43
    起泡算法 每次选出一个最大的数字甩到后面,再次选择次大的,...循环下去。 #include <stdio.h> //起泡排序 void BubbleSort(int R[],int n) { //大的数字往后冒(写小的往前也行) int i,j,temp,flag=0;...
  • 数据结构算法(c++)--排序算法

    千次阅读 2020-09-11 13:12:43
    数据结构算法(c++)–排序算法 这篇文章主要简单记录下数据结构算法中的排序算法技术 只记录下了七种排序算法: 插入排序 直接插入排序 希尔排序 交换排序 起泡排序 快速排序 选择排序 简单选择排序 堆排序 ...
  • 引言:我们的数据结构已经学习完基本的知识,但是光有数据结构是不可以的,现在我们将目光放在接下来的内容,基础算法部分。现在我们就开始第一部分的学习——排序算法 排序一.排序简介二.桶排序1.定义2.代码原理3....
  • 数据结构起泡排序

    2020-03-14 17:27:21
    数据结构算法写在前面起泡排序算法粗暴版提前终止版提前终止加强版 写在前面 看了b站上清华老师邓俊辉邓老师的视频,把代码写下来自己记录记录,方便记忆和理解。 起泡排序算法 粗暴版 起泡排序是个很简单也很容易...
  • 利用随机函数产生30000个随机整数,利用插入排序、起泡排序、选择排序、快速排序、堆排序、归并排序等排序方法进行排序,并统计每一种排序上机所花费的时间。提示:用顺序存储结构
  • 1插入排序直接插入排序希尔排序 2交换排序起泡排序快速排序 3选择排序简单选择排序堆排序 4归并排序基数排序;排序将数据元素的一个任意序列重新排列成一 个按关键字有序的序列 ; 设 Ki = Kj (1in, 1jn, ij )且在排序...
  • Java数据结构算法_冒泡排序 一、冒泡排序介绍 冒泡排序也称起泡排序,它是通过元素两两比较,如果前者比后者大,则交换位置,这样一趟排序下来,最大的元素就排到队尾了;反复此操作,直至数列有序完成排序操作。 ...
  • 起泡排序,别名“冒泡排序”,该算法的核心思想是将无序表中的所有记录,通过两两比较关键字,得出升序序列或者降序序列。 例如,对无序表{49,38,65,97,76,13,27,49}进行升序排序的具体实现过程如图 1 所示...
  • 插入排序主要包含直接插入排序、希尔排序 直接插入排序:https://blog.csdn.net/plus_l/article/details/80984159 ... 交换排序,主要包括:起泡排序、快速排序 冒泡排序:https://www.cnblogs.co...
  • A选项起泡算法:相邻元素两两比较,一个元素大于右侧相邻元素交换位置,否则位置不变。 一趟排序为:46,56,38,40,79,84 B选项直接插入:每一步将一个待排序的记录,插入到前面已经排好序的有序序列中去,直到...
  • 文章目录0 十大排序算法(总结向)0.1 排序性能的衡量方法0.2 九大排序算法的性能分析1 起泡排序1.1 算法步骤1.2 动图演示1.3 代码实现2 选择排序2.1 算法步骤2.2 动图演示2.3 代码实现3 插入排序3.1 算法步骤3.2 ...
  • 十大排序算法的时间复杂度和空间复杂度如下图...排序算法的稳定性:以下排序算法同一默认为升序,且以int为待排序数据类型冒泡排序(起泡排序):稳定算法过程:a.从第二个元素开始,和前一个元素进行比较大小,如果比...
  • l算法介绍 冒泡排序也叫起泡排序,它是通过一系列的”交换”动作完成的。首先第一个记录和第二个记录比较,如果第一个比较大,则二者进行交换,否则不交换;然后第二个和第三个进行比较,如果第二个比较大,则二者...
  • 目录 一、各排序算法的时间复杂度与空间复杂度比较 二、直接插入排序 1、算法思想 2、代码实现 3、输出结果 4、时间复杂度与空间复杂度...1、算法思想 ...四、起泡排序 1、算法思想 2、代码实现 3、输出结果 ...
  • 九大排序算法 在之前的向量、列表、散列表与优先级序列中,已经学习了前七种排序方法。在本博客中将学习剩余的快速排序与希尔排序。 起泡排序 归并排序 插入排序 选择排序 桶排序 基数排序 堆排序 快速排序 希尔排序...
  • 数据结构算法》课程设计 30、排序综合 问题描述: 利用随机函数产生N个随机整数(20000以上),对这些数进行多种方法进行排序。 基本要求: (1)至少采用三种方法实现上述问题求解(提示:可采用的方法有插入...
  • 冒泡(起泡)排序是一种比较简单的基本排序,思想:假如我们对10个数进行从小到大排序。思路是将相邻的两个数比较,将小的调到前头,大的数字下沉。 设数组长度为N。 1、N个数排序,需要循环进行N-1趟排序。 2、每一...
  • 适合初学者学习C++数据结构练习的一个实验,排序算法时间测试,快速排序,归并排序及起泡排序法,请使用VS2013打开,如使用低版本请自己加载头文件和源文件。希望可以帮助到大家,谢谢(来自某大学软件工程的一名...
  • 数据结构-排序算法

    2020-01-27 18:33:09
    数据结构-排序算法一、直接插入法二、希尔排序法三、交换排序(起泡排序)四、快速排序 一、直接插入法 解决方法: 将第1个记录看成是初始有序表,然后从第2个记录起依次插入到这个有序表中,直到将第n个记录...
  • #include <stdio.h> #include<stdlib.h> #include <time.h> #define MAX 20 /*线性表中最多元素个数*/ typedef int KeyType; typedef char InfoType[10]; typedef struct ......
  • 数据结构所有排序算法性能分析与比较 通过对数据结构的学习,我发现数据结构中各种排序算法的排序方法,过程,以及时间性能,空间性能都比较容易混淆,现就这些情况做如下总结,希望对大家有所帮助。 起泡排序...
  • 数据结构算法演示 1. 顺序表 (1)在顺序表中插入一个数据元素(ins_sqlist) (2)删除顺序表中一个数据元素(del_sqlist) (3)合并两个有序顺序表(merge_sqlist) 2. 链表 (1)创建一个单链表(Crt_LinkList) ...
  • 【大话数据结构&算法】冒泡排序

    千次阅读 2016-08-03 22:51:45
    起泡排序又称为冒泡排序。它是通过一系列的“交换”动作完成的。首先将第一和第二个记录进行比较,如果第一个记录大于第二个记录,则两者交换位置,否则保持原位置不变;然后比较第二和第三个记录……一直按这种方式...
  • 在这类排序方法中最常见的是起泡排序和快速排序,其中快速排序是一种在实际应用中具有很好表现的算法。 1.冒泡排序 a.算法描述  起泡排序的思想非常简单。首先,将n个元素中的第一个和第二个进行比较,如果两个...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 193
精华内容 77
关键字:

数据结构起泡算法

数据结构 订阅