数据结构——排序算法

一、排序

• 将数据放置在某个数据结构中存储起来后(如数组), 根据需求对数据进行不同方式的排序

排序算法:

冒泡排序/选择排序/插入排序/归并排序/计数排序/基数排序/希尔排序/堆排序/桶排序等

（一）简单排序

   1.冒泡排序

//冒泡排序
   bubbleSort() {
                //控制趟数 控制次数
                for (let i = 0; i < this.item.length - 1; i++) {
            
                    for (let j = 0; j < this.item.length - 1 - i; j++) {
                        //相邻元素比较  交换
                        if (this.item[j + 1] < this.item[j]) {
                            this.swap(j, j + 1)
                        }
                    }
                }
            }
     swap(m, n) {
                //交换两个位置的值
                let temp = this.item[n]
                this.item[n] = this.item[m]
                this.item[m] = temp
            }

 代码图解流程：

 代码测试：

   2.选择排序

//选择排序
   selectionSort() {
                for (let i = 0; i < this.item.length - 1; i++) {
                    let min = i
                    for (let j = i+1; j < this.item.length; j++) {
                        if (this.item[j] < this.item[min]) {
                            min = j
                        }
                    }
                    this.swap(i, min)
                }
            }
    swap(m, n) {
                //交换两个位置的值
                let temp = this.item[n]
                this.item[n] = this.item[m]
                this.item[m] = temp
            }

 代码测试：

 

   3.插入排序

//插入排序
            insertionSort() {
                for (let i = 1; i < this.item.length; i++) {
                    let j = i;
                    let mark = this.item[i];

                    while (this.item[j - 1] > mark && j > 0) {
                        this.item[j] = this.item[j - 1];
                        j--;
                    }

                    this.item[j] = mark
                }
            }

代码测试： 

（二）高级排序

   1.快速排序--分而治之

//快速排序--分而治之
   quickSort() {
                this.item = this.quick(this.item)
            }
            quick(arr) {
                 //如果数组<=1,则直接返回
                if (arr.length <= 1) {
                    return arr
                } else {
                    //分
                    let index = Math.floor(arr.length / 2)
                    //找基准，并把基准从原数组删除
                    let middle = arr.splice(index, 1)[0]
                    //定义左右数组
                    let leftarr = [],
                        rightarr = []
                    //比基准小的放在left，比基准大的放在right
                    for (let i = 0; i < arr.length; i++) {
                        if (arr[i] < middle) {
                            leftarr.push(arr[i])
                        } else {
                            rightarr.push(arr[i])
                        }
                    }
                 //递归
                    return this.quick(leftarr).concat(middle, this.quick(rightarr))
                }
            }

 测试代码：

   2.归并排序--分而治之

       基本思想与过程：先递归的分解数列，再合并数列

//归并排序--分而治之
            mergerSort() {
                this.item = this.divide(this.item)
            }
            divide(arr) {
                if (arr.length <= 1) {
                    return arr
                } else {
                    //分
                    let index = Math.floor(arr.length / 2)
                    let leftarr = arr.slice(0, index)
                    let rightarr = arr.slice(index)

                    this.merger(this.divide(leftarr), this.divide(rightarr))
                }
            }
            merger(left, right) {
                //合
                let newarr = []

                while (left.length && right.length) {
                    if (left[0] < right[0]) {
                        newarr.push(left.shift())
                    } else {
                        newarr.push(right.shift())
                    }
                }
                return newarr.concat(left, right)
            }

 测试代码：

二、搜索算法

1.顺序查找

 //顺序查找
       inturnSearch(ele) {
                for (let i = 0; i < this.item.length; i++) {
                    if (this.item[i] == ele) {
                        return true
                    }

                }
                return false
            }

 测试代码：

2.二分查找

//二分法查找--必须有序
        binarySearch(ele) {
                let start = 0
                let end = this.item.length - 1

                if (ele < this.item[start] || ele > this.item[end]) return false

                while (start <= end) {
                    let middle = Math.floor((start + end) / 2)
                    
                    if (ele < this.item[middle]) {
                        end = middle - 1
                    } else if (ele > this.item[middle]) {
                        start = middle + 1
                    } else {
                        return true
                    }
                }
                return false
            }

测试代码：