- 博客(43)
- 收藏
- 关注
RSS订阅原创 Haar小波对图像的分解
haar小波对图像的一次分解实验，同样要求不使用matlab自带的小波函数和卷积函数。分解过程：matlab代码如下：clcclearx=imread('cameraman.tif'); %读取matlab里自带的一副图片%imshow(img);该图像的行列为366*364%haar小波对图像进行分解h1=x;h3=x;for i=1:256 for j=1:255 %对行,进行低通滤波 (1/2,1/2) h1(i,1)=0+1/2*x(
2021-06-08 19:38:43
1479
原创 db4小波的一次分解与重构
clcclear%db4小波的一次分解与重构load leleccum; %导入信号、n=1000;x=leleccum(1:n);%x=[2,4,6,8,2,4,6,8];% haar 的分解b=[];a=[];%b(1)=0-1/2*x(1);%a(1)=0+1/2*x(1);[Lo_D,Hi_D,Lo_R,Hi_R]=wfilters('db4'); % 调用db4小波的四个滤波器% db小波的分解%滤波过程，频域相乘，时域卷积a=conv(Lo_D,x);
2021-06-03 15:23:30
2079
原创 ＜模板＞中缀转后缀
注：中缀表达式转后缀表达式，要求输入的中缀表达式不能带正负号，括号只有’('和‘)’，且不能有多余的括号，运算符只有加减乘除。若想实现更一般的功能，需要再完善一下代码。#include<iostream>#include<string>#include<stack>using namespace std;stack<char> stk; //栈中存储的只有运算符号bool justic(char a, char b) //判断a的优先级是不是
2021-05-26 19:17:14
163
原创 哈尔小波一次分解与重构
哈尔小波的一次分解与重构，用程序实现，要求不调用任何matlab内置函数matlab代码如下：clcclear%哈尔小波的一次分解与重构，用程序实现，要求不调用任何matlab内置函数load leleccum; %导入信号、matlab里自带的一个信号n=1000;x=leleccum(1:n);%x=[2,4,6,8,2,4,6,8];% haar 的分解b=[];a=[];b(1)=0-1/2*x(1);a(1)=0+1/2*x(1);for i=1:n-1
2021-05-25 11:07:29
701
原创 ＜算法导论＞练习10.2
10.2-1插入可以在常量的时间内完成，只需要将其插入到特定的位置比如链表的开始或结尾即可。删除元素需要找到要删除元素的位置，无法在常量的时间内完成，除非删除的元素在链表的开始或结尾。10.2-2栈的特点是先进后出以链表来模拟的话，插入删除操作均在链表头完成即可。代码如下：def push(l,x): x.next=l.head l.head=xdef pop(l): if l.head==None: return error else: x=l.head l.head=x
2021-05-23 20:50:01
91
原创 ＜模板＞二叉Huffman树
以叶节点的权值为1，2，3，4，5，求解二叉哈夫曼树的问题。直接计算了结果没有构建出哈夫曼树。计算的问题是：求最小的∑wi∗li\sum {w_i*l_i}∑wi∗li,其中w为叶节点，L为叶节点到根的深度。#include<iostream>#include<queue>using namespace std;struct rec //定义了结构体，方便重载小于号{ int v;};rec exm;priority_queue<rec&
2021-05-19 17:21:02
146
原创 ＜算法导论＞练习10.1
10.1-1push(s,4) s:4push(s,1) s:4,1push(s,3) s:4,1,3pop(s) s:4,1push(s,8) s:4,1,810.1-2第一个栈从数组的下标0开始向后增加，第二个栈从数组的末尾n-1开始向前增加。当两者的下标相遇时二者的总和为n，停止向栈中增加元素。10.1-3定义好判断队列满及空的函数，在每次插入以及删除的时候判断一下即可。判断函数如下：def queue_empty(Q): if Q.head==Q.tail:
2021-05-07 21:32:39
127
原创 ＜算法导论＞练习9.2
9.2-1如果数组的长度是0，那么调用的randomized-select函数的第二个和第三个参数是相同的。如果调用发生在程序的第8行，即p=q-1,那么有k=q-p+1=0.而题目中的i表示要找数组中第i小的元素，那么i一定大于等于0，而程序进行到第8行的条件是i<k=0,不成立。同理可以证明如果是在第九行调用的话i会大于k，同样不成立，所以程序不会递归调用长度为空的数组。9.2-3def randomized_select(A,p,r,i): while true: if p==r
2021-05-07 14:42:03
213
原创 ＜算法导论＞练习8.4
8.4-1B:1–0.13–0.162–0.203–0.394–0.425–0.536–0.647–0.71–0.798–0.8998.4-2如果所有的元素都放到了同一个桶中，那么桶排序就变成了插入排序（在书中的例子中，每个桶内部的排序方式是插入排序），如果他们恰好是按从大到小的顺序出现的，那么时间复杂度是O(n^2).提高效率的办法是在每个桶中使用堆排序或归并排序，不过这样的话要把链表转换为数组，需要额外的存储空间。...
2021-05-07 09:54:57
163
原创 ＜模板＞计数排序
计数排序是一种可以将时间复杂度降低为O(n)的非比较排序，因为它不需要两两元素进行比较所以比较排序的上界O(nlgn)并不适用于它，不过它有较多的限制条件：1、输入的n个元素必须是整数。2、数据的符号应保持一致。3、数据的范围不能太大，即数据的最大值k不能过大。4、数据之间的跨越幅度不宜过大，否则会浪费较多空间。代码如下：#include<iostream>using namespace std;const int k = 30; //k是要排序数组中的最大值int B[k
2021-05-06 17:07:07
95
原创 ＜算法导论＞练习8.2
8.2-2所谓稳定指的是相同元素的值在排序好的数列中的相对位置与他们在输入数组中的相对次序一样。从书中的代码中可以很清楚的得到这一结论，因为循环是从后向前进行迭代的，每次找到一个位置后会把c中的相应元素个数减一，所以再有相同的元素会插入到该元素的前面，保证相对位置不变。8.2-3该算法仍然是正确的，只是相同元素的相对位置反转了，它不再是稳定的了。8.2-4其实就是一道求前缀和的题，由书中计数排序代码的前九行可以计算出数组c，其中c[i]表示数组中小于等于i的元素个数，那么落在[a,…b]中的元素
2021-05-06 10:27:33
117
原创 ＜算法导论＞思考7
7-2a.如果所有元素都相同，那么时间复杂度是O(n^2)b.def partition(A,p,r): x=A[p] low=p high=p for j in range(p+1,r): if A[j]<x: y=A[j] A[j]=A[high+1] A[high+1]=A[low] A[low]=y low=low+1 high=high+1 elif A[j]==x: swap(A[high+1],A[j]) # swap函数
2021-05-05 09:56:29
55
原创 ＜模板＞大根堆
#include<iostream>using namespace std;const int SIZE = 110;int heap[SIZE], n; //heap 从下标1开始存储的，n是数组中已有的元素void up(int p){ while (p > 1) { if (heap[p] > heap[p / 2]) { swap(heap[p], heap[p / 2]); p = p / 2; } else { break;
2021-05-03 13:54:21
43
原创 ＜算法导论＞练习7.3
7.3-1我们分析期望运行时间因为它代表的时间成本更加典型。7.3-2在最坏的情况下，调用random的次数是：T(n)=T(n−1)+1=nT(n)=T(n-1)+1=nT(n)=T(n−1)+1=n即Θ(n)\Theta(n)Θ(n).最好的情况也是Θ(n)\Theta(n)Θ(n)....
2021-05-03 12:19:50
116
原创 ＜算法导论＞练习7.2
7.2-1证明方法和第二章的一样，这里不证了。7.2-2当元素都相同时，快速排序的时间复杂度是O(n^2),因为每次排序时没有大于所选的元素，所以相当于每次只排了一个元素。7.2-3按照书中所用的快排方式，时间复杂度是O(n^2),因为书中的代码取的分界元素是最后一个，若数组已经降序了 ，那么最后的元素一定是最小的，所以每次调用PARTITION只会排一个元素。7.2-4如上一题所说的那样，快排在几乎有序的数组中时间复杂度接近于n^2....
2021-05-03 12:08:59
155
原创 ＜模板＞快速排序
#include<iostream>#include<algorithm>using namespace std;void quick_sort(int q[], int l, int r){ if (l >= r) return; int i = l - 1, j = r + 1, t = q[l + r>>1]; while (i < j) { do i++; while (q[i] < t); do j--; whil
2021-04-30 10:19:05
50
原创 ＜算法导论＞练习7.1
7.1-113,19,9,5,12,8,7,4,21,2,6,1113,19,9,5,12,8,7,4,21,2,6,1113,19,9,5,12,8,7,4,21,2,6,119,19,13,5,12,8,7,4,21,2,6,119,5,13,19,12,8,7,4,21,2,6,119,5,13,19,12,8,7,4,21,2,6,119,5,8,19,12,13,7,4,21,2,6,119,5,8,7,12,13,19,4,21,2,6,119,5,8,7,4,13,19,12
2021-04-30 09:24:21
77
原创 ＜模板＞正整数转32位二进制字符串
把一个正整数转为32位二进制字符串，其中数据范围是0<=x<2310<=x<2^{31}0<=x<231#include<iostream>using namespace std;void itobs(int i, char* c){ int j = 0; while (j < 32) { if ((i & (1 << (31 - j))) != 0) c[j] = '1'; else c[j] = '0';
2021-04-28 20:02:18
214
原创 ＜算法导论＞第六章思考
6-1a.不一样。当输入数据为1，2，3时，bulid_max_heap产生的堆为：3,2,1本题中给出的代码产生的数据为：3,1,2b.每次插入数据最多耗时O(lgn)O(lgn)O(lgn),一共要执行n次，总的复杂度为O(nlgn)O(nlgn)O(nlgn).6-2...
2021-04-28 18:50:29
122
原创 ＜算法导论＞练习6.5
6.5-1将15与最后一个元素交换，并把堆的大小减1，类似于弹出操作，剩下的元素维持最大堆的性质，过程如下：1,13,9,5,12,8,7,4,0,6,213,1,9,5,12,8,7,4,0,6,213,12,9,5,1,8,7,4,0,6,213,12,9,5,6,8,7,4,0,1,26.5-2先在堆的末尾插入一个值为负无穷的节点，再调用heap-increase-key函数把该节点的值提高为要插入的值key。过程如下：15,13,9,5,12,8,7,4,0,6,2,1,-inf
2021-04-27 20:31:50
113
原创 ＜算法导论＞练习6.4
6.4-1先把数组转化为最大堆，然后取出根节点，把剩余的节点数组再转化为最大堆，重复这个过程就是堆排序。5,13,2,25,7,17,20,8,45,13,20,25,7,17,2,8,45,25,20,13,7,17,2,8,425,5,20,13,7,17,2,8,425,13,20,5,7,17,2,8,425,13,20,8,7,17,2,5,44,13,20,8,7,17,2,5,2520,13,4,8,7,17,2,5,2520,13,17,8,7,4,2,5,255,13
2021-04-27 15:40:18
160
原创 ＜模板＞Trie字典树
字典树，一种存储字符串的结构，可以快速的找到某一字符串是否在字典树中。int trie[SIZE][26],tot=1; //假设输入为26个小写字母void insert(char* str) //插入数据{ int len=strlen(str),p=1; for(int k=0;k<len;k++) { int ch=str[k]-'a'; if(trie[p][ch]==0) trie[p][ch]=++tot; p=trie[p][ch]; } endk[
2021-04-26 16:03:52
47
原创 ＜模板＞单调栈
#include<iostream>using namespace std;//int a[100]; //原始数组,数组最后一个元素要设为一个极小值const int N = 8;int q[100]; //单调递增的栈int res[N]; //结果数组，第i个存的数表示a[i]左边第一个小于它的数int n = N; //a数组的长度void calc_stk(int *a){ int p = 0; for (int i = 1; i <= n; i++
2021-04-23 20:02:54
68
原创 ＜算法导论＞练习6.3
6.3-15,3,17,10,84,19,6,22,95,3,17,22,84,19,6,10,95,3,19,22,84,17,6,10,95,84,19,22,3,17,6,10,984,5,19,22,3,17,6,10,984,22,19,5,3,17,6,10,984,22,19,10,3,17,6,5,96.3-2max-heap 维护堆的性质，比较 的是自己与左右孩子的关系，不会跨级比较。所以若最大值在底层，那么程序结束后它不会在A[1]的位置。...
2021-04-22 15:47:50
100
原创 ＜算法导论＞练习6.2
6.2-127,17,3,16,13,10,1,5,7,12,4,8,9,027,17,10,16,13,3,1,5,7,12,4,8,9,027,17,10,16,13,9,1,5,7,12,4,8,3,06.2-2就是找到自身和左右孩子里最小的值交换即可。def min_heapify(A,i): l=left(i) r=right(i) if l<= A.heap_size and A[l] <A[i]: small=l else : small=i if r
2021-04-21 18:30:21
74
原创 ＜模板＞高精度减法
计算两正整数的减法，结果可能小于0.所谓高精度就是指可以计算超出计算机量程范围的数的减法。#include<iostream>#include<vector>#include<string>using namespace std;vector<int> sub(vector<int>& A, vector<int>& B) //倒着的高精度减法{ vector<int> c; for (i
2021-04-20 19:42:55
53
原创 ＜模板＞高精度加法
#include<iostream>#include<vector>using namespace std;vector<int> add(vector<int>& A, vector<int>& B){ //其实就是模拟了竖式加法的操作过程 if (A.size() < B.size()) return add(B, A); //在内部调用居然只用传参就可以了 int t = 0; vector<int
2021-04-20 19:36:26
36
原创 kmp匹配模板
#include<iostream>using namespace std;char a[1000010];char b[1000010]; //两个字符串数组，待匹配的两个字符串int next1[1000010] , n,m; //n是字符串a的长度,m是字符串b的长度int f[1000010];//计算字符串的next数组void calc_next(){ next1[1] = 0; for (int i = 2, j = 0; i <= n;
2021-04-20 19:33:22
42
原创 字符串hash模板
总是换电脑，我决定把这些通用的模板记在这里。#include<iostream>using namespace std;char s[1000010]; //存贮要计算哈希值的字符串 此例子中字符串只包含小写英文字母unsigned long long h[1000010], p[1000010]; //h存哈希值的计算结果，p存那个质数的幂，p一般取131 此类型unsigned long long 计算时不用处理溢出 //产生溢出时，相当于自动对2^64取模
2021-04-20 19:30:14
173
原创 ＜算法导论＞练习6.1
6.1-1高度为h的堆最多有：1+2+22+...+2h1+2+2^2+...+2^h1+2+22+...+2h个元素。最少有1+2+22+...+2h−1+11+2+2^2+...+2^{h-1}+11+2+22+...+2h−1+16.1-2一个堆中的元素必定为2m+k−12^m+k-12m+k−1个，其中2^m个元素构成了一棵完全二叉树，剩下的k-1个元素构成了叶节点。所以堆的最大高度是m+1，也就是lgn向下取整，这里的lg是指以e为底的指数。6.1-3这其实就是大根堆的定义，构建大根堆
2021-04-15 20:59:28
114
原创 ＜算法导论＞练习5.3
5.3-1把第一种情况单独列出来即可。5.3-2无法实现，这个题前面好像有，比如想由A[1,2,3]生成[3,2,1]是无法实现的，因为i是递增的，所以第一步只能和3交换得到[3,2,1],还会进行第二步的交换，生成[3,1,2].所以不能生成任意排列。5.3-3这种方法并不能产生均匀的随机排列。以n=3为例，for循环的每次迭代都会把第i个元素和第[1,2,3]之中的某个进行交换，所以第i次迭代会有3种不同情况。那么整个迭代经过排列组合一共会有33=273^3=2733=27种情况，而3个不同
2021-04-06 21:30:33
115
原创 ＜算法导论＞练习5.2
5.2-1只雇用一次意味着能力最强者在第一个，概率是1n\frac1nn1.正好雇佣n次意味着所有人按能力大小顺序出现，一共有n！种情况，概率是1n!\frac1{n!}n!15.2-2要遍历所有人，其中第一个人一定会被雇佣，而且能力最大的人一定会被雇佣，则正好两次的情况就是雇佣第一个人以及能力最高的人，且他们之间所有人的能力要小于第一个人。概率为：p=∑i=1n−11n∑k=1iknp=\sum_{i=1}^{n-1} {\frac1n}\sum_{k=1}^{i} {\frac{k}{
2021-04-01 15:03:09
150
原创 ＜算法导论＞练习5.1
5.1-2random(a,b)将返回一个介于（a,b）之间的整数，题目要求只能调用random(0,1)，很明显要转变为二进制计算，且random(0,1)是已经实现了的，令k=⌈lg(b−a)⌉k=\left \lceil lg(b-a) \right \rceil k=⌈lg(b−a)⌉k代表了要生成序列的二进制位数，若生成的数不再（a,b）之间就重新生成。def random(a,b): l=b-a k=int(log(l,2)+1) res=0 for i in range(k
2021-04-01 09:46:43
120
原创 ＜算法导论＞练习4.5
4.5-1判断一下分别属于哪种情况然后代入公式即可。a.Θ(nlog42)=Θ(n12)\Theta(n^{\log_42})=\Theta(n^\frac12)Θ(nlog42)=Θ(n21)b.Θ(nlog42lgn)=Θ(n12lgn)\Theta(n^{\log_42}lgn)=\Theta(n^\frac12lgn)Θ(nlog42lgn)=Θ(n21lgn)c.Θ(n)\Theta(n)Θ(n)d.Θ(n2)\Theta(n^2)Θ(n2)4.5-2题目描述的挺多，实际
2021-03-29 20:16:02
375
原创 ＜算法导论＞练习4.3
4.3-1用数学归纳法证明即可，思路是假设n<=kn<=kn<=k时存在c使得T(k)<=cn2T(k)<=cn^2T(k)<=cn2成立，只要证明出n=k+1n=k+1n=k+1时，存在c使得T(k+1)<=c(k+1)2T(k+1)<=c(k+1)^2T(k+1)<=c(k+1)2。那么把T(k)和T(k−1)T(k)和T(k-1)T(k)和T(k−1)代入递归式得到：KaTeX parse error: Expected 'EOF', got
2021-03-29 15:20:15
734
2
原创 ＜算法导论＞练习4.2
4.2-1就是代入书中的式子计算一下，令A=[1375]B=[6842]A=\begin{bmatrix} 1&3 \\ 7&5\end{bmatrix}B=\begin{bmatrix} 6&8 \\ 4&2\end{bmatrix}A=[1735]B=[6482]S1=B12−B22=8−2=6S_1=B_{12}-B_{22}=8-2=6S1=B12−B22=8−2=6同理，S2=4，S3=12，S4=-2，S5=6，
2021-03-26 20:28:08
253
原创 ＜算法导论＞练习4.1
4.1-1所有元素都是负数时，最大子数组的和就是A中最大的元素。所有程序会返回A中最大的数。4.1-2两个for循环嵌套，且最大迭代次数是n，时间复杂度是Θ(n2)\Theta(n^2)Θ(n2)def find_maximum_subarray(a): n=len(a) max_sum=-float('inf') low=0;high=0 for i in range(n): sum_da=0 for j in range(i,n):
2021-03-25 19:46:03
211
2
原创 ＜算法导论＞练习3.2
3.2-1因为f(m),与g(m)单调递增，所以，在n>m时有：f(m)<f(n)(1)g(m)<g(n)(2)f(m)<f(n)\quad(1)\\g(m)<g(n)\quad(2)f(m)<f(n)(1)g(m)<g(n)(2)式(1)与（2）相加可得f(m)+g(m)<f(n)+g(n)f(m)+g(m)<f(n)+g(n)f(m)+g(m)<f(n)+g(n),所以是单调递增的。在m<n时，有g(m)<g(n),且
2021-03-24 21:44:13
474
原创 ＜算法导论＞练习3.1
3.1-1 由题目可知，f(n)>0且g(n)>0f(n)>0且g(n)>0f(n)>0且g(n)>0,并且他们均小于max(f(n),g(n))max(f(n),g(n))max(f(n),g(n)),而且max(f(n),g(n))max(f(n),g(n))max(f(n),g(n))一定小于f(n)+g(n)f(n)+g(n)f(n)+g(n),那么存在：0<=f(n)+g(n)2<=max(f(n)+g(n))<=f(n)+g(n)0&
2021-03-22 22:06:11
184
原创 ＜算法导论＞第二章思考题
2-1a、对长度为k的子表使用插入排序最坏的情况下复杂度为Θ($k^{2}$),因此对n/k个每个长度为k的子表 排序最坏需要Θ(k^2 * n/k)=Θ(nk).b、$ J_\alpha(x) = \sum_{m=0}^\infty \frac{(-1)^m}{m! \Gamma (m + \alpha + 1)} {\left({ \frac{x}{2} }\right)}^{2m + \alpha} \text {，行内公式示例} $...
2021-03-20 21:05:12
247
1
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人