swiftR

数组的定义和使用

  • 方式一：int[] arr;
  • 方式二：int arr[];
1
2
3
//创建数组
//        Integer[] arr = {1,2};
//        int[] arr2 = new int[5];

数组的遍历

1.for循环
2.增强for循环
3.lambda表达式

1
Arrays.asList(arr).forEach(e -> System.out.println(e));

数组拷贝

1
2
Integer[] arr2 = Arrays.copyOf(arr,arr.length);
//        System.out.println(Arrays.toString(arr2));

其中第二个参数为新数组长度

1
2
3
public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

数组填充

1
2
Arrays.fill(arr2,6);
System.out.println(Arrays.toString(arr2));

值得注意的是使用fill会覆盖数组原有的值

数组合并

这里使用apache的工具类完成

1
2
3
4


int[] arr3 = org.apache.commons.lang3.ArrayUtils.addAll(arr, arr2);
System.out.println(Arrays.toString(arr3));

数组排序

使用 Arrays的sort完成
可以看到里面的实现使用的是快速排序

1
2
3
public static void sort(int[] a) {
        DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
    }

python简单实现如下

1
2
3
4
5
6
7
8
def quicksort(arr):
    if len(arr) < 2:
        return arr
    else:
        pivot = arr[0]
        less = [i for i in arr[1:] if i<= pivot]
        greaater = [i for i in arr[1:] if i> pivot]
        return quicksort(less)+[pivot]+quicksort(greaater)

冒泡排序

这是一种效率比较低的排序方法,实现起来也比较简单

1
2
3
4
5
6
7
8
9
10
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr.length; j++) {
        if (arr[i] > arr[j]) {
            // 元素交换
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
}

选择排序

从每次遍历的结果中筛选出最大或最小的元素放入新数组中，效率和冒泡排序一样都是O(n2)

1
2
3
4
5
6
7
8
def findSmallest(arr):
    smallest = arr[0]
    smallest_index = 0
    for i in range(1,len(arr)):
        if arr[i] < smallest:
            smallest = arr[i]
            smallest_index = i
    return smallest_index

元素的查找

java官方api里面的实现使用的是二分查找，效率也很高

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private static int binarySearch0(long[] a, int fromIndex, int toIndex,
                                     long key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            long midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }
 Previous