精华内容
下载资源
问答
  • 合并两个有序序列

    千次阅读 2011-07-16 16:37:27
    经典写法合并两个有序序列,太简单了吧?还有专门讨论的必要吗?这是一个最简单的 Merge 版本:template void merge(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last

    经典写法

    合并两个有序序列,太简单了吧?还有专门讨论的必要吗?

    这是一个最简单的 Merge 版本:

    template<class InputIter1, class InputIter2, class OutputIter>
    void merge(InputIter1 first1, InputIter1 last1,
               InputIter2 first2, InputIter2 last2, OutputIter output) {
        for (; first1 != last1 && first2 != last2; ++output) {
            if (*first2 < *first1)
                *output = *first2, ++first2;
            else
                *output = *first1, ++first1;
        }
        for (; first1 != last1; ++first1, ++output)
            *output = *first1;
        for (; first2 != last2; ++first2, ++output)
            *output = *first2;
    }
    

    看似简单?为什么循环里面判断是:
            if (*first2 < *first1)
                *output = *first2, ++first2;
            else
                *output = *first1, ++first1;
    

    而不是:

            if (*first1 < *first2)
                *output = *first1, ++first1;
            else
                *output = *first2, ++first2;
    

    答案:排序的稳定性,有序序列可能存在相等的元素,对于相等的元素,在 output 中,前者可以保证 seq1 的实例在 seq2 中的之前,而后者反了过来,虽说仍然是确定的,但不符合人的直觉。

    为什么要两个不同类的 InputIter ? 只是付出了很小的努力,我们就达到了 merge 不同 iterator 的效用(注意,是效用,不是目标!),从理论上讲,InputIter1, InputIter2, OutputIter 完全可以是 不同的 iterator,并且,他们所指向的元素类型也可以不同,只要在相应的操作符下兼容即可。

    应用

    如此,最正常的应用莫过于于 merge_sort  了:

    template<class RandInputIter, class OutputIter>
    OutputIter
    merge_sort_loop(RandInputIter first, RandInputIter last, OutputIter output) {
        ptrdiff_t len = last - first;
        if (len <= 1) {
            if (len == 1)
                *output = *first, ++output;
            return output;
        }
        else {
            ptrdiff_t mid = len / 2;
            OutputIter lasto1 = merge_sort_loop(first      , first + mid, output);
            OutputIter lasto2 = merge_sort_loop(first + mid, last       , lasto1);
            merge(output, lasto1, lasto1, lasto2, first);
            std::copy(first, last, output);
            return lasto2;
        }
    }
    
    template<class RandIter>
    void merge_sort(RandIter first, RandIter last) {
        typedef typename std::iterator_traits<RandIter>::value_type val_t;
        boost::scoped_array<val_t> tmp(new val_t[last - first]); // exception safe
        merge_sort_loop(first, last, tmp.get());
    }
    
    

    在 merge_sort_loop 中,output  不必是 RandomAccessIterator !(stl 里面有 stable_sort/inplace_merge,效率和内存使用比这里的 merge_sort 都要低,生产系统中还是应该用 stl 。)

    这里说的只是经典的 merge 写法,有没有其它写法呢?只要仔细想,肯定有!

    另一种写法


    template<class InputIter1, class InputIter2, class OutputIter>
    OutputIter
    merge2(InputIter1 first1, InputIter1 last1,
           InputIter2 first2, InputIter2 last2, OutputIter output) {
        for (; first1 != last1 && first2 != last2; ++output) {
            if (*first2 < *first1) {
                do { // why use do .. while ?
                    *output = *first2;
                     ++output; ++first2;
                } while (first2 != last2 && *first2 < *first1);
                *output = *first1; ++first1;
            } else {
                do { // why use do .. while ?
                    *output = *first1;
                     ++output; ++first1;
                } while (first1 != last1 && !(*first2 < *first1)); // Important
                *output = *first2, ++first2;
            }
        }
        for (; first1 != last1; ++first1, ++output)
            *output = *first1;
        for (; first2 != last2; ++first2, ++output)
            *output = *first2;
        return output;
    }
    
    
    

    注意,为了实现稳定性,Important 行的条件是:
    while (first1 != last1 && !(*first2 < *first1))
    
    而非
    while (first1 != last1 && *first1 < *first2)
    


    这种写法有什么优势呢?搞那么复杂?

    这里有一道题目:原地合并两个单向链表,返回新的表头。

    简单生硬地套用经典写法:

    Node* mergelist(Node* a, Node* b) {
        if (NULL == a) return b;
        if (NULL == b) return a;
        Node* c = b->key < a->key ? b : a; // note:stablize
        do { // why use do .. while ?
            if (b->key < a->key) { // note:stablize
                Node* tmp = b->next;
                b->next = a;
                b = tmp;
            } else {
                Node* tmp = a->next;
                a->next = b;
                a = tmp;
            }
        } while (a && b);
        return c;
    }
    
    
    
    有问题吗?具体啥问题,慢慢找,不难找!

    套用新写法:

    Node* mergelist2(Node* a, Node* b) {
        if (NULL == a) return b;
        if (NULL == b) return a;
        Node* c = b->key < a->key ? b : a; // note:stablize
        do { // why use do .. while ?
            Node* prev;
            if (b->key < a->key) { // note:stablize
                do {        
                    prev = b;       
                    b = b->next;    
                } while (b && b->key < a->key); // stablize 
                prev->next = a;
            } else {
                do {        
                    prev = a;       
                    a = a->next;    
                } while (a && !(b->key < a->key)); // stablize 
                prev->next = b;
            }       
        } while (a && b); 
        return c;
    }
    


    其它(可能的困惑)
    !(y<x)

    可以看到,程序中很多地方使用了 ! (y < x) 的写法,而非 x <= y,为什么?

    一方面,stl 对 Comparable 的最小定义是 operator<,一个类型,如果定义了 operator<,那么它可以在直接使用所有stl的排序/堆/查找算法,还有 set/map, multiset/multimap 容器。但是 std::find 等在非排序序列上操作的算法不算。

    虽然,直观看,!(y < x) 和 x <= y 等价,然而,在数学定义上,两者并不等价,我们可以举出一些反例,但这些反例多多少看上去并不太“自然”。我正在努力寻找“很自然”的反例。

    boost 提供了一系列模板类来从 operator< 推导其它操作符: ==, !=, <=, >, >=,原理上都很简单。

    do {...} while

    一般情况下, while (expr) {... } 和 do {...} while (expr) 等价,如果循环之前 expr 为 true 的话,在这种情况下,我们应该用 do {... } while,主要原因有两点:

    1. 少了一次对 expr 的求值
    2. 减少了一次非条件(绝对)跳转,和至少一次条件跳转(参考编译原理关于代码生成的章节,或者直接看编译器生成的汇编码)
    当然,如果循环执行的次数很多的话,这个效率的损失微乎其微,但是,如果循环的执行次数很少,就像这本文例子中的,内循环的平均执行次数少于2次,这个多余的开销就相当可观了!
    展开全文
  • 有序列表和无序列表的不同类型

    千次阅读 2019-06-12 15:15:54
    大家可曾想过有序列表和无序列表除了默认类型,是否还有其它的类型呢? 虽然不常用,但也做了一篇总结给大家做参考。 无序列表 UL (unorder list的缩写) 定义:无序列表是一个项目的列表,此列项目默认使用粗体...

    大家可曾想过有序列表和无序列表除了默认类型,是否还有其它的类型呢?
    虽然不常用,但也做了一篇总结给大家做参考。

    无序列表 UL (unorder list的缩写)
    定义:无序列表是一个项目的列表,此列项目默认使用粗体圆点(典型的小黑圆圈)进行标记。
    无序列表始于 ul 标签,每个列表项始于 li。
    默认类型:ul type=”disc” 因为是默认类型,所以不需要写出来,直接ul即可。
    在这里插入图片描述
    显示形式为黑色实心圆圈
    在这里插入图片描述
    扩展:
    总共有3种不同类型:
    Ul type=“disc” 英文”discircle”的缩写,显示形式为实心圆。
    Ul type=”square” 显示形式为实心方块。
    Ul type=”circle” 显示形式为空心圆。

    有序列表(OL =order list的缩写)

    有序列表也是一列项目,列表项目使用数字进行标记。
    有序列表始于 ol 标签。每个列表项始于 li标签。
    默认类型:ol type=”1”。
    在这里插入图片描述
    显示形式为阿拉伯数字:
    在这里插入图片描述
    扩展

    1.5种不同类型
    Ul type=”1” 显示形式为1,2,3(默认形式)。
    Ul type=”A” 显示形式为A,B,C。
    Ul type=”a” 显示形式为a,b,c。
    Ul type=”I” 显示形式为大写罗马数字。
    Ul type=”i” 显示形式为小写罗马数字。

    2.倒叙
    如果想从最末位开始排序,用reversed属性即可。
    ul type=”1” reversed=”reversed”

    3.从别的位置开始排序
    如果不想从1开始排序,想从3开始排序。
    或者不想从A开始排序,而是从D开始排序,那么用start属性即可。
    注意从哪儿开始排,指的是这个数字或者字母在第几个位置,就写数字几。
    ol start=”3”
    ol type=”A” start=”4” (D排在第4个位置,A,B,C,D,所以是从第四个开始排,start=”4”)

    总结
    此处扩展仅作扩展知识使用,实际应用中基本都是直接用无序列表去掉格式做导航栏使用。

    展开全文
  • python数据类型 列表 list(有序)

    万次阅读 2018-05-06 11:45:37
    列表:list定义: 列表是由一系列元素组成的, 元素与元素之间可能没有任何的的关联关系, 但他们之间有先后顺序关系 列表是一种容器 列表是一种序列 列表是可以被改变的序列列表是可变的可以存放任意列表是一...

                            列表:list

    定义:
        列表是由一系列元素组成的, 元素与元素之间可能没有任何的的关联关系,
        但他们之间有先后顺序关系
        列表是一种容器
        列表是一种序列
        列表是可以被改变的序列

    列表是可变的
    可以存放任意
    列表是一种容器:
    列表是一种序列:
    是 有序的可变的容器

    可变的有
    list, dictionnary  set(集合) byte

    python 中的序列:
       字符串     str
       列表       list
       元组       tuple
       字节串      bytes
       字节数组    bytearray



    创建空列表的字面值:

    list1 = []   #L 绑定空列表


    创建非空列表的字面值:
     L = [1, 2, 3, 4]
     L = ['beijing','shanghai', 'shenzhen']
     L = [1, 'two', 3.3, '四']
     L= [ 1, 2, [3.1, 3.2, 3.3]]


    Python3中常用的列表方法(method)

    见:help(list)
    方法  意义
    L.index(v [, begin[, end]]) 返回对应元素的索引下标, begin为开始索引,end为结束索引,当 value 不存在时触发ValueError错误

    L.insert(index, obj)  将某个元素插放到列表中指定的位置

    L.count(x)  返回列表中元素的个数

    L.remove(x) 从列表中删除第一次出现在列表中的值

    L.copy()  复制此列表(只复制一层,不会复制深层对象)

    L.append(x) 向列表中追加单个元素

    L.extend(lst) 向列表追加另一个列表

    L.clear() 清空列表,等同于 L[:] = []

    L.sort(reverse=False) 将列表中的元素进行排序,默认顺序按值的小到大的顺序排列

    L.reverse() 列表的反转,用来改变原列表的先后顺序

    L.pop([index])  删除索引对应的元素,如果不加索引,默认删除最后元素,同时返回删除元素的引用关系


    示例:

    >>> list("hello")
    ['h', 'e', 'l', 'l', 'o']
    >>> list(range(1,10))
    [1, 2, 3, 4, 5, 6, 7, 8, 9]

    列表运算:
     +  +=  *  *=

    + 用于拼接列表
     x = [1,2,3]
     y = [4,5,6]
     z = x + y #z = [1, 2, 3, 4, 5, 6]

    += 用原列表与右侧列表拼接, 并用变量绑定列表
      
      x = [1, 2, 3]
      x += [4, 5, 6]   # x = [1, 2, 3, 4, 5, 6]


    * 生成重复的列表
      
      x = [1, 2 ] * 3  # x = [1, 2, 1, 2, 1, 2]
      y = 3 * [5, 6]   # y = [5, 6, 5, 6, 5, 6]

    *= 生成重复的列表, 并给原变量赋值
      
       x = [3, 4]
       x *= 2   #[3, 4, 3, 4]
       y = 3
       y *= [6, 7]  #[7, 8, 7, 8, 7,8]
       y * = x  等同于y  = y * x.

    列表的比较运算:
     < <= > >= == !=

     示例:
     [1, 2, 3 ] <[1, 2, 4 ]   #True
       [1, 3]  >   [1,2, 4]     #True
       [5] <       [5, 0]       #True
       ['ABC','123'] > ['abc','456'] #False

       [1, 'two'] > ['two', 1] TypeError int不能和str比较

    列表的in / not in 运算符:
        in 判断一个对象是否存在于容器内, 如果存在就返回True 否则
        就会返回 False
        用法同字符串的in相同

      (字符串中放的都是UNICODE值
    语法: 

       数据对象 in 容器

     示例;
         L = [ 1, 'Two', 3.3, '四']
         1   in L  #True
         2   in L  #True
         3.3 in L  #True
         "4" not in L  #True

    列表的索引和切片操作:

        语法:
           列表[整数表达式]
        用法:
           取值时, 等同于字符串的索引操作
           索引分为正向索引和反向索引, 规则与字符串索引规则完全相同
          
    support(支持)  assignment(赋值)   assignment(赋值)
    support(支持)

    列表支持索引赋值:
        
        列表是可变的序列,可以通过索引赋值改变列表中的元素

    示例:
       L = [1, 2, 3, 4]
       L [2] = 3.3  #将第三个元素改为3.3
                       

    列表是可以索引的 正向索引和反向索引[-1] [-2]
    列表的切片:
         语法:
          
        列表[:]                   
        列表[::]
        列表的切片取值时, 返回一个列表, 规则等同于字符串切片规则

    列表的切片赋值:  切片是就是原来的列表截取下来,建一个新的列表d
            作用:
       
              可以改变原列表的排序,可以插入和修改数据
              可以用切片改变列表的对应元素的值
            语法:
               列表[切片] = 可迭代对象
             注: 赋值运算符的右侧必须是一个可迭代对象

            示例:
             L= [2. 3. 4]
             L[0:1] = [1.1, 2.2]   # [1.1, 2.2, 3, 4]
             

             l = [2, 3, 4]
             l[1:] = [3.3, 4.4, 5.5]  # [2, 3.3, 4.4, 5.5]


             l = [2, 3, 4]
             l[:] = [0, 1]

             #实现中间插入
             l = [2, 4]
             l[1:1] = [3] # l = [2, 3, 4]
             l[1:1] = [3.3, 4.4] = [2, 3.3, 4.4, 4]

             #实现在前面插入[0, 1]
             l = [2, 3, 4] #实现在前面插入[0, 1]
             l[0:0] = [0, 1]

             l = [2, 3, 4] #实现在后面插入[5, 6]
             l = [3:3] = [5, 6]  #[2, 3, 4, 5, 6]
             l = [-1:-1] = [5, 6]
     
             #用range函数生成的可迭代对象赋值
             l = [1, 4]
             l =[1:1] = range(2, 4)
              l =[2, 3, 4]
              l[1:2] = "ABCD" #“ABCD" 也是可迭代对象

         切片的注意事项:
            对于步长不等于1的切片赋值, 赋值运算符右侧的可迭代对象
            提供的元素个数一定要等于切片切出的段数

          例:

            l = [1, 2, 3, 4, 5, 6]
            L = [::2] = "ABC" 对的
            # 以下切出三段, 但给出5个元素填充是错的
            L = [::2] = "ABCDE"


    del语句  用于删除列表中的元素
      语法:  ( 删除列表中的变量 )
        del  序列[整数表达式]
        del  序列[切片]

      示例:
      L = [1, 2, 3, 4, 5, 6]
      del l[-1]    #删除最后一个
      del l[0]     #删除第1个
      del l[::2]   #删除1, 3, 6



    python中常用于序列的函数:
       
    len(seq) 返回容器的元素的个数
    max()    返回序列中的最大值元素
    min(x)    返回序列中的最小值元素
    sum()    返回序列中所有元素的和(元素必须是数值类型)
    any(x)   真值测试, 如果容器内其中一个值为True则返回True则返回False
    all(x)   真值测试, 容器内所有元素的布尔值都为True 才返回True






    L.copy()    复制此列表(只复制一层,不会复制深层对象)
    l = [1, 2, 3]
    l2 = l.copy()
    l2.clear()
    l2为空了 
    1 没有变



    列表推导式 list comprehension

    列表推导式是用可迭代对象依次生成带有多个元素的列表的表达式

    作用:
       用简易方法生成列表

    语法:
       [表达式 for 变量 in 可迭代对象]

       或

       [表达式 for 变量 in 可迭代对象 if 真值表达式]



    问题:
       如何生成下列列表
       [1, 4, 9, 16, 25 ..... 81]

       for x in range(1, 10):
        l.apped(x)

    #用列表推导式生成:
     
    L = [x**2 for x in range(1, 10)]


    示例:
      生成[1, 9, 16, 25, 36......81] 列表,跳过所有的偶数

    [x **2 for x in range(1, 10) if x % 2 == 1]







    展开全文
  • 算法-有序序列中运用“压缩”思想

    千次阅读 2017-03-20 14:03:20
    在面对一个海量的有序序列时,海量数据往往会压迫到我们的神经,让我们沉在数据大海里。有没有一种更好的方法,让我们有针对性地分析这个问题,而不是沉在海量数据中呢?

    我们经常遇到在一个有序序列中进行一系列的操作,比如查找某个元素,插入某个元素,删除某个元素等,这里的有序序列,可能是线性的一对一的序列,也可能是二叉树的一对多序列,那么在面对一个海量的有序序列时,海量数据往往会压迫到我们的神经,让我们沉在数据大海里。

    然后有没有一种更好的方法,让我们有针对性地分析这个问题,而不是沉在海量数据中呢? 我们利用有序序列的特点,何不尝试用根据问题的性质,将海量压缩为1个单元数据呢?

    如果一个序列是这样的

       int sorted[10000] =  {1  4  5  8 12 111  114  115  118 122 2111  2114  2115  2118 2122 
        2221  2224  2225  2228 2312 2241  2514  2615  2718 2822 2911  
        3114  3115  3118 3222 4221  4224  4225  4228 4312 4641  4714  4815  
        4918 4922 5011  };

    现在要插入元素190,请问怎么分析这个问题。我们计划用二分查找,查找一个插入元素的合适的位置,然后放入元素。二分查找设计到两个端点,一个中点,并且原数据是有序的。所以,我们直接压缩为1个数据,这个数据时中点数据,

    n

    此时的中点位置为n,所以比较 sorted[n]与 190的大小,假如 sorted[n]小于190, 则 190只可能位于n后,此时的区间自然变为[n+1, 10000),相反,如果sorted[n]大于190,则190只能位于n前,即区间[0, n)处。

    兑现为代码:

           public static int searchInsertLocation(int[] sorted, int e)
            {
                int lo = 0;
                int hi = sorted.Length;
                while (lo < hi) 
                {
                    int mi = (lo + hi) >> 1;
                    if (e < sorted[mi])
                        hi = mi;
                    else 
                      lo = mi + 1;
                }
                return lo;
            }

    因此根据有序序列,将大量的数据压缩为1个或几个有代表性的数据,可以让问题变得精简!

    展开全文
  • Java 中的 List —— 有序序列

    万次阅读 2018-08-21 21:54:00
    List 在 java 中是个有序序列: 一、容量 ArrayList 中有一个容量概念,表示基础数组的大小(无参时默认为 10)。在需要的时候(比如 add操作)会自动增加其容量。LinkedList 没有这个概念。 TreeMap 也有容量,...
  • python 中list、tuple等有序序列

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

    2019-03-25 23:32:00
    序列类型:字符串类型、元组类型列表类型 序列类型通用操作符 6个操作符 元组是序列类型的一种扩展 -元组是一种序列类型,一旦创建就不能修改 -使用小括号()或tuple()创...
  • 有序序列中查找某关键字的区间

    千次阅读 2019-02-13 11:14:13
    * 在有序序列中查找某关键字的区间 * 实验目的: * 掌握折半查找的过程及其算法设计 * 实验内容: * 设计程序,在有序序列中查找某关键字的区间。 * 例如序列为(1,2,2,3),对于关键字2,其位置区间[1,3)。 * 解决思路:...
  • list是处理一组有序项目的数据结构,即你可以在一个列表中存储一个序列的项目。 列表是可变类型的数据。 用[]表示列表,包含了多个以逗号分割开的数字或者字符串。 >>> list1 = ['1','chen','陈'] >>> list2 = [1,2,...
  • 有序序列有:列表、元组、字符串 无序序列有:字典、集合 可变序列有:列表、字典、集合 不可变序列有:字符串、元组
  • 如果需要修改有序序列,我们应该使用类别而非元组。如果要对元组进行修改,可以使用list()转换函数将其转换为列表,之后在产生的列表之上进行适当修改。tuple数据类型可以作为一个函数进行调用,tuple()---不指...
  • //这里定义一个模板函数,它可以把一个有序序列变成随机序列 { if(p_myrandom==NULL) { random_shuffle(v.begin(),v.end());//此处调用STL中的模板函数产生随机序列 } else { random_shuffle(v....
  • * 由有序序列创建一颗高度最小的二叉排序树 * 实验目的: * 掌握二叉排序树的构造过程及其算法设计 * 实验内容: * 设计程序,对于给定的一个有序的关键字序列,创建一颗高度 * 最小的二叉排序树。 * 解决思路: * 要...
  • python序列类型

    2020-04-28 18:57:52
    定义 序列是具有先后关系的一组元素(有序性... 序列是一个基类类型:字符串,元组,列表都是序列类型 序列类型的通用方法: len(s) :返回序列的长度 min(s) :返回s中最小的元素,元素需要可以比较 max(s) :...
  • Python-序列类型及操作

    千次阅读 2019-09-27 11:57:32
    1. 序列类型定义 序列是具有先后关系的一组元素 序列是一维元素向量,元素类型可以不同; 类似数学元素序列:; 元素间由序号引导,通过下标访问序列的特定元素 序列是一个基类类型 2. 序列处理函数及方法 ...
  • 两个有序链表序列的合并 标签(空格分隔): 数据结构 算法竞赛 02-线性结构1 两个有序链表序列的合并(15 分) 本题要求实现一个函数,将两个链表表示的递增整数序列合并为一个非递减的整数序列。 函数接口...
  • 【Python】python序列类型

    千次阅读 2015-05-05 08:42:41
    在python中,序列类型包括字符串(普通字符串和unicode字符串)、列表和元组,所谓序列,即成员有序排列,可通过下标访问。假设序列有n个元素,访问单个元素时,下标从0开始,到n-1结束,如果是逆序访问,下标从-1...
  • 序列类型及其操作

    2018-08-05 16:55:00
    序列类型定义 序列是具有先后关系的一组元素 --- 序列是一维元素向量,元素类型可以不同 ... 列表类型   序列类型统用操作符   序列类型统用函数和方法     元组类型及操作   元组类型定...
  • PTA 两个有序链表序列的合并

    千次阅读 2017-11-15 22:16:48
    02-线性结构1 两个有序链表序列的合并(15 分) 本题要求实现一个函数,将两个链表表示的递增整数序列合并为一个非递减的整数序列。 函数接口定义: List Merge( List L1, List L2 ); 其中List结构...
  • python的数据结构主要就是序列,而列表、元组和字典三种类型比较容易混淆,特地做了个笔记记录了一下,供大家学习: 列表有序可变序列   创建:userlist = [1,2,3,4,5,6]   修改:userlist[5] = 999   ...
  • Python序列类型

    千次阅读 2017-12-25 11:58:17
    序列类型本文是《流畅的Python》一书第二章的笔记。Python内置了强大的数据结构,除了基本的数值类型和布尔值外,Python还有各种集合类型,包含了:序列(sequence)、映射(mapping)和集合(set)。序列类型可分为两大类...
  • 《Python基础语法全体系》系列博文第三篇,本篇博文将详细深入地讲解Python的组合数据类型,包括集合类型及其常用操作,序列类型列表与元组常用操作,以及映射类型:字典的常用操作。
  • 序列类型是一个基类类型,字符串,元组,和列表属于序列类型 序号的定义有两种,正向递增序号和反向递减序号 序列处理函数及方法(6种) 6个操作符 x in S 判断元素x是否在序列S中,如果在则返回True x not ...
  • 序列 序列的标准操作符 切片操作符 一个例子 序列的功能函数 enumerate 枚举出序列对象的元素 len 获取序列对象的长度 min 取出sequence中的最小值 max 取出sequence中的最大值 reversed 返回一个逆序访问的迭代器 ...
  • 两个有序链表序列的合并 (15分)

    千次阅读 2020-01-15 11:09:00
    两个有序链表序列的合并 (15分)本题要求实现一个函数,将两个链表表示的递增整数序列合并为一个非递减的整数序列。 函数接口定义: List Merge( List L1, List L2 ); 其中List结构定义如下: typedef struct Node...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 117,669
精华内容 47,067
关键字:

列表类型属于有序序列