数据结构与算法 学习笔记
2010-11-04 12:45
435 查看
1,判断链表是否存在环型链表
问题:判断一个链表是否存在环,例如下面这个链表就存在一个环:
例如N1-N2-N3-N4-N5-N2就是一个有环的链表,环的开始结点是N5
这里有一个比较简单的解法。设置两个指针p1,p2。每次循环p1向前走一步,p2向前走两步。直到p2碰到NULL指针或者两个指针相等结束循环。如果两个指针相等则说明存在环。
struct link
{
int data;
link next;
};
bool IsLoop(link head)
{
link p1=head, p2 = head;
if (head ==NULL head-next ==NULL)
{
return false;
}
do{
p1= p1-next;
p2 = p2-next-next;
} while(p2 && p2-next && p1!=p2);
if(p1 == p2)
return true;
else
return false;
}
2,链表反转
5, 找出单向链表的中间结点
这道题和解 判断链表是否存在环 ,我用的是非常类似的方法,只不过结束循环的条件和函数返回值不一样罢了。设置两个指针p1,p2。每次循环p1向前走一步,p2向前走两步。当p2到达链表的末尾时,p1指向的时链表的中间。
link mid(link head)
{
link p1,p2;
p1=p2=head;
if(head==NULL head-next==NULL)
return head;
do {
p1=p1-next;
p2=p2-next-next;
} while(p2 && p2-next);
return p1;
}
6, 按单词反转字符串
并不是简单的字符串反转,而是按给定字符串里的单词将字符串倒转过来,就是说字符串里面的单词还是保持原来的顺序,这里的每个单词用空格分开。例如:
Here is www.fishksy.com.cn
经过反转后变为:
www.fishksy.com.cn is Here
如果只是简单的将所有字符串翻转的话,可以遍历字符串,将第一个字符和最后一个交换,第二个和倒数第二个交换,依次循环。其实按照单词反转的话可以在第一遍遍历的基础上,再遍历一遍字符串,对每一个单词再反转一次。这样每个单词又恢复了原来的顺序。
char reverse_word(const char str)
{
int len = strlen(str);
char restr = new char[len+1];
strcpy(restr,str);
int i,j;
for(i=0,j=len-1;ij;i++,j--)
{
char temp=restr[i];
restr[i]=restr[j];
restr[j]=temp;
}
int k=0;
while(klen)
{
i=j=k;
while(restr[j]!=' ' && restr[j]!='0' )
j++;
k=j+1;
j--;
for(;ij;i++,j--)
{
char temp=restr[i];
restr[i]=restr[j];
restr[j]=temp;
}
}
return restr;
}
单向链表的反转是一个经常被问到的一个面试题,也是一个非常基础的问题。比如一个链表是这样的: 1-2-3-4-5 通过反转后成为5-4-3-2-1。最容易想到的方法遍历一遍链表,利用一个辅助指针,存储遍历过程中当前指针指向的下一个元素,然后将当前节点元素的指针反转后,利用已经存储的指针往后面继续遍历。源代码如下:
struct linka {
int data;
linka next;
};
void reverse(linka& head)
{
if(head ==NULL)
return;
linkapre, cur, ne;
pre=head;
cur=head-next;
while(cur)
{
ne = cur-next;
cur-next = pre;
pre = cur;
cur = ne;
}
head-next = NULL;
head = pre;
}
3, 判断两个数组中是否存在相同的数字
后来发现有一个 O(n)算法。因为两个数组都是排好序的。所以只要一次遍历就行了。首先设两个下标,分别初始化为两个数组的起始地址,依次向前推进。推进的规则是比较两个 数组中的数字,小的那个数组的下标向前推进一步,直到任何一个数组的下标到达数组末尾时,如果这时还没碰到相同的数字,说明数组中没有相同的数字。
bool findcommon2(int a[], int size1, int b[], int size2)
{
int i=0,j=0;
while(i<size1 && j<size2)
{
if(a[i]==b[j])
return true;
if(a[i]>b[j])
j++;
if(a[i]<b[j])
i++;
}
return false;
}
4, 最大子序列
问题:
给定一整数序列A1, A2,... An (可能有负数),求A1~An的一个子序列Ai~Aj,使得Ai到Aj的和最大
在给出线性算法之前,先来看一个对穷举算法进行优化的算法,它的算法复杂度为O(n^2)。其实这个算法只是对对穷举算法稍微做了一些修改:其实子序列的和我们并不需要每次都重新计算一遍。假设Sum(i, j)是A[i] ... A[j]的和,那么Sum(i, j+1) = Sum(i, j) + A[j+1]。利用这一个递推,我们就可以得到下面这个算法:
int max_sub(int a[],int size)
{
int i,j,v,max=a[0];
for(i=0;i<size;i++)
{
v=0;
for(j=i;j<size;j++)
{
v=v+a[j];Sum(i, j+1) = Sum(i, j) + a[j+1]
if(v>max)
max=v;
}
}
return max;
}
最优:
int max_sub2(int a[], int size)
{
int i,max=0,temp_sum=0;
for(i=0;i<size;i++)
{
temp_sum+=a[i];
if(temp_sum>max)
max=temp_sum;
else if(temp_sum<=0)
temp_sum=0;
}
return max;
}
在这一遍扫描数组当中,从左到右记录当前子序列的和temp_sum,若这个和不断增加,那么最大子序列的和max也不断增加(不断更新max)。如果往前扫描中遇到负数,那么当前子序列的和将会减小。此时temp_sum 将会小于max,当然max也就不更新。如果temp_sum降到0时,说明前面已经扫描的那一段就可以抛弃了,这时将temp_sum置为0。然后,temp_sum将从后面开始将这个子段进行分析,若有比当前max大的子段,继续更新max。这样一趟扫描结果也就出来了。
问题:判断一个链表是否存在环,例如下面这个链表就存在一个环:
例如N1-N2-N3-N4-N5-N2就是一个有环的链表,环的开始结点是N5
这里有一个比较简单的解法。设置两个指针p1,p2。每次循环p1向前走一步,p2向前走两步。直到p2碰到NULL指针或者两个指针相等结束循环。如果两个指针相等则说明存在环。
struct link
{
int data;
link next;
};
bool IsLoop(link head)
{
link p1=head, p2 = head;
if (head ==NULL head-next ==NULL)
{
return false;
}
do{
p1= p1-next;
p2 = p2-next-next;
} while(p2 && p2-next && p1!=p2);
if(p1 == p2)
return true;
else
return false;
}
2,链表反转
5, 找出单向链表的中间结点
这道题和解 判断链表是否存在环 ,我用的是非常类似的方法,只不过结束循环的条件和函数返回值不一样罢了。设置两个指针p1,p2。每次循环p1向前走一步,p2向前走两步。当p2到达链表的末尾时,p1指向的时链表的中间。
link mid(link head)
{
link p1,p2;
p1=p2=head;
if(head==NULL head-next==NULL)
return head;
do {
p1=p1-next;
p2=p2-next-next;
} while(p2 && p2-next);
return p1;
}
6, 按单词反转字符串
并不是简单的字符串反转,而是按给定字符串里的单词将字符串倒转过来,就是说字符串里面的单词还是保持原来的顺序,这里的每个单词用空格分开。例如:
Here is www.fishksy.com.cn
经过反转后变为:
www.fishksy.com.cn is Here
如果只是简单的将所有字符串翻转的话,可以遍历字符串,将第一个字符和最后一个交换,第二个和倒数第二个交换,依次循环。其实按照单词反转的话可以在第一遍遍历的基础上,再遍历一遍字符串,对每一个单词再反转一次。这样每个单词又恢复了原来的顺序。
char reverse_word(const char str)
{
int len = strlen(str);
char restr = new char[len+1];
strcpy(restr,str);
int i,j;
for(i=0,j=len-1;ij;i++,j--)
{
char temp=restr[i];
restr[i]=restr[j];
restr[j]=temp;
}
int k=0;
while(klen)
{
i=j=k;
while(restr[j]!=' ' && restr[j]!='0' )
j++;
k=j+1;
j--;
for(;ij;i++,j--)
{
char temp=restr[i];
restr[i]=restr[j];
restr[j]=temp;
}
}
return restr;
}
单向链表的反转是一个经常被问到的一个面试题,也是一个非常基础的问题。比如一个链表是这样的: 1-2-3-4-5 通过反转后成为5-4-3-2-1。最容易想到的方法遍历一遍链表,利用一个辅助指针,存储遍历过程中当前指针指向的下一个元素,然后将当前节点元素的指针反转后,利用已经存储的指针往后面继续遍历。源代码如下:
struct linka {
int data;
linka next;
};
void reverse(linka& head)
{
if(head ==NULL)
return;
linkapre, cur, ne;
pre=head;
cur=head-next;
while(cur)
{
ne = cur-next;
cur-next = pre;
pre = cur;
cur = ne;
}
head-next = NULL;
head = pre;
}
3, 判断两个数组中是否存在相同的数字
后来发现有一个 O(n)算法。因为两个数组都是排好序的。所以只要一次遍历就行了。首先设两个下标,分别初始化为两个数组的起始地址,依次向前推进。推进的规则是比较两个 数组中的数字,小的那个数组的下标向前推进一步,直到任何一个数组的下标到达数组末尾时,如果这时还没碰到相同的数字,说明数组中没有相同的数字。
bool findcommon2(int a[], int size1, int b[], int size2)
{
int i=0,j=0;
while(i<size1 && j<size2)
{
if(a[i]==b[j])
return true;
if(a[i]>b[j])
j++;
if(a[i]<b[j])
i++;
}
return false;
}
4, 最大子序列
问题:
给定一整数序列A1, A2,... An (可能有负数),求A1~An的一个子序列Ai~Aj,使得Ai到Aj的和最大
在给出线性算法之前,先来看一个对穷举算法进行优化的算法,它的算法复杂度为O(n^2)。其实这个算法只是对对穷举算法稍微做了一些修改:其实子序列的和我们并不需要每次都重新计算一遍。假设Sum(i, j)是A[i] ... A[j]的和,那么Sum(i, j+1) = Sum(i, j) + A[j+1]。利用这一个递推,我们就可以得到下面这个算法:
int max_sub(int a[],int size)
{
int i,j,v,max=a[0];
for(i=0;i<size;i++)
{
v=0;
for(j=i;j<size;j++)
{
v=v+a[j];Sum(i, j+1) = Sum(i, j) + a[j+1]
if(v>max)
max=v;
}
}
return max;
}
最优:
int max_sub2(int a[], int size)
{
int i,max=0,temp_sum=0;
for(i=0;i<size;i++)
{
temp_sum+=a[i];
if(temp_sum>max)
max=temp_sum;
else if(temp_sum<=0)
temp_sum=0;
}
return max;
}
在这一遍扫描数组当中,从左到右记录当前子序列的和temp_sum,若这个和不断增加,那么最大子序列的和max也不断增加(不断更新max)。如果往前扫描中遇到负数,那么当前子序列的和将会减小。此时temp_sum 将会小于max,当然max也就不更新。如果temp_sum降到0时,说明前面已经扫描的那一段就可以抛弃了,这时将temp_sum置为0。然后,temp_sum将从后面开始将这个子段进行分析,若有比当前max大的子段,继续更新max。这样一趟扫描结果也就出来了。
相关文章推荐
- 数据结构和算法-学习笔记7
- 算法设计和数据结构学习_4(《数据结构和问题求解》part4笔记)
- 数据结构学习笔记 模拟算法1
- 数据结构 学习笔记 模拟算法2
- 数据结构与算法学习笔记之--数据结构
- 数据结构与算法学习笔记之 提高读取性能的链表(上)
- 算法设计和数据结构学习_3(《数据结构和问题求解》part2笔记)
- 数据结构和算法学习笔记-1
- 数据结构学习笔记0——算法分析
- 数据结构和算法分析学习笔记(三)--二叉查找树的懒惰删除(lazy deletion)
- 数据结构与算法学习笔记
- 数据结构 试探法算法学习笔记
- 数据结构 学习笔记(九):图(下):最小生成树(Prim,Kruskal 算法),拓扑排序 AOV,关键路径 AOE
- 数据结构学习笔记 --- 线性表 (一些常见的关于链表的算法和面试题)
- 数据结构 学习笔记(一):基本概念:什么是数据结构和算法,应用实例
- 学习笔记1 数据结构和算法绪论
- 数据结构&算法学习笔记: 归并排序
- 数据结构与算法学习笔记——线性表
- 数据结构和算法学习笔记-2
- 【Java数据结构学习笔记之三】Java数据结构与算法之队列(Queue)实现