[golang] 数据结构-冒泡排序

碎碎念
不能再经典的排序算法,说到排序算法大部分可能第一印象就是它了吧。记得大学时老师还花了一节课的时间进行详细解释。

原理
冒泡算法(bubble sort) 是一种很简单的交换排序。每轮都从第一个元素开始,依次将较大值向后交换一位,直至整个队列有序。

复杂度
和其他低效排序算法一样,平均时间复杂度是O(n^2)。最好的情况就是原队列就是排列好的数组,这个时候时间复杂度就是O(n)。空间复杂度为O(1),用于交换。
按顺序通过比较排序的算法都是稳定的,冒泡排序也是这样。

代码

package main

import (
    "time"
    "fmt"
    "math/rand"
)

func main() {
    var length = 15
    var list []int

    // 以时间戳为种子生成随机数,保证每次运行数据不重复
    r := rand.New(rand.NewSource(time.Now().UnixNano()))
    for i := 0; i < length; i++ {
        list = append(list, int(r.Intn(1000)))
    }
    fmt.Println(list)

    // n-1轮,每轮减少一位的比较
    for i := 1; i < length; i++ {
        // 每轮都从第一个元素开始,将最大的值交换到最后一位
        for j := 0; j < length-i; j++ {
            if list[j] > list[j+1] {
                list[j], list[j+1] = list[j+1], list[j]
            }
        }
        fmt.Println(list)
    }

}

运行结果

原文地址:http://blog.51cto.com/13022101/2152306

时间: 2024-12-17 03:48:10

[golang] 数据结构-冒泡排序的相关文章

数据结构-冒泡排序

#include <iostream> using namespace std; void BubbleSort(int* a,int n){ for(size_t i=0;i<n;i++){ for(size_t j=0;j<n-i;j++){ if(a[j] > a[j+1]){ int tmp = a[j]; a[j] = a[j+1]; a[j+1] = tmp; } } } } int main() { int a[] = {1,5,8,9,6,4,7,2,3,0}

golang数据结构之冒泡排序

//BubbleSort 冒泡排序 func BubbleSort(arr *[7]int) { for i := len(arr) - 1; i >= 0; i-- { for j := i; j >= 0; j-- { if (*arr)[j] > (*arr)[i] { (*arr)[j], (*arr)[i] = (*arr)[i], (*arr)[j] } } fmt.Printf("第%d趟的结果为:%v\n", len(arr)-1-i, *arr) }

1、golang之冒泡排序

1.冒泡排序时间复杂度 冒泡排序的时间复杂度是O(N2). 假设被排序的数列中有N个数.遍历一趟的时间复杂度是O(N),需要遍历多少次呢?N-1次!因此,冒泡排序的时间复杂度是O(N2). 2.冒泡排序稳定性 冒泡排序是稳定的算法,它满足稳定算法的定义. 算法稳定性 -- 假设在数列中存在a[i]=a[j],若在排序之前,a[i]在a[j]前面:并且排序之后,a[i]仍然在a[j]前面.则这个排序算法是稳定的! 3.示例 // golang func BubbleAsort(values []i

大话数据结构----冒泡排序Bubble sort

冒泡排序是排序算法中最基础的排序算法: 原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换 package com.neuedu.java; public class BubbleSort { public static void main(String[] args) { int [] arr=new int[]{0,9,5,45,12,94,56,7}; BubbleSort(arr); for(int i=0;i<arr.length;i++){ System.out.p

数据结构-冒泡排序算法

算法稳定性 冒泡排序就是把小的元素往前调或者把大的元素往后调.比较是相邻的两个元素比较,交换也发生在这两个元素之间.所以,如果两个元素相等,我想你是不会再无聊地把他们俩交换一下的:如果两个相等的元素没有相邻,那么即使通过前面的两两交换把两个相邻起来,这时候也不会交换,所以相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法.从大到小的冒泡排序 package structsmethod; /*  * 冒泡  */ public class BubbleSort { public void

大话数据结构——冒泡排序

#include<iostream> using namespace std; #define MAX_SIZE 100//用于排序数组个数的最大值 typedef struct { int r[MAX_SIZE+1];//用于存储要排序的数组 int length;//用于记录顺序表的长度 }sqlist; //用于交换数组r中下标i和下标j的数组元素的值 void swap(sqlist* L, int i,int j) { int temp; temp=L->r[i]; L->

数据结构-冒泡排序(Python&amp;java实现)

1. 冒泡算法的核心思想冒泡排序的核心思想就是扫描数据清单,找到乱序的两个相邻的数据进行两两比较并交换位置,然后继续扫描数据,接着反复重复上述的操作直至排序结束.2. 示例我们以23,15,58,-4,99,0这组无序的数字为例:例子为从小到大排序,初始状态:23,15,58, -4,99,0第一次排序结果:15,23,-4,58,0,99第二次排序结果:15,-4,23,0,58,99第三次排序结果:-4,15,0,23,58,99第四次排序结果:-4,0,15,23,58,99第五次排序结果

[golang] 数据结构-地精排序

碎碎念这是一个名字起得很随便的排序算法,是我我就叫他史莱姆排序ㄟ(▔,▔)ㄏ 原理地精排序是也是一种交换排序.它只进行一轮比较,在这轮比较中,遇到比较前面元素大就向后移动一位继续比较,遇到比前面值小就和前面的值交换,并向前移动一位. 复杂度对已经排序号的队列哥布林只需从头走到尾就结束了,所以最好情况时间复杂度就是O(n),平均的时间复杂度也和冒泡排序一样也是O(n^2). 代码 package main import ( "time" "fmt" "mat

[golang] 数据结构-鸡尾酒排序

吐个槽又是一个不正经取名的排序算法.真要说和鸡尾酒间的关系,大概就是想喝到鸡尾酒(得到排序好的队列)就要摇晃酒杯让不同的成分混合均匀(向两个方向冒泡排序) 原理鸡尾酒排序(Cocktail Sort)是冒泡排序的一种优化算法.原本的冒泡排序只能在一轮中挑出一个值移动到最后,而鸡尾酒则可以在一轮里挑最大的移到最后,再挑最小的移到最前面.实际上就是先正向进行一轮普通的冒泡排序,然后再逆向进行一轮反向冒泡,每轮冒泡都缩小一点范围. 复杂度最好情况是正序排列的数列O(n),最坏情况是逆序O(n^2),平