精华内容
下载资源
问答
  • 中序遍历二叉树得到序列有序还是无序的? 中序遍历二叉树得到序列有序还是无序的?
  • python 中list、tuple等有序序列

    万次阅读 2016-06-07 20:33:38
    list,tuple以及str都是有序序列,和后面两者不同的是list是个可变对象,tuple和str则是不可变对象。主要讲的就是这三种的有序序列的一些方式。 方法 效果 L1.append(var) 在后面追加元素 L1.pop(var)...

    listtuple以及str都是有序序列,和后面两者不同的是list是个可变对象,tuplestr则是不可变对象。主要讲的就是这三种的有序序列的一些方式。

    方法效果
    L1.append(var)在后面追加元素
    L1.pop(var)返回相应的元素,并在L1中删除
    L1.remove(var)移除列表中某个值的第一个匹配项
    L1.sort()列表会进行排序
    L1.reverse()列表倒序排列
    L1.count(var)计算列表中某个值出现的次数

    以上就是列表常用的方法,其中L1.remove()在 for…. in….循环中会出现状况。
    比如 ,你想取大于20的数,把小于20的全部删掉 :

    list2 = range(50)
    for i in list2:
        if i<20:
            print "do something"
            list2.remove(i)
    print list2        

    得到的结果是这样的:

    [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]

    原因在于在这个迭代过程中,for..in循环靠的是指针指示

    [0,1,2,….49]
    ^

    第一次remove之后,列表成这样的形式,

    [1,2,3,4…49]
    ^
    如果你想要得到正确的结果的话,可以这样写,enumerate,这个内置函数既可以遍历索引,又可以遍历元素。

    for i, n in enumerate(numbers):
        if n < 20 :
            print "do something" 
            numbers[i] = None
    numbers = [n for n in numbers if n is not None]

    tuple
    tuple是不可变的有序序列,一旦初始化,就不能修改。
    因为无法修改所以没有apeend()等方法,也无法删除其中单个元素,只能删除整个元组。

    tup1 = (1, 4, 5, 3);
    del tup1;
    print tup1
    #得到的答案就是这样
    NameError: name 'tup1' is not defined

    字符串

    str,字符串在python中是有序序列,这意味着字符串在python中可以做很多操作,比如slice。不过有一点是字符串中某部分无法进行修改,因为是不可变对象。

    字符串经常碰到的一个问题就是怎么把 字符串倒序输出。
    这时候我们就可以把slice用到字符串中,编写一个倒序输出的函数如下:

    def reverse(x):
        if not isinstance(x,basestring):
           raise TypeError ("bad type");
        else:
            return x[::-1]   

    isinstance是用来判断参数是否是字符串,如果不是的话将会报错。
    basestringstrunicode的父类,可以用来分辨是不是字符串的类型。
    slice
    这是一个可以快速截取有序序列片段的操作。

    slice的基本样式:
    slice(start, stop[, step])
    比如建一个list

    L =range(100)
    >>>[0,1,2,3.....99]

    要取10~20之间的数

    L[10:21]
    >>>[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
    #每隔一个数取
    L[10:20:2]
    >>> [10, 12, 14, 16, 18]
    # 取后10个数
    L[-10:]
    >>>[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

    tuple和string同样也可以用slice,得到的结果仍然是tuple或string。

    (0, 1, 2, 3, 4, 5)[:3]
    >>>(0, 1, 2)
    
    'ABCDEFG'[:3]
    >>>'ABC'
    展开全文
  • 两个有序序列的中位数(二分搜索)

    问题:

    已知有两个等长的非降序序列S1, S2, 设计函数求S1S2并集的中位数。有序序列A0,A1,,AN1的中位数指A(N1)/2的值,即第(N+1)/2个数(A0为第1个数)。



    算法描述:

    ① 输入两个长度自定且等长的数组,然后对他们进行赋值。算法的思路是分别取他们的中位数进行比较,假设两个数组如下:

    1

    3

    5

    7

    9

    2

    3

    4

    5

    6

    上面数组的中位数是比下面数组的中位数大的,接下来的操作就是取大中位数的左边(包括中位数),取小中位数的右边(包括中位数)。

    1

    3

    5

    4

    5

    6

    再次重复以上操作,最后有

    3

    5

    4

    5

    接下来已经不能再分别取他们的中位数缩小范围了,所以对两个数组进行比较。取数组的首位进行比较,如上即是3和4进行比较,若是哪边比较小就取它的下一位进行比较。过程就是3和4比(3比4小,所以下标加1)→5和4比(4比5小,所以得到中位数为4)→中位数为4。

    这是当数组为奇数长度的情况,若是数组长度为1,或者是数组长度为偶数,要再次进行讨论。

    ② 当数组长度为1时,比较两个数,谁比较小谁就是中位数。

    ③ 当数组长度为偶数时,

    -100

    -10

    1

    1

    1

    1

    -50

    0

    2

    3

    4

    5

    在第一步,取数组的中位数时候,若是按照奇数的方法,我们会发现,最后取出来的两个数组不是等长的,这样的话就会对我们的实际结果造成影响。如上,我们可以一个数组取第三个数,一个数组取第四个数这样进行比较,这样接下来得到的数组都是等长的。接下来步骤和奇数数组一样。

    ④ 在这里,偶数数组这样的取法原因是,我们每次取新数组出来,只要两个数组的长度和加起来是原来数组的一半或者大于一半,我们就可以保证中位数一直在我们取出来的新数组里面,不会出现中位数丢失的情况。



    算法时间及空间复杂度分析:

    时间复杂度:每一次调用的过程为判断余下数组长度是否大于2,接下来判断数组个数是奇数个还是偶数个,最后判断两个数组的中位数谁大谁小。所以t(n) = O(1)+O(1)+O(1)。总共执行次数为logn次。在主函数中,执行的语句为创建两个数组还有数组左右下标等变量,和为数组赋值。所以总的时间复杂度为T(n) = logn*t(n)+O(n)+O(1) = O(logn)。

     

    空间复杂度:算法中辅助空间并不随着数组长度n而线性增大,所以空间复杂度为O(1)。


    展开全文
  • 求两个等长有序序列的中位数

    千次阅读 2013-05-02 17:37:44
    /*现有两个等长的升序序列序列A,B,试设计一个时间...3:a>b:则中位数只能出现在b和a之间,在序列a中舍弃A之后的元素得到序列A1,在序列B中舍弃b之前的元素,得到B1; 在A1和B1中分别求出中位数,重复上述过程,得到

    /*现有两个等长的升序序列的序列A,B,试设计一个时间和空间都尽可能高效的算法,找出两个序列的中位数

    算法的基本思想是:分别求出两个序列的中位数,即为a b,有下列三种情况
    1:a=b;即a 为两个序列的中位数
    2:a<b: 则中位数只能出现在a和b之间,在序列A中舍弃a之后的元素的到序列A1,在序列B中舍弃b之前的元素,得到序列B1
    3:a>b:则中位数只能出现在b和a之间,在序列a中舍弃A之后的元素得到序列A1,在序列B中舍弃b之前的元素,得到B1;
    在A1和B1中分别求出中位数,重复上述过程,得到俩个序列中只有一个元素,则较小者即为所求

    */

     

     

     

    #include<iostream>
    using namespace std;
    void ZhWei(int m[],int n[],int k)
    {
    int s1=0,e1=k-1,s2=0,e2=k-1;//初始化初始化两个序列的上下限;
    int mid1;
    int mid2;
    while(s1<e1&&s2<e2)
    {
     mid1=(s1+e1)/2;//序列m的中位数下标
     mid2=(s2+e2)/2;//中位数n的中位数下标
     if(mid1==mid2)
     {
         cout<<m[mid1];
         return;
     }
     else if(m[mid1]<n[mid2])
     {
      s1=mid1+1;
      if((s2+e2)%2==0)
      {
       e2=mid2-1;
      }
       else e2=mid2;
     }
      else
      {
       s2=mid2+1;
       if((s1+e1)%2==0)
       {
        e1=mid1-1;
       }
        else
        {
         e1=mid1;
        }
      }
    }

      if(m[s1]<n[s2])//较小者即为所求
      cout<<m[s1];
      else
      
      cout<<n[s2];
       return;
     }

     void main()
     {
      int n[100];
      int m[100];
      int k;
      cout<<"数组元素的个数"<<endl;
      cin>>k;
      for(int i=0;i<k;i++)
      {
       cin>>n[i];
      
      }
      for(int j=0;j<k;j++)
      {

     cin>>m[j];
      }
         ZhWei(m,n, k);

     }

    由于每次求两个有序序列的中位数后,得到的两个子序列的长都是上溢序列的一半,因此循环共执行log2n次,时间复杂度为O(log2n),算法除简单变量外没有额外开辟存储空间 ,因此空间复杂度为O(1)

    展开全文
  • 给一串数据 I ...来得到其对应位上的数据的最长有序序列的长度L; 这是个经典的DP问题。 在这里我们利用F[i]的数组; 来储存其之前数据的最长有序序列 进而得到后面的。 /*最长有序

    给一串数据

    I012345678
    num[I]147258369

    来得到其对应位上的数据的最长有序子序列的长度L;


    I012345678
    num[i]147258369
    F[i]123234345


    这是个经典的DP问题。

    在这里我们利用F[i]的数组;

    来储存其之前数据的最长有序子序列

    进而得到后面的。



    /*最长有序子序列*/
    
    
    #include<iostream>
    using namespace std;
    
    int main()
    {
    	int num[]={1,4,7,2,5,8,3,6,9};
    	int F[9];
    	for(int i=0;i<=8;i++)
    	{
    		F[i]=1;//全都置为1,本身也是最长有序子序列的一个元素
    	}
    	for(int i=0;i<=8;i++)
    	{
    		cout<<F[i]<<" ";
    	}
    	cout<<endl;
    	for(int i=0;i<=8;i++)
    	{
    		for(int j=0;j<i;j++)
    		{
    			if(num[j]<num[i])
    				if(F[i]<F[j]+1)//当元素小于前面较之小元素的+1值才进行更新。
    				{
    					F[i]=F[j]+1;
    				}
    		} 
    	}
    	for(int i=0;i<=8;i++)
    	{
    		cout<<F[i]<<" ";
    	}
    	return 0;
    }
    
    
    

    刚开始写成了

    if(num[j]<num[i])
    <span style="white-space:pre">	</span>F[i]=F[j]+1;
    
     
    后来发现这样只计算了对应位置前面小于该值的数目。并没有计算出最长有序子序列。 
    

    因此当F[i]小于F[j]+1后才进行更新能保留住前面的最长有序子序列的值。



    展开全文
  • public void putAll(Map map) { int mapSize = map.size(); if (size==0 && mapSize!=0 && map instanceof SortedMap) { // 如果是有序Map,则执行自定义方法,否则调用父类putAll Comparator c = ((S
  • python 产生有序整数序列

    千次阅读 2018-11-24 14:55:00
    其中一种方法 A = np.linspace(0,n,n) 转载于:https://www.cnblogs.com/zhibei/p/10012149.html
  • 两个有序链表序列的合并

    万次阅读 2016-09-24 15:55:16
    02-线性结构1 两个有序链表序列的合并 (15分) 本题要求实现一个函数,将两个链表表示的递增整数序列合并为一个递增的整数序列。 函数接口定义: List Merge( List L1, List L2 ); 其中List结构定义...
  • Oracle创建序列,删除序列得到序列的例子 序列的创建 create sequence seq_newsId increment by 1 start with 1 maxvalue 999999999; 得到序列的SQL语句 select seq_newsid.nextval from sys.dual; ...
  • 已知两个已经排好序(非减序)的序列X和Y,其中X的长度为m,Y长度为n, 现在请你用分治算法,找出X和Y的第k小的数,算法时间复杂度为O(max{logm, logn})。 此题请勿采用将序列X和Y合并找第k小的O(m+n)的一般方法,...
  • 7-1 两个有序链表序列的合并 (10分)

    千次阅读 2020-03-18 15:51:31
    7-1 两个有序链表序列的合并 (10分) 已知两个非降序链表序列S1与S2,设计函数构造出S1与S2合并后的新的非降序链表S3。 输入格式: 输入分两行,分别在每行给出由若干个正整数构成的非降序序列,用−1表示序列的结尾...
  • 使序列有序的最少交换次数

    千次阅读 2018-09-14 09:05:51
    题目1: 给出一个序列,只交换相邻两数,使得序列升序排列,求出最少交换次数。...2.当完成最大数的交换后,可以将最大数从序列中划去不管了,即此时序列个数为n-1了,我们再在该序列中找到一个最大数,进...
  • 1、问题描述 一个数的序列bi,当b1 的时候,我们称...a2, ..., aN),我们可以得到一些上升的子序列(ai1, ai2, ..., aiK),这里1 i2 。比如,对于序列(1, 7, 3, 5, 9, 4, 8),有它的一些上升子序列,如(1, 7), (3, 4,
  • 7-2 两个有序链表序列的交集 (20 分)

    千次阅读 2019-09-07 09:07:33
    输入分两行,分别在每行给出由若干个正整数构成的非降序序列,用−1表示序列的结尾(−1不属于这个序列)。数字用空格间隔。 输出格式: 在一行中输出两个输入序列的交集序列,数字间用空格分开,结尾不能有多余空格...
  • 该函数生成对图像处理、信号处理、遗传算法等有用的序列(沃尔什)有序哈达玛矩阵。
  • 已知两个非降序链表序列S1与S2,设计函数构造出S1与S2的交集新链表S3。 输入格式: 输入分两行,分别在每行给出由若干个正整数构成的非降序序列,用−1表示序列的结尾(−1不属于这个序列)。数字用空格间隔。 输出...
  • 已知两个已经排好序(非减序)的序列X和Y,其中X的长度为m,Y长度为n, 现在请你用分治算法,找出X和Y的第k小的数,算法时间复杂度为O(max{logm, logn})。
  • 分别指向最小的和最大,让其先相加,会得到一个数 M ; 如果 M>sum ,则 j-- ; 如果 M ,则  i++ ; 如果 M==sum ,则打印出响应的值,并且 j--;i++ ,寻找下一对满足的值; 如果 i>j ,此时...
  • 2.将一个整数插入到该数组的序列中,使新得到的数组序列仍然有序。 class HalfSearh { public static void main(String[] args) { int arr[]={1,3,4,7,9,13,17}; //System.out.println(search(arr,8)); //
  • 序列化和反序列化的详解

    万次阅读 多人点赞 2018-09-19 09:09:29
    一、基本概念 1、序列化和反序列化的定义:  (1)Java序列化就是指把Java对象转换为字节序列的...对象转换为有序字节流,以便在网络上传输或者保存在本地文件中。  反序列化的最重要的作用:根据字节流中保存的对...
  • 序列化和反序列化的底层实现原理是什么?

    万次阅读 多人点赞 2018-04-07 13:53:41
    序列化和反序列化作为Java里一个较为基础的知识点,大家心里也有那么几句要说的,但我相信很多小伙伴掌握的也就是那么几句而已,如果再深究问一下Java如何实现序列化和反序列化的,就可能不知所措了!遥记当年也被问...
  • python 序列

    千次阅读 2018-08-21 13:00:40
    python数据的集合总称序列,分为有序序列和无序序列两类; 有序序列包括:  列表,元组,字符串 无序序列包括:  字典,集合,控制集合数据的对象 一、列表 列表:python中是有序的、可变数据集合,使用一对标识...
  • 下述二叉树中,哪一种满足性质:从任一结点出发到根的路径上所经过的结点序列按其关键字有序() a.二叉排序树 b.哈夫曼树 c.avl树 d.堆 答案:d 解析: 首先a, 二叉排序树(B树即为二叉搜索树或称二叉排序...
  • 编写一个程序,对于给定的一个有序的关键字序列,创建一棵高度最小的二叉排序树。并判断一个序列是否为该二叉排序树中的一个合法的查找序列 #include #include typedef struct node { int data; struct node *...
  • 时间序列预测算法总结

    万次阅读 多人点赞 2018-10-18 10:30:48
    time series data mining 主要包括decompose(分析数据的各个成分,例如趋势,周期性),prediction(预测未来的值),classification(对有序数据序列的feature提取与分类),clustering(相似数列聚类)等。...
  • 一个有序数列,序列中的每一个值都能够被2或者3或者5所整除, * 1是这个序列的第一个元素。求第1500个值是多少? * 这个类用来计算这个序列的第n个元素的值。 * */package bia.arithmetic;import java.util.Date;...
  •  将a[0……n-1]看成是n个长度为1的有序序列,然后进行两两归并,得到n/2(向上取整)个长度为2(最后一个有序序列的长度可能为1)的有序序列,再进行两两归并,得到n/4(向上取整)个长度为4(最后一个有序序列的长度...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 111,954
精华内容 44,781
关键字:

得到有序序列