第 54 题：冒泡排序如何实现，时间复杂度是多少，还可以如何改进？ #94

zeroone001 · 2019-04-14T23:39:07Z

时间复杂度： n^2

// 生成从l到r的数量为n的随机数组
function randomArr (n, l, r) {
    let arr = [];
    for (let i = 0; i < n; i++) {
        let _random = Math.round(l + Math.random() * (r - l));
        arr.push(_random)
    } 
    return arr;
}
function buddleSort (arr) {
    let len = arr.length;
    for (let i = len;  i >= 2;  i-- ) {
        for (let j = 0;  j < i - 1;  j++) {
             if (arr[j] > arr[j+1]) {
                  [arr[j], arr[j+1]] = [arr[j+1], arr[j]];
             }
        }
    }
    return arr;
}
console.log(buddleSort(randomArr(10, 5, 100)));

admin00001 · 2019-04-15T01:32:42Z

刚好这有一篇文章解答了今天面试题https://www.jianshu.com/p/5d44186b5263

Ray-56 · 2019-04-15T02:21:43Z

function bubbleSort(arr) {
    for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                const temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    console.log(arr);
}

// 改进冒泡排序
function bubbleSort1(arr) {
    let i = arr.length - 1;

    while (i > 0) {
        let pos = 0;
        for (let j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                pos = j;
                const temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        i = pos;
    }
    console.log(arr);
}

Ray-56 · 2019-04-15T03:08:44Z

补充一个

function bubbleSort2(arr) {
    let low = 0;
    let high = arr.length - 1;
    let temp, j;

    while (low < high) {
        // 正排找最大
        for (j = low; j < high; ++j) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        --high;

        // 反排找最小
        for (j = high; j > low; --j) {
            if (arr[j] < arr[j - 1]) {
                temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
            }
        }
        ++low;
    }
    console.log(arr);
}

xbcc123 · 2019-04-15T03:15:08Z

时间复杂度： O(n2)
let arr = [ 2, 3, 4, 44, 9, 4, 3, 2, 5, 1, 65, 2, 3, 6 ]
	for(let i = 0; i < arr.length; i++ ) {
		for(let j = i + 1; j < arr.length; j++) {
			if(arr[i] > arr[j]) {
				let beforeVar = arr[i]
				arr[i] = arr[j]
				arr[j] = beforeVar
			}
		}	
	}

Haru1990 · 2019-04-15T03:30:53Z

冒泡排序

/**
* @param {Array} arr 待排序数组
* @returns {Array}
*/
function bubbleSort(arr) {
     for (var i = 0, len = arr.length; i < len;  i++) {
          for (var j = i + 1;  j < len;  j++) {
               if (arr[i] > arr[j]) {
                    var temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
               }
          }
     }
     return arr;
}

时间复杂度（大O计数法）：O(n^2)

通常说的时间复杂度是指的最坏的情况。具体解析如下：

两层for循环，假如每一次if条件都满足，就是需要执行 n * (n-1) * 3 次，取最高次项后常数系数变为1之后可以得到时间复杂度为 n^2

ChuYang-FE · 2019-04-15T04:15:14Z

fengjinlong · 2019-04-15T06:11:50Z

我喜欢

xsf0105 · 2019-04-15T07:06:12Z

function sort(values) {
  var origValues = values.slice();
  do {
    var swapped = false;
    for(var i = 0; i < origValues.length - 1; ++i) {
      if (origValues[i] > origValues[i+1]) {
		[origValues[i], origValues[i+1]] = [origValues[i+1], origValues[i]]
        swapped = true;
      }
    }
  }
  while(swapped === true);
  return origValues
}

haiifeng · 2019-04-16T05:52:09Z

时间复杂度： n^2

// 生成从l到r的数量为n的随机数组
function randomArr (n, l, r) {
    let arr = [];
    for (let i = 0; i < n; i++) {
        let _random = Math.round(l + Math.random() * (r - l));
        arr.push(_random)
    } 
    return arr;
}
function buddleSort (arr) {
    let len = arr.length;
    for (let i = len;  i >= 2;  i-- ) {
        for (let j = 0;  j < i - 1;  j++) {
             if (arr[j] > arr[j+1]) {
                  [arr[j], arr[j+1]] = [arr[j+1], arr[j]];
             }
        }
    }
    return arr;
}
console.log(buddleSort(randomArr(10, 5, 100)));

bubble

mengsixing · 2019-04-16T12:59:05Z

function bubbleSort(arr) {
    for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                const temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    console.log(arr);
}

// 改进冒泡排序
function bubbleSort1(arr) {
    let i = arr.length - 1;

    while (i > 0) {
        let pos = 0;
        for (let j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                pos = j;
                const temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        i = pos;
    }
    console.log(arr);
}

@guokangf 这个改良算法能解释一下吗？

lzbSun · 2019-04-22T03:07:59Z

// 冒泡排序
const bubbleSort = (array) => {
  const newArray = [...array]
  const len = newArray.length
  if (len <= 1) return 
  let isChange = false
  for(let i = 0; i < len; i++) {

    for (let j = i; j < len - i - 1; j++) {
      if (newArray[j + 1] < newArray[j]) {
        let temp = newArray[j + 1]
        newArray[j + 1] = newArray[j]
        newArray[j] = temp
        isChange = true
      }
    }

    if (!isChange) break

  }
  return newArray
}

时间复杂度 O(n^2)

ablikim915 · 2019-04-24T14:45:17Z

function random(n,x,y){
  let arr = [];
  for(let i = 0; i < n; i++){
    let num = (x + Math.random() * (y - x)) | 0;
    arr.push(num);
  }
  return arr;
};
function sort(arr){
  let leng = arr.length;
  for(let i = 0; i < leng; i++){
    for(let j = 0; j < leng - i - 1; j++){
      if(arr[j] > arr[j + 1]){
        let tmp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = tmp; 
      }
    }
  }
  return arr;
}
console.log(sort(random(5,5,50)));

练个手

chengshenghua · 2019-04-28T02:06:27Z

arr = [5,4,22,33,11,66]
arr.sort(function(a,b){
return a-b })
console.log(arr)

raven3005672 · 2019-05-10T09:54:09Z

function bubbleSort(arr) {
    for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                const temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    console.log(arr);
}

// 改进冒泡排序
function bubbleSort1(arr) {
    let i = arr.length - 1;

    while (i > 0) {
        let pos = 0;
        for (let j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                pos = j;
                const temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        i = pos;
    }
    console.log(arr);
}

@guokangf 这个改良算法能解释一下吗？

每次最大值放到最右后，会将本轮最后一个操作的位置作为下一轮的终点，可以减少不必要的一些冒泡

dingLeiOnly · 2019-05-17T09:15:57Z

for (let i = 0;i < ary.length;i++) {
       for (let j = 0;j < ary.length - i - 1;j++) {
            if (ary[j] > ary[j + 1]) [ary[j], ary[j + 1]] = [ary[j + 1], ary[j]];
       }
 }

MTStark · 2019-07-12T09:20:27Z

var bubbleSort = function(arr) {
		var temp = null;
		for (var i=arr.length-1;i>=0;i--){
			var flag = true; // 循环开始时设置一个flag为true，若在一个循环中没有发生交换，则数组已经有序，可以直接退出
			for (var j=0;j<i;j++) {
				if(arr[j]>arr[j+1]){
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
					flag = false;
				}
			}
			if(flag) break;
		}
		return arr;
	}

yuyueMidea · 2019-07-16T12:32:28Z

长知识了~

wwwxy80s · 2019-07-18T16:59:26Z

function bubbleSort(arr) {
    for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                const temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    console.log(arr);
}

// 改进冒泡排序
function bubbleSort1(arr) {
    let i = arr.length - 1;

    while (i > 0) {
        let pos = 0;
        for (let j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                pos = j;
                const temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        i = pos;
    }
    console.log(arr);
}

@guokangf 这个改良算法能解释一下吗？

根据上述代码，我们每一轮冒泡需要的结果就是把最大的数通过冒泡放到最后，然后缩小下一轮需要冒泡的数组的范围（未优化的方案中数组范围只缩小了一位），但是实际上我们每一轮冒泡后可能会出现后面的几个数都有序的情况，这个时候我们完全可以再缩小一点下一次需要冒泡的数组的范围（不然下一轮冒泡到最后发现最大的数本来就在最后，此次冒泡就是多余的）。那怎么确定这个i值呢？

举个栗子：
[a[0],...,a[j],a[j+1],...,a[i]]
如果某一次冒泡比较中a[j]>a[j+1]
交换两值，此时a[j+1]大于a[0]到a[j]的任何值（a[0]到a[j]还是无序的）
如果再接下来的冒泡中满足a[j+1]到a[i]有序，即不做任何交换操作（a[j]和a[j+1]是最后一次交换操作）
那我们下一轮只需要对a[0]到a[j]的无序数组进行冒泡排序，j就是下一轮循环的i值

longfeiyu127 · 2019-07-23T03:50:39Z

@wwwxy80s 我这边的冒泡排序的改良思路是，如果某一次遍历，没有进入过if条件，则表示已经是排好的顺序了，跳出循环

Jesseszhang · 2019-11-14T07:11:08Z

function bubbleSort(arr) {
  for (let i = 0; i < arr.length - 1; i++) {
    for (let j = 0; j < arr.length - 1 - i; j++) {  // 此处还需要减去i 每一次排序都会排序好i 个数据
      let temp = '';
      if (arr[j] > arr[j + 1]) {
        temp = arr[j]
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
  return arr;
}
bubbleSort([1,4,3,5,2,10,8,9])

function bubbleSort2(arr) {
  for (let i = 0; i < arr.length - 1; i++) {
    let finish = true;
    let pos = 0;
    let len = arr.length - 1 - i;
    for(let j = 0; j < len; j++) {
      let temp = '';
      if (arr[j] > arr[j + 1]) {
        temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
        finish = false; // 是否还有交换 ，没有互换则代表排序排好了
        pos = j // 最后一次交换的位置，之后的数据不需要再遍历
      }
    }
    len = pos;
    if (finish) {
      break;
    }
  }
  return arr;
}
bubbleSort2([1,4,3,5,2,10,8,9])

lovelmh13 · 2020-02-07T09:47:27Z

时间复杂度： O(n^2)

一般的冒泡：

function bubbleSort1(arr) {
	for (let i = 0; i < arr.length - 1; i++) {
		for (let j = 0; j < arr.length - 1; j++) {
			if (arr[j] > arr[j + 1]) {
				[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
			}
		}
	}
}

这个存在的问题是，每次循环一次，后面就会多一段有序的数组，然而每次还是遍历了，是多余了

优化一下这个问题

function bubbleSort2(arr) {
	// i是j需要遍历的次数，并不用i来遍历内容。
	// 这样，每次会把上一次排过的数组滤过，只排列前面还没有排列的部分
	// 每一次j就可以少遍历一次
	for (let i = arr.length-1; i >= 0; i--) {	
		for (let j = 0; j < i; j++) {
			if (arr[j] > arr[j + 1]) {
				[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
			}
		}
	}
}

对于这个方案，还可以改进
如果剩下的还没有排序的部分，本身就是有序的，也可以让遍历跳过，就又可以省下不少时间
例如这种： let a = [1, 2, 3, 4, 5, 6, 3, 11, 12, 9, 5, 8, 7, 23, 6, 8, 9];

function bubbleSort3(arr) {
	var swapedFlag;
	for (var i = arr.length - 1; i >= 0; i--) {
		swapedFlag = false;
		for (var j = 0; j < i; j++) {
			if (arr[j] > arr[j + 1]) {
				swapedFlag = true;
				[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
			}
		}
		// 如果j遍历，从头到尾都没有把swapedFlag置为true，就证明剩下的一段数组，本来就是按顺序的，就不用再遍历了
		if (!swapedFlag) {
			break;
		}
	}
}

Gumplefik · 2020-04-18T07:59:49Z

普通：冒泡排序
改良：鸡尾酒排序（就是先向上冒个泡，再向下冒个泡，如此重复）

cutie6 · 2020-06-27T08:26:03Z

```js
function bubbleSort(arr) {
    for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                const temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    console.log(arr);
}

// 改进冒泡排序
function bubbleSort1(arr) {
    let i = arr.length - 1;

    while (i > 0) {
        let pos = 0;
        for (let j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                pos = j;
                const temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        i = pos;
    }
    console.log(arr);
}

@guokangf 这个改良算法能解释一下吗？

每次最大值放到最右后，会将本轮最后一个操作的位置作为下一轮的终点，可以减少不必要的一些冒泡

标准实现中的 j < arr.length - i - 1; 循环条件不已经达到这个目的了吗？？

fariellany · 2020-07-02T10:29:23Z

function bubbleSort(arr) {
    for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                const temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    console.log(arr);
}

// 改进冒泡排序
function bubbleSort1(arr) {
    let i = arr.length - 1;

    while (i > 0) {
        let pos = 0;
        for (let j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                pos = j;
                const temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        i = pos;
    }
    console.log(arr);
}

这个改进版是不是每次取最后一次调换位置的下标作为下一次循环的长度？？？？？

fariellany · 2020-07-02T10:37:56Z

```js
function bubbleSort(arr) {
    for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                const temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    console.log(arr);
}

// 改进冒泡排序
function bubbleSort1(arr) {
    let i = arr.length - 1;

    while (i > 0) {
        let pos = 0;
        for (let j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                pos = j;
                const temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        i = pos;
    }
    console.log(arr);
}

@guokangf 这个改良算法能解释一下吗？
每次最大值放到最右后，会将本轮最后一个操作的位置作为下一轮的终点，可以减少不必要的一些冒泡

标准实现中的 j < arr.length - i - 1; 循环条件不已经达到这个目的了吗？？

不一样的改良版的可以跳跃的 j < arr.length - i - 1 标准的是每次都是一次递减的，不管是不是存在部分冒泡好的

523451928 · 2020-07-14T03:17:26Z

function bubbleSort(arr) {
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr.length - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
      }
    }
  }
  return arr
}
bubbleSort([3, 1, 15, 7, 5])

gitwillsky · 2020-08-20T13:55:11Z

另一种写法：

function bubbleSortV2(arr) {
  if (!arr || !arr.length) {
    return [];
  }

  for (let r = arr.length-1; r > 0; ) {
    let tempIndex = 0;
    for (let l = 0; l < r; l++) {
      if (arr[l] > arr[l + 1]) {
        // 缩小需要冒泡的范围
        tempIndex = l;
        [arr[l], arr[l + 1]] = [arr[l + 1], arr[l]];
      }
    }
    // 更新冒泡范围
    r = tempIndex;
  }
}

ysyfff · 2020-12-17T12:58:48Z

冒泡排序概念：依次比较相邻的两个元素，如果顺序倒置则交换相邻元素。🤣🤣🤣

tsnake520 · 2021-01-21T02:42:34Z

function bubbleSort(array) {
    if (!Array.isArray(array)) {
        throw new TypeError('train.js:bubbleSort() arguments is not Array');
    }

    let length = array.length,
         cycleIndex = Math.ceil(length / 8),
         complementNnumber = length % 8 - 1;

    for (let i = 0; i < length; i++) {
        let j = 0, 
             iteration = cycleIndex,
             startAt = complementNnumber;

        do {
            switch (startAt) {
                case 0: swap(j, j + 1), j++;
                case 7: swap(j, j + 1), j++;
                case 6: swap(j, j + 1), j++;
                case 5: swap(j, j + 1), j++;
                case 4: swap(j, j + 1), j++;
                case 3: swap(j, j + 1), j++;
                case 2: swap(j, j + 1), j++;
                case 1: swap(j, j + 1); j++;
            }

            startAt = 0;
        } while (--iteration > 0);
    }

    function swap(i, j) {
        if (array[i] > array[j]) {
            let temp = array[i];
            array[i] = array[j],
            array[j] = temp;
        }
    }

    return array;
}

tchen-l · 2021-06-10T06:58:53Z

刚好这有一篇文章解答了今天面试题https://www.jianshu.com/p/5d44186b5263

这篇文章里面的 break 应该换成 continue

Soyn · 2021-08-03T13:39:51Z

const getRandomArray = (max = 100, len = 10) => {
  return Array.from(new Array(len)).map(() => Math.floor(Math.random() * max));
};

const solution = (a = []) => {
  let len = a.length;
  const t0 = performance.now();
  let swapped = false;
  do {
    swapped = false;
    for (let i = 1; i < len; i += 1) {
      if (a[i] < a[i - 1]) {
        [a[i], a[i - 1]] = [a[i - 1], a[i]];
        swapped = true;
      }
    }
  } while (swapped);
  const t1 = performance.now();
  console.log("time: ", t1 - t0);
  return a;
};

const solution1 = (a = []) => {
  let len = a.length;
  let swapped = false;
  const t0 = performance.now();
  do {
    swapped = false;
    for (let i = 1; i < len; i += 1) {
      if (a[i] < a[i - 1]) {
        [a[i], a[i - 1]] = [a[i - 1], a[i]];
        swapped = true;
      }
    }
    len -= 1;
  } while (swapped);
  const t1 = performance.now();
  console.log("time: ", t1 - t0);
  return a;
};

const solution2 = (a = []) => {
  let len = a.length;
  const t0 = performance.now();
  do {
    let newLen = 0;
    for (let i = 1; i < len; i += 1) {
      if (a[i] < a[i - 1]) {
        [a[i], a[i - 1]] = [a[i - 1], a[i]];
        newLen = i;
      }
    }
    len = newLen;
  } while (len > 1);
  const t1 = performance.now();
  console.log("time: ", t1 - t0);
  return a;
};

const a = getRandomArray(10000, 1000);
solution(a.slice());
solution1(a.slice());
solution2(a.slice());

Reference

Bubble Sort

jackluson · 2021-09-09T03:34:23Z

Tip:

冒泡则是在每一层遍历过程中找出最大的那个数（通过相邻比较，移动）

算法复杂度：O(n2)，可以通过空间换取时间方法--记录每一次遍历的第二大数索引，下一次遍历从第二大数索引位置开始遍历

let arr = [10, 80, 40, 60, 30, 90, 40, 50, 85];

const bubbleSort = (arr) => {
  for (let i = 0; i < arr.length - 1; i++) {
    for (let j = 0; j < arr.length - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
      }
    }
  }
};

const bubbleSortPlus = (arr) => {
  let second_max_pos = 0; // 存储每次遍历的第二大数索引
  for (let i = 0; i < arr.length - 1; i++) {
    let j = second_max_pos; // 从每次遍历之后的第二大数的索引开始遍历
    second_max_pos = 0; // 每次第二层遍历开始前重置
    for (j; j < arr.length - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
        if (arr[j] > arr[second_max_pos]) {
          second_max_pos = j;
        }
      }
    }
  }
};

bubbleSortPlus(arr);

更多解析

sionnigjt · 2021-09-28T10:14:10Z

function bubbleSort1(array) {
    //常规冒泡排序
    for (let i = 0; i < array.length; i++) {
        for (let j = i; j < array.length - 1; j++) {
            if (array[j] > array[j + 1]) {
                array[j + 1] = array[j + 1] ^ array[j]
                array[j] = array[j + 1] ^ array[j]
                array[j + 1] = array[j + 1] ^ array[j]
            }
        }

    }

}
function bubbleSort2(array) {
    //思路 :寻找每一次冒泡排序后最后一次交换的下标,减少排序次数
    let i = array.length - 1;
    while (i > 0) {
        let index = 0
        for (let j = 0; j < i; j++) {
            if (array[j] > array[j + 1]) {
                index=j
                array[j + 1] = array[j + 1] ^ array[j]
                array[j] = array[j + 1] ^ array[j]
                array[j + 1] = array[j + 1] ^ array[j]
            }
            
        }
        i = index;
    } 
}
let array = [1, 3, 2, 4, 11, 23, 3, 35, 7, 8,"2",'2',[5],(1),{"6":1}]
bubbleSort2(array)
console.log(array);

输出
[ 1, 1, 2, 2, 2, 3, 3, 4, 5, 7, 8, 11, 23, 35, { '6': 1 } ]
所以为啥??[5]不见了

AKclown · 2022-06-11T06:51:19Z

// 优化版本

function  sort(arr[]){
  for( int i = 0;i < arr.length - 1 ; i++ ){
          boolean isSort = true; // 关键
          for( int j = 0;j < arr.length - 1 - i ; j++ ){
              int temp = 0;
              if(arr[j] < arr[j + 1]){
                  temp = arr[j];
                  arr[j] = arr[j + 1];
                  arr[j + 1] = temp;
                  isSort = false;
              }
          }
          if(isSort){
              break;
          }
      }
}

yygmind mentioned this issue Jul 14, 2019

前端 100 问：能搞懂80%的请把简历给我 yygmind/blog#43

Open

yygmind added the 编程题 label Dec 16, 2019

lovelmh13 mentioned this issue Feb 7, 2020

冒泡排序如何实现，时间复杂度是多少，还可以如何改进？ lovelmh13/One-question-a-day#30

Open

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

第 54 题：冒泡排序如何实现，时间复杂度是多少，还可以如何改进？ #94

第 54 题：冒泡排序如何实现，时间复杂度是多少，还可以如何改进？ #94

zeroone001 commented Apr 14, 2019 •

edited

Loading

admin00001 commented Apr 15, 2019

Ray-56 commented Apr 15, 2019

Ray-56 commented Apr 15, 2019

xbcc123 commented Apr 15, 2019 •

edited

Loading

Haru1990 commented Apr 15, 2019 •

edited

Loading

ChuYang-FE commented Apr 15, 2019

fengjinlong commented Apr 15, 2019

xsf0105 commented Apr 15, 2019 •

edited

Loading

haiifeng commented Apr 16, 2019

mengsixing commented Apr 16, 2019

lzbSun commented Apr 22, 2019

ablikim915 commented Apr 24, 2019 •

edited

Loading

chengshenghua commented Apr 28, 2019

raven3005672 commented May 10, 2019

dingLeiOnly commented May 17, 2019 •

edited

Loading

MTStark commented Jul 12, 2019

yuyueMidea commented Jul 16, 2019

wwwxy80s commented Jul 18, 2019

longfeiyu127 commented Jul 23, 2019

Jesseszhang commented Nov 14, 2019 •

edited

Loading

lovelmh13 commented Feb 7, 2020

Gumplefik commented Apr 18, 2020

cutie6 commented Jun 27, 2020

fariellany commented Jul 2, 2020

fariellany commented Jul 2, 2020

523451928 commented Jul 14, 2020

gitwillsky commented Aug 20, 2020 •

edited

Loading

ysyfff commented Dec 17, 2020

tsnake520 commented Jan 21, 2021

tchen-l commented Jun 10, 2021

Soyn commented Aug 3, 2021

jackluson commented Sep 9, 2021

sionnigjt commented Sep 28, 2021

AKclown commented Jun 11, 2022

第 54 题：冒泡排序如何实现，时间复杂度是多少， 还可以如何改进？ #94

第 54 题：冒泡排序如何实现，时间复杂度是多少， 还可以如何改进？ #94

Comments

zeroone001 commented Apr 14, 2019 • edited Loading

admin00001 commented Apr 15, 2019

Ray-56 commented Apr 15, 2019

Ray-56 commented Apr 15, 2019

xbcc123 commented Apr 15, 2019 • edited Loading

Haru1990 commented Apr 15, 2019 • edited Loading

冒泡排序

时间复杂度（大O计数法）：O(n^2)

ChuYang-FE commented Apr 15, 2019

fengjinlong commented Apr 15, 2019

xsf0105 commented Apr 15, 2019 • edited Loading

haiifeng commented Apr 16, 2019

mengsixing commented Apr 16, 2019

lzbSun commented Apr 22, 2019

ablikim915 commented Apr 24, 2019 • edited Loading

chengshenghua commented Apr 28, 2019

raven3005672 commented May 10, 2019

dingLeiOnly commented May 17, 2019 • edited Loading

MTStark commented Jul 12, 2019

yuyueMidea commented Jul 16, 2019

wwwxy80s commented Jul 18, 2019

longfeiyu127 commented Jul 23, 2019

Jesseszhang commented Nov 14, 2019 • edited Loading

lovelmh13 commented Feb 7, 2020

Gumplefik commented Apr 18, 2020

cutie6 commented Jun 27, 2020

fariellany commented Jul 2, 2020

fariellany commented Jul 2, 2020

523451928 commented Jul 14, 2020

gitwillsky commented Aug 20, 2020 • edited Loading

ysyfff commented Dec 17, 2020

tsnake520 commented Jan 21, 2021

tchen-l commented Jun 10, 2021

Soyn commented Aug 3, 2021

Reference

jackluson commented Sep 9, 2021

sionnigjt commented Sep 28, 2021

AKclown commented Jun 11, 2022

第 54 题：冒泡排序如何实现，时间复杂度是多少，还可以如何改进？ #94

第 54 题：冒泡排序如何实现，时间复杂度是多少，还可以如何改进？ #94

zeroone001 commented Apr 14, 2019 •

edited

Loading

xbcc123 commented Apr 15, 2019 •

edited

Loading

Haru1990 commented Apr 15, 2019 •

edited

Loading

xsf0105 commented Apr 15, 2019 •

edited

Loading

ablikim915 commented Apr 24, 2019 •

edited

Loading

dingLeiOnly commented May 17, 2019 •

edited

Loading

Jesseszhang commented Nov 14, 2019 •

edited

Loading

gitwillsky commented Aug 20, 2020 •

edited

Loading