Leetcode 算法面试冲刺 实战 四（数组与循环）（十一）

485 · 生成给定大小的数组

给你一个大小size,生成一个元素从1 到 size的数组

def generate(self, size):
        # write your code here
        if size <= 0: return []
        return [i for i in range(1, size + 1)]

484 · 交换数组两个元素

给你一个数组和两个索引，交换下标为这两个索引的数字

注意特殊情况，一定要考虑，养成习惯。

def swapIntegers(self, A, index1, index2):
        # write your code here
        if index1 < 0 or index1 > len(A) - 1:
            pass
        elif index2 < 0. or index2 > len(A) - 1:
            pass
        else:
            A[index1], A[index2] = A[index2], A[index1]

优化后代码：要不断的去优化自己的代码，并且吸取别人代码好的地方。

def swapIntegers(self, A, index1, index2):
        # write your code here
        if (index1 >= 0 and index1 < len(A)) and (index2 >= 0 or index2 < len(A)):
            A[index1], A[index2] = A[index2], A[index1]

463 · 整数排序

给一组整数，按照升序排序，使用选择排序，冒泡排序，插入排序或者任何 O(n2) 的排序算法。

冒泡

def sortIntegers(self, A):
        # write your code here
        for i in range(len(A) - 1):
            for j in range(i + 1, len(A)):
                if A[i] > A[j]:
                    A[i], A[j] = A[j], A[i]
        return A

下面是一个大佬写的：
冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序（适用于正数排序）

class Solution:
    """
    @param A: an integer array
    @return: nothing
    """
    def sortIntegers(self, A):
        # write your code here
        if A == None or len(A) == 0:
            return
        A.sort()
        
# Bubble Sort
class Solution:
    def sortIntegers(self, A):
        if A == None or len(A) == 0:
            return
        
        for i in range(len(A) - 1):
            for j in range(len(A) - 1 - i):
                if A[j] > A[j + 1]:
                    A[j], A[j + 1] = A[j + 1], A[j]
                    
# Selection Sort
class Solution:
    def sortIntegers(self, A):
        if A == None or len(A) == 0:
            return
        for i in range(len(A)):
            tmp = i
            for j in range(i + 1, len(A)):
                if A[j] < A[tmp]:
                    tmp = j
            A[i], A[tmp] = A[tmp], A[i]

# Insertion Sort
class Solution:
    def sortIntegers(self, A):
        if A == None or len(A) == 0:
            return
        for i in range(1, len(A)):
            for j in range(i - 1, -1, -1):
                if A[i] < A[j]:
                    A[i], A[j] = A[j], A[i]
                    i = j
                else:
                    break


# Shell Sort
class Solution:
    def sortIntegers(self, A):
        if A == None or len(A) == 0:
            return
        dk = len(A) // 2
        while dk >= 1:
            self.InsertSort(A, dk)
            dk = dk // 2
            
    def InsertSort(self, A, dk):
        for i in range(dk):
            for j in range(i, len(A), dk):
                for k in range(j - 1, -1, -dk):
                    if A[j] < A[k]:
                        A[j], A[k] = A[k], A[j]
                        j = k
                    else:
                        break

# Merge Sort
class Solution:
    def sortIntegers(self, A):
        if A == None or len(A) == 0:
            return
        tmp = [0] * len(A)
        self.mergeSort(A, 0, len(A) - 1, tmp)
        
    def mergeSort(self, A, start, end, tmp):
        if start >= end:
            return
        
        self.mergeSort(A, start, (start + end) // 2, tmp)
        self.mergeSort(A, (start + end) // 2 + 1, end, tmp)
        
        self.merge(A, start, end, tmp)
        
    def merge(self, A, start, end, tmp):
        mid = (start + end) // 2
        leftIndex = start
        rightIndex = mid + 1
        index = leftIndex
        
        while leftIndex <= mid and rightIndex <= end:
            if A[leftIndex] <= A[rightIndex]:
                tmp[index] = A[leftIndex]
                leftIndex += 1
            else:
                tmp[index] = A[rightIndex]
                rightIndex += 1
            index += 1
            
        while leftIndex <= mid:
            tmp[index] = A[leftIndex]
            index += 1
            leftIndex += 1
        while rightIndex <= end:
            tmp[index] = A[rightIndex]
            index += 1
            rightIndex += 1
            
        for index in range(start, end + 1):
            A[index] = tmp[index]

# Quick Sort
class Solution:
    def sortIntegers(self, A):
        if A == None or len(A) == 0:
            return
        self.quickSort(A, 0, len(A) - 1)
        
    def quickSort(self, A, start, end):
        if start >= end:
            return
        
        left, right = start, end
        pivot = A[(start+end)//2]
        
        while left <= right:
            while left <= right and A[left] < pivot:
                left += 1
            while left <= right and A[right] > pivot:
                right -= 1
                
            if left <= right:
                A[left], A[right] = A[right], A[left]
                left += 1
                right -= 1
                
        self.quickSort(A, start, right)
        self.quickSort(A, left, end)

# Heap Sort
class Solution:
    def sortIntegers(self, A):
        if A == None or len(A) == 0:
            return
        A.insert(0, 0)

        lenA = len(A) - 1
        dk = lenA // 2
        for i in range(dk):
            self.heapAdjust(A, dk - i, lenA)

        for i in range(lenA - 1):
            A[1], A[lenA - i] = A[lenA - i], A[1]
            self.heapAdjust(A, 1, lenA - i - 1)

        A.remove(0)

    def heapAdjust(self, A, start, end):
        tmp = A[start]

        i = start
        j = 2 * i

        while j <= end:
            if j < end and A[j] < A[j + 1]:
                j += 1
            if tmp < A[j]:
                A[i] = A[j]
                i = j
                j = 2 * i
            else:
                break

        A[i] = tmp

# Counting Sort
class Solution:
    def sortIntegers(self, A):
        if A == None or len(A) == 0:
            return
        
        minA = min(A)
        maxA = max(A)

        L = [0] * (maxA - minA + 1)

        for i in range(len(A)):
            L[A[i] - minA] += 1

        index = 0
        for i in range(len(L)):
            while L[i] > 0:
                A[index] = minA + i
                index += 1
                L[i] -= 1

# Bucket Sort
class Solution:
    def sortIntegers(self, A):
        if A == None or len(A) == 0:
            return

        n = 100
        new_list = [[] for _ in range(n)]
        minA = min(A)

        for data in A:
            index = (data - minA) // 100
            new_list[index].append(data)

        for i in range(n):
            new_list[i].sort()

        index = 0
        for i in range(n):
            for j in range(len(new_list[i])):
                A[index] = new_list[i][j]
                index += 1

# Radix Sort
# Suitable for positive sorting
class Solution:
    def sortIntegers(self, A):
        if A == None or len(A) == 0:
            return
        
        maxA = max(A)

        d = 0
        while maxA // 10 > 0:
            d += 1
            maxA = maxA // 10
        d += 1

        for i in range(d):
            s = [[] for _ in range(10)]
            for data in A:
                s[data // (10 ** i) % 10].append(data)
            index = 0
            for j in s:
                for k in j:
                    A[index] = k
                    index += 1

看完大佬的代码，写了一个选择排序，都忘了好多。

def sortIntegers(self, A):
        # write your code here
        if A == None or len(A) == 0: return 
        for i in range(len(A) - 1):
            temp = i
            for j in range(i + 1, len(A)):
                if A[temp] > A[j]:
                    temp = j
            A[i], A[temp] = A[temp], A[i]

再写一个插入排序：

def sortIntegers(self, A):
        # write your code here
        if A == None or len(A) == 0: return 
        for i in range(1, len(A)):
            for j in range(i - 1, -1, -1):
                if A[i] < A[j]:
                    A[i], A[j] = A[j], A[i]
                    i = j
                else: break       

214 · 数组的最大值

给一个浮点数数组，求数组中的最大值。

def maxOfArray(self, A):
        # write your code here
        if A is None or len(A) == 0: return []
        elif len(A) == 1: return A[0]

        # 倒叙冒泡一次就行
        for i in range(len(A) - 1, 0, -1):
            for j in range(i - 1, -1, -1):
                if A[j] > A[i]:
                    A[j], A[i] = A[i], A[j]
            return A[-1

注意注意！

 A[j], A[i] = A[i], A[j]

只是A[j]和A[i]对应的值发生了变化，i，j不变。

看到很多答案，官方答案居然直接调用了max函数，无力吐糟。其他人的答案没有考虑边界问题，另外，也没有考虑性能问题。看来自己的代码在一点点变好，这是好的迹象。

25 · 打印X

输入一个正整数N， 你需要按样例的方式返回一个字符串列表。

def printX(self, n: int) -> List[str]:
        # write your code here
        li = []
        for i in range(n):
            temp = [' '] * n
            temp[i], temp[n - 1 - i] = 'X', 'X'
            li.append("".join(temp))
        return li

这道题我一直在考虑能否不用join函数来做，用字符串，但是那样的话，就需要生成一个空的且有长度的字符串。

看了答案，都没有我的方法简单。不贴了