java、kotlin 记录冒泡排序，二分查找，单向链表反序

冒泡排序

    fun bubbleSort(arr: IntArray) {
        for (i in 0 until arr.size - 1) {
            for (j in 0 until arr.size - 1 - i) {
                var temp: Int
                if (arr[j + 1] > arr[j]) {
                    temp = arr[j + 1]
                    arr[j + 1] = arr[j]
                    arr[i] = temp
                }
            }
        }
    }

简单的解释一下，第二层循环一轮下来，会找出最小的，并且会放在数组的最右边。

所以每当i变大，第二层循环就会不去跟后面的去比较，因为已经选出了最小的了。这也是冒泡的精髓。

 

二分查找

    fun binSearch(arr: IntArray, key: Int): Int {
        var imd = arr.size / 2
        if (key == arr[imd]) {
            return imd
        }
        var start = 0
        var end = arr.size - 1
        while (start <= end) {
            imd = (end - start) / 2 + start
            when {
                key > arr[imd] -> start = imd + 1
                key < arr[imd] -> end = imd - 1
                else -> return imd
            }
        }
        return -1
    }

先看数组最中间的数，是否和key相等，不想等的话，则到达while循环。

当然开始都会先计算中间数的下标，然后比较，该往哪边查询。

 

单向链表反序

    class Note {
        public var note: Note? = null
        var data: Int = 0
    }



    //note的下一个是current，而current的下一个是currentNext
    fun reverse(note: Note) {
        var current = note.note
        note.note = null
        var head = note
        while (current != null) {
            val currentNext = current.note
            //翻转指向
            current.note = head
            //记录每一次的上一轮
            head = current
            //记录下一指向
            current = currentNext
        }
    }

 

这个有点绕口，因为要逆序，所以 note的下一个也就是current要指向note，current的下个currentNext要指向current。

关键是while循环的，可以看成是上一个、现在、下一个 的一个循环记录，直到没有下一个为止。