array

ck_tools = {} /** * 第一步：公用方法 * */ //伪数组转真数组 ck_tools.fArrToTArr = function(fArr){ if(ck_tools.isFunction(Array.from)){ return Array.from(fArr);//[...fArr] }else{ return Array.prototype.slice.call(fArr); } } /** * 判读是不是对象字面量(纯对象)。对象字面量创建方式有{}、new Object()创建 */ ck_tools.isPlainObject = function(obj){ var flag = false; if(!obj || typeof obj != 'object'){return flag;} if(ck_tools.isHasPro(obj.constructor.prototype,"isPrototypeOf")){ flag = true; } return flag; } //判断是否是数组 ck_tools.isArray = function(arr){ if(ck_tools.isFunction(Array.isArray)){ return Array.isArray(arr); }else{ return Object

indptr = np.array([0, 2, 3, 6]) indices = np.array([0, 2, 2, 0, 1, 2]) data = np.array([1, 2, 3, 4, 5, 6]) scipy.sparse.csc_matrix((data, indices, indptr), shape=(3, 3)).toarray() output: array([[1, 0, 4], [0, 0, 5], [2, 3, 6]]) 转换成稀疏矩阵有3种方式: crc_matrix, csr_matrix, coo_matrix crc_matrix 矩阵是按照列存储的 indptr 是每列数据的对应的data的下标,即 indptr[0] - indptr[1], indptr[2] - indptr[1], indptr[3] - indptr[2] 数据有3列 indices 是 对应的行的下标大小 第一列： data[ indptr[0] : indptr[1] ] = data[0:2] = 1, 2 indices[indptr[0] : indptr[1] ] = indices[0:2] = 0, 2 output: [ [1], [0], [2] ] 第二列： data[ indptr[1] : indptr[2] ] = data[2:3]

golang 的log包使用起来挺简单，这里做一些简单介绍。 示例： package main import ( "log" ) func main() { arr := []int{1, 2} log.Print("Print array ", arr, "\n") log.Println("Println array", arr) log.Printf("Printf array with item [%d,%d]\n", arr[0], arr[1]) } 结果： 2018/12/14 18:42:02 Print array [1 2] 2018/12/14 18:42:02 Println array [1 2] 2018/12/14 18:42:02 Printf array with item [1,2] log.Fatal 、log.Fatalln、log.Fatalf 示例： log.Fatal("Fatal array ", arr, "\n") log.Fatalln("Fatalln array", arr) log.Fatalf("Fatalf array with item [%d,%d]\n", arr[0], arr[1]) 对于 log.Fatal 接口，会先将日志内容打印到标准输出，接着调用系统的 os.exit(1) 接口退出程序并返回状态 1

基本思想 排序思想 用最大堆排序的基本思想： 先将初始文件R[1..n]建成一个最大堆，此堆为初始的无序堆。 再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录R[n]交换，由此得 到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key。 由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。 然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由 此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系 R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。 算法实现 最大堆排序算法，Java实现，代码如下所示： public abstract class Sorter { public abstract void sort ( int [] array); } public class HeapSorter extends Sorter { public void sort ( int [] array) { heapSort(array); } private void heapSort ( int [] array) { int temp; // 用于交换的暂存单元

选择排序 实现原理 首先从未排序序列中找到最小的元素，放置到排序序列的起始位置，然后从剩余的未排序序列中继续寻找最小元素，放置到已排序序列的末尾。所以称之为选择排序。 代码实现 public static int[] selectionSort(int[] arr){ if (null == arr || arr.length == 0){ return null; } int length = arr.length; for (int i = 0; i < length - 1; i++) { int min = i; for (int j = i + 1; j < length; j++) { if (arr[j] < arr[min]){ min = j; } } int temp = arr[i]; arr[i] = arr[min]; arr[min] = temp; } return arr; } 案例分析 时间复杂度与空间复杂度 每次要找一遍最小值，最坏情况下找n次，这样的过程要执行n次，所以时间复杂度还是O(n^2)。空间复杂度是O(1)。 快速排序 实现原理 在数据集之中，选择一个元素作为”基准”（pivot）。 所有小于”基准”的元素，都移到”基准”的左边；所有大于”基准”的元素，都移到”基准”的右边。这个操作称为分区 (partition)。 操作

选择排序 实现原理 首先从未排序序列中找到最小的元素，放置到排序序列的起始位置，然后从剩余的未排序序列中继续寻找最小元素，放置到已排序序列的末尾。所以称之为选择排序。 代码实现 public static int[] selectionSort(int[] arr){ if (null == arr || arr.length == 0){ return null; } int length = arr.length; for (int i = 0; i < length - 1; i++) { int min = i; for (int j = i + 1; j < length; j++) { if (arr[j] < arr[min]){ min = j; } } int temp = arr[i]; arr[i] = arr[min]; arr[min] = temp; } return arr; } 案例分析 时间复杂度与空间复杂度 每次要找一遍最小值，最坏情况下找n次，这样的过程要执行n次，所以时间复杂度还是O(n^2)。空间复杂度是O(1)。 快速排序 实现原理 在数据集之中，选择一个元素作为”基准”（pivot）。 所有小于”基准”的元素，都移到”基准”的左边；所有大于”基准”的元素，都移到”基准”的右边。这个操作称为分区 (partition)。 操作

转自：https://www.coder4.com/archives/3853Shell编程中的数组定义、遍历 4 Replies 数组定义： arr=(1 2 3 4 5) # 注意是用空格分开，不是逗号！！ 数组定义法2： array array[0]="a" array[1]="b" array[2]="c" 获取数组的length（数组中有几个元素）： ${#array[@]} 遍历（For循环法）： for var in ${ arr[@] }; do echo $var done 遍历（带数组下标）： for i in "${!arr[@]}"; do printf "%s\t%s\n" "$i" "${arr[$i]}" done 遍历（While循环法）： i=0 while [ $i -lt ${ #array[@] } ] do echo ${ array[$i] } let i++ done 遍历（for循环次数） for i in {1..5} do echo "Welcome $i times" done 向函数传递数组： 由于Shell对数组的支持并不号，所以这是一个比较麻烦的问题。 翻看了很多StackOverFlow的帖子，除了全局变量外，无完美解法。 这里提供一个变通的思路，我们可以在调用函数前，将数组转化为字符串。 在函数中，读取字符串

代码 #include <iostream> using namespace std; int main() { int n,max=0,max_num=0; int *array = new int[1000]; cin>>n; for(int i=0;i<n;i++) cin>>array[i]; int count[10001] = {0}; for(int i=0;i<n;i++) { count[array[i]]++; } for(int i=0;i<10001;i++) { if(count[i]>max) { max=count[i]; max_num=i; } } cout<<max_num<<endl; return 0; } 知识点总结： 1. 动态一维数组：int * array = new int[size]; 2. map用法： //头文件 #include<map> //定义 map<int, string> mapStudent; //插入元素 // 第一种 用insert函数插入pair mapStudent.insert(pair<int, string>(000, "student_zero")); // 第二种 用insert函数插入value_type数据 mapStudent.insert(map<int, string>::value

一、快速排序： 在待排元素中找出一个基准元素,然后比较基准元素和其他元素，以基准元素为基准，将大于准的元素的放后边，小于 基准的元素放前边。然后再对分好的左右两个小区间进行快速排序 以基准元素划分区间的方式有以下2种： 第一种： 设两个参考变量less,great，less先从第一个元素开始往后遍历，直到找到的当前元素大于基准元素。 然后让great从最后一个元素开始往前遍历，直到找到当前元素小于基准元素，交换当前less和great指向的值。 再接着从less开始，重复上述动作，遍历结束的条件是less>=great; 遍历结束后，交换当前less(或great)指向的值与基准元素的值。再进行下一次的小区间内的查找 二、图示 注意：新划分的两个区间的范围是： 第一段：原本的left到上一轮基准元素最终位置的前一位；即[left,pivotIndex-1] 第二段：上一轮基准元素最终位置的后一位到原本的right;即[pivotIndex+1,right] 最终结果: 三、代码实现 public static void quickSort ( int[] array){ int left = 0; int right = array.length - 1; quickSortInternal1(array, left, right); } public static void

1.最基本的去重方法 思路：定义一个新数组，并存放原数组的第一个元素，然后将元素组一一和新数组的元素对比，若不同则存放在新数组中。 function unique(arr){ 　　var res = [arr[0]]; 　　for(var i=1;i<arr.length;i++){ 　　　　var repeat = false; 　　　　for(var j=0;j<res.length;j++){ 　　　　　　if(arr[i] == res[j]){ 　　　　　　　　repeat = true; 　　　　　　　　break; 　　　　　　} 　　　　} 　　　　if(!repeat){ 　　　　　　res.push(arr[i]); 　　　　} 　　} 　　return res; } 2.先排序在去重 思路：先将原数组排序，在与相邻的进行比较，如果不同则存入新数组 function unique(arr){ 　　var arr2 = arr.sort(); 　　var res = [arr2[0]]; 　　for(var i=1;i<arr2.length;i++){ 　　　　if(arr2[i] !== res[res.length-1]){ 　　　　　　res.push(arr2[i]); 　　　　} 　　} 　　return res; } 3.利用对象的属性去重（推荐）