精华内容
下载资源
问答
  • 列表-拉链

    千次阅读 2014-09-30 11:48:29
    若选定的散列表长度为m,则可将散列表定义为一个由m个头指针组成的指针数组T[0..m-1]。凡是散列地址为i的结点,均插入到以T[i]为头指针的单链表中。T中各分量的初值均应为空指针。在拉链中,装填因子α可以大于1,...
    拉链法
    (1)拉链法解决冲突的方法
         拉链法解决冲突的做法是:将所有关键字为同义词的结点链接在同一个单链表中。若选定的散列表长度为m,则可将散列表定义为一个由m个头指针组成的指针数组T[0..m-1]。凡是散列地址为i的结点,均插入到以T[i]为头指针的单链表中。T中各分量的初值均应为空指针。在拉链法中,装填因子α可以大于1,但一般均取α≤1。

    【例9.2】已知一组关键字和选定的散列函数和例9.1相同,用拉链法解决冲突构造这组关键字的散列表。
      解答:不妨和例9.1类似,取表长为13,故散列函数为h(key)=key%13,散列表为T[0..12]。
    注意:
         当把h(key)=i的关键字插入第i个单链表时,既可插入在链表的头上,也可以插在链表的尾上。这是因为必须确定key不在第i个链表时,才能将它插入表中,所以也就知道链尾结点的地址。若采用将新关键字插入链尾的方式,依次把给定的这组关键字插入表中,则所得到的散列表如下图所示。

     




    (2)拉链法的优点
         与开放定址法相比,拉链法有如下几个优点:
      (1)拉链法处理冲突简单,且无堆积现象,即非同义词决不会发生冲突,因此平均查找长度较短;
      (2)由于拉链法中各链表上的结点空间是动态申请的,故它更适合于造表前无法确定表长的情况;
      (3)开放定址法为减少冲突,要求装填因子α较小,故当结点规模较大时会浪费很多空间。而拉链法中可取α≥1,且结点较大时,拉链法中增加的指针域可忽略不计,因此节省空间;
      (4)在用拉链法构造的散列表中,删除结点的操作易于实现。只要简单地删去链表上相应的结点即可。而对开放地址法构造的散列表,删除结点不能简单地将被删结点的空间置为空,否则将截断在它之后填人散列表的同义词结点的查找路径。这是因为各种开放地址法中,空地址单元(即开放地址)都是查找失败的条件。因此在用开放地址法处理冲突的散列表上执行删除操作,只能在被删结点上做删除标记,而不能真正删除结点。

    (3)拉链法的缺点
         拉链法的缺点是:指针需要额外的空间,故当结点规模较小时,开放定址法较为节省空间,而若将节省的指针空间用来扩大散列表的规模,可使装填因子变小,这又减少了开放定址法中的冲突,从而提高平均查找速度。 
    展开全文
  • python list列表的乘除

    千次阅读 2020-04-30 20:46:05
    由于需要对列表数据整体处理,所以需要遍历整个 列表元素,这里 以全int型数据为例 x = [72, 50, 81, 74, 94, 86, 59, 83, 65, 33, 88, 81] x_=[] for i in x: i/=10 #对数据逐个处理 x_.append(i) x=x_ print(x) ...

    1

    由于需要对列表数据整体处理,所以需要遍历整个 列表元素,这里 以全int型数据为例

    x = [72, 50, 81, 74, 94, 86, 59, 83, 65, 33, 88, 81]
    x_=[]
    for i in x:
        i/=10   #对数据逐个处理
        x_.append(i)
    x=x_
    print(x)
    

    2

    上述是利用for 循环实现的,也可不用,如下:

    x = [72, 50, 81, 74, 94, 86, 59, 83, 65, 33, 88, 81]
    s=[10,10,10,10,10,10,10,10,10,10,10,10]
    xx=[a/b for a,b in zip(x,s)]     #利用该语句实现
    x=xx
    print(x)
    
    

    3

    还有一种情况假如要除的数是数值,但是由这个列表内数值计算出的,那么可以用

    x[:]=x[:]/x_std
    

    这条语句来实现,以下面例子来方便读者体会:

        x=[]
        y=[]
        data = [[72, 84], [50, 63], [81, 77], [74, 78], [94, 90], [86, 75], [59, 49], [83, 79], [65, 77], [33, 52],
                [88, 74], [81, 90]]
        for a,b in data:
            x.append(a)
            y.append(b)
        x_mean = np.mean(x)
        x_std = np.std(x)
        y_mean = np.mean(y)
        y_std = np.std(y)
        xx=[]
        yy=[]
        xx[:]=x[:]-x_mean
        xx[:]=x[:]/x_std
        yy[:]=y[:]-y_mean
        yy[:]=y[:]/y_std
    

    4

    当然 可以用numpy数组 ,将列表转为numpy数组,之后循环遍历也可以
    如下:

    import numpy as np
     
    a = np.array([1,1,1])  #这样的确简单,但考虑到可能你还需要再转回list类型,也可以不用这种方法,而用上面几种
    c = a/3
    print(c)
    

    注意以下是不可以的!!!

    a = [1.0, 1.0, 1.0]
    c = a/3          # 这样是不可以的
    #会出现 TypeError: unsupported operand type(s) for /: 'list' and 'int'
    print(c)
    

    另附笔记二维列表不能和数组一样循环遍历

    在这里插入图片描述

    另外对列表的拼接以及元素级的相加,还有相减,相乘等看下面这个blog:
    https://blog.csdn.net/jp_666/article/details/98055191?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1

    展开全文
  • 列表之开放定址

    千次阅读 2015-07-12 00:13:46
    列表之开放定址列表的基本操作 插入操作_INSERT 查找操作_SEARCH 删除操作_DELETE 散列表的探查方法probe methods 散列表探查的定义 线性探查 二次探查 双重散列 总结注意: 本文中所有的代码你可以在这里:...

    注意:
    本文中所有的代码你可以在这里:

    https://github.com/qeesung/algorithm/tree/master/chapter11/11-4/openAddressing(这里会及时更新)

    或者这里:

    http://download.csdn.net/detail/ii1245712564/8891141

    找到

    散列表之开放定址法

    在前面的文章中我们介绍过《散列表之链接法》,在链接法中,如果不同键值却将有相同的映射值,即有不同键值的元素却映射到散列表中的同一位置,那么就采用链表的方法,将映射到同一位置的元素插入到同一个链表之中,当需要删除, 查询元素时,只需要遍历该链表即可,链接法在最坏情况下删除和查询元素的时间代价为O(n)

    今天我们来讲散列表中另外一种解决冲突的方法,那就是开放定址法(open addressing)

    假如你在外面旅游时,吃坏东西,急需上厕所,当你好不容易找到一件洗手间的时候,发现排了好多人,这时你会怎么做?

    • 如果是链接法:排队不就行了,我就在外面等,迟早会排到我的
    • 如果是开放定址法:直接放弃现有厕所,去寻找新的厕所

    没错,放弃已被占用的位置,寻找新的插入位置就是开放定址法的思想,开放定址法中的开放二字指的是没有被占用的位置,定址指的是确定位置。开放定址法中,所有的元素都放在散列表中(链接法放在链表中)。也就是说散列表中的每一个位置,要么有元素,要么没有元素。当需要删除,查询元素时,我们从某一个位置开始,按照某种特定的确定下一个位置的方法来检查所有表项,直到找到目标元素,或者没有找到。

    散列表的基本操作

    散列表有三种最基本的操作:

    • 插入元素:INSERT(ele)
    • 查询元素:SEARCH(k)
    • 删除元素:DELETE(ele)

    下面我们给出开放定址法散列表的定义

    template < class T >
    class OpenAddressingTable
    {
        public:
            typedef size_t (*Hash_Func_Type)( const T & , size_t , size_t);// [> 定义散列函数的指针 <]
            /* 描述表的一个位置的状态 */
            enum ELE_STATUS{
                EMPTY=0,// 空的
                DELETED=1,// 被删除的
                FULL=2 //有元素的
            };
            // ====================  LIFECYCLE     =======================================
            OpenAddressingTable (size_t array_size ,Hash_Func_Type _hash_func=NULL) ; /** constructor      */
            ~OpenAddressingTable ()                                                 ; /** destructor       */
            /** ====================  MUTATORS      ======================================= */
            bool hash_insert(const T & t)                    ; /*  向散列表中插入新的元素 */
            bool hash_search(const T & t , T & target) const ; /*  在散列表中查找键值 */
            bool hash_delete(const T & t)                    ; /* 在散列表中删除键值对应的元素 */
            void hash_clear();
    
        private:
            /** ====================  DATA MEMBERS  ======================================= */
            T * array_ptr                 ; /*  散列表的数组指针 */
            const size_t array_size       ; /* 散列表数组的大小 */
            ELE_STATUS * status_array_ptr ; /* 用于存放各个位置的状态信息*/
            Hash_Func_Type HASH           ; /* 采用的散列函数,这个函数用户也可以自己指定 */
    
    }; /** -----  end of template class OpenAddressingTable  ----- */
    
    #include "open_addressing.cc"
    #endif   /* ----- #ifndef OPEN_ADDRESSING_INC  ----- */

    插入操作_INSERT

    只要我们找到的位置没有元素在里面,那么表示这个位置可以插入新的元素

    /**
     *  插入一个元素
     *  @param t 要插入的元素
     */
    template < class T >
    bool OpenAddressingTable<T>::hash_insert (const T & t)
    {
        size_t i = 0;
        while(i!= array_size)
        {
            size_t j = HASH(t , i , array_size); // 取出位置
            if(status_array_ptr[j] != FULL) // 判别元素是否是开放为空的
            {
                array_ptr[j] = t;   //插入元素
                status_array_ptr[j] = FULL;//并将该位置状态设为已经被插入
                return true;
            }
            ++i;
        }
        std::cerr<<"hash table overflow"<<std::endl;
        return false;
    }       /** -----  end of method OpenAddressingTable<T>::hash_insert  ----- */

    查找操作_SEARCH

    查找操作和插入操作比较类似,查找操作是要找到有非空位置,并判断是否是目标元素,当遇到为EMPTY的时候,说明之后元素也不必再检查,因为后面已经没有元素了

    /*
     * 查找元素
     * @param t      要查找的键值
     * @param target 返回找到的目标
     */
    template < class T >
    bool OpenAddressingTable<T>::hash_search (const T & t , T & target) const
    {
        size_t i = 0;
        while(i != array_size)
        {
            size_t j = HASH(t , i , array_size) ;
            if(status_array_ptr[j] == EMPTY) // 之后就再也没有元素了
                return false;
            else if (status_array_ptr[j] == FULL)
            {
                if(array_ptr[j].key == t.key )  
                {
                    target = array_ptr[j];
                    return true;
                }
            }
            ++i;
        }
        target = T();
        return false;
    }           /** -----  end of method OpenAddressingTable<T>::hash_search  ----- */

    删除操作_DELETE

    删除操作和上面两个操作也比较相似,但是有一点需要注意,那就是已删除元素的散列表位置不能标记为EMPTY,而是要标记为DELETED,因为在查找操作中是以EMPTY作为探查的终止,如果标记为EMPTY,那么在被删元素之后的那些元素就会丢失

    
    template < class T >
    bool OpenAddressingTable<T>::hash_delete (const T & t)
    {
        size_t i = 0;   
        while(i !=array_size)
        {
            size_t j = HASH(t , i , array_size);
            if(status_array_ptr[j] == EMPTY)
                return false;
            else if (status_array_ptr[j] == FULL)
            {
                if(array_ptr[j].key == t.key )  
                {
                    status_array_ptr[j] = DELETED;// 不应该是EMPTY
                    return true;
                }
            }
            ++i;
        }
        return false;
    }       /** -----  end of method OpenAddresingTable<T>::hash_delete  ----- */

    散列表的探查方法(probe methods)

    上文提到,我们从某一个位置开始,按照某种特定的确定下一个位置的方法来检查所有表项,而这种特定的确定下一个位置的方法就是我们这里的探查方法。

    在进入正题前,我们首先来看两个问题:

    问题一:为什么需要探查?

    回答一:前面我们讲过,开放定址法在一个位置被占用时,就会去寻找下一个新的位置,那这个找的方法也不是乱找。那么就需要按照一定的查找规律去一个一个的探查。


    问题二:什么样的探查才算是一个好的探查?

    回答二:一个好的探查一定是可以等可能的探查散列表中的所有表项的,每个关键字的探查序列等可能的为<0,1,2,...,m1>m!种排列中的一种。但是这种探查只是理想化的,我们只能做到尽可能的趋近。

    散列表探查的定义

    为了使用开放定址法插入一个元素,需要连续的检查散列表,直到找到一个新的空槽来放置带插入的元素为止。检查的顺序不一定是0,1,2,…,m-1的这种顺序,而是要依赖待插入的关键字key,为了确定探查哪些槽,我们将散列函数加以扩充,使之包含探查号作为第二个输入参数,于是散列函数就定义为:

    h:U×{0,1,2,...,m1}{0,1,2,...,m1}

    对于每一个关键字k,使用开放定址法得到的探查序列<h(k,0),h(k,1),...,h(k,m1)>都是{0,1,2,...,m1}的一个排列。

    在下面我们将介绍三种探查的方法,这三种探查的方法都能保证每一个关键字的探查序列都是{0,1,2,3,...,m1}的一个排序,但是并不能做到等可能的为{0,1,2,3,...,m1}m!排列中的一个。

    线性探查

    给定一个辅助散列函数_h:U{0,1,2,...,m1},那么线性探查的散列函数为:

    h(k,i)=(_h(k)+i) modm,  i=0,1,2,...,m1

    首先我们探查HashTable[_h(k)] modm位置,如果发现已经被占用,那么就探查HashTable[_h(k)+1] modm,如果也被占用了,那么就探查HashTable[_h(k)+2] modm,以此类推,直到找到合适的位置,或者探查了m次以后到位置HashTable[_h(k)1] modm,那么探查停止。

    /**
     * 辅助散列函数
     * @param t          要插入的元素
     * @param array_size 散列表的大小
     */
    template < class T >
    size_t _hash (const T & t , size_t array_size) 
    {
        return t.key%array_size;
    }       /** -----  end of method OpenAddressingTable<T>::_hash  ----- */
    
    /**
     * 线性探查  
     * @param t           要插入的元素
     * @param offset      探查号
     * @param array_size  散列表大小
     */
    template < class T >
    size_t linear_probing (const T & t, size_t offset , size_t array_size) 
    {
        return (_hash(t , array_size)+offset)%array_size;
    }       /** -----  end of method OpenAddresingTable<T>::linear_probing  ----- */

    举个栗子:
    假设现在有大小为5的散列表,现在要插入三个元素{a1(key=0),a2(key=1),a3(key=5)}到散列表中

    Alt text

    插入a1,h(0,0)=0,位置0为空,可以直接插入

    Alt text

    插入a2,h(1,0)=1,位置1为空,可以直接插入

    Alt text

    插入a3,首先探查好h(5,0)=0,发现位置0已有元素,那么接下来探查h(5,1)=1,发现位置1也有元素了,于是继续探查h(5,2)=2,2位置为空,可以插入

    Alt text

    可能你也发现上面的问题了,如果我们要查找a3,那么就要经过一个a1,a2的探查,其中a1a3的辅助散列值相同,要经过a1的探查还算是情有可原,但是a2a3基本算是无关元素,我要找a3,还要探查一次a2,这样未免也太慢了,而且随着插入的元素越来越多,将会探查的不相关的元素就越来越多,连续被占用的糟会越来越长,那么效率就越来越低,这种问题称为一次群集线性探查一次群集最为严重探查方法,我们可以使用下面两种更为巧妙的探查方法来避免一次群集

    二次探查

    二次探查相对于线性探查来说,在散列函数中添加了一个二次项:

    h(k,i)=(_h(k)+c1i+c2i2) modm

    其中h是一个辅助散列函数,c1,c2为正常的辅助常数,初始的探查位置是_h(k) modm虽然二次探查不存在像线性探查哪样的严重群集,但是还是存在一定的群集现象,该群集现象称为二次群集
    /**
     *  二次探查
     */
    template < class T >
    size_t quadratic_probing (const T & t , size_t offset , size_t array_size) 
    {
        return (_hash(t , array_size)+offset*offset)%array_size;
    }       /** -----  end of method OpenAddressingTable<T>::quadratic_probing  ----- */
    

    双重散列

    双重散列是用于开放定址法的最好的探查方法之一,因为双重散列对于任何一个键值来说,得到的探查序列都是足够随机的,双重散列采用下面的散列函数:

    h(k,i)=(h1(k)+ih2(k)) modm

    其中h1h2分别是两个辅助散列函数,起始的散列表项为h1(k) modm

    有一个散列函数就已经够头疼的了,现在还多了一个新的辅助散列函数,为了能查找整个散列表,值h2(k)必须要与散列表的大小m互素。有一种简便的方法可以保证这个条件成立,就是取m为2的幂,并设计一个总产生奇数的散列函数h2。另一种方法是取m为素数,并设计一个总产生比m小d额正整数的函数h2

    比如在我们去m为一素数的时候,我们可以讲散列函数设计如下

    h1(k)=k modm,h2(k)=1+k mod(m1)
    /**
     *  双重散列的第二个辅助函数
     */
    template < class T >
    size_t _hash1 (const T & t  , size_t array_size) 
    {
        return (1+t.key%(array_size-1));
    }       /** -----  end of method OpenAddressingTable<T>::_hash1  ----- */
    
    
    /**
     *  双重散列
     */
    template < class T >
    size_t double_hashing (const T & t , size_t offset , size_t array_size) 
    {
        return (_hash(t , array_size)+offset*_hash1(t , array_size))%array_size ;
    }       /** -----  end of method OpenAddressingTable<T>::double_hash  ----- */

    总结

    开放定址法的所有元素都存在于散列表之内,每一个表项要么存在元素,要么就为空,当发生映射值冲突的时候我们可以探查新的位置。最好的探查方法是双重散列,因为双重散列产生的探查序列足够随机,不像线性探查二次探查哪样存在较为严重的群集现象。

    开放定址法相对于链接法来说,可以将存储链表指针的内存空出来存储更多的数据,直接跳过了指针的操作,而是用数组的直接访问来访问元素,但是如果探查散列函数设计差劲的话,将会严重拖慢散列表的速度!

    展开全文
  • 数字电路基础知识——数字逻辑代数(逻辑代数公式、卡洛图的运用、Q-M法化简(列表法)) 本节主要介绍逻辑代数的公式、及逻辑函数的化简、包括公式法化简、卡洛图化简、Q-M列表法化简。 一、逻辑代数的三个基本运算 ...

    数字电路基础知识——数字逻辑代数(逻辑代数公式、卡洛图的运用、Q-M法化简(列表法))
    本节主要介绍逻辑代数的公式、及逻辑函数的化简、包括公式法化简、卡洛图化简、Q-M列表法化简。重点需要知道前面两种的方法,第三种可以了解,能够帮助自己更深的了解逻辑相邻项的理解

    一、逻辑代数的三个基本运算

    逻辑代数中最基本的三个运算:与、或、非
    基本的函数关系如下:
    在这里插入图片描述

    二、逻辑代数的基本定律
    1. 基本公式

    在这里插入图片描述
    在这里插入图片描述

    比较重要的是后面三个定律:

    1. 反演律(德摩根律)
      使用此定律可以将乘积项和项打开。
      具体规则是 × 变++变×原变量变反变量,反变量变原变量
    2. 吸收律
      重点知道这个:A+A’B=A+B、A+AB=A、A(A+B)=A
      A+A’B
      =A+AB+A’B
      =A+B(A+A’)
      =A+B
    3. 冗余律
      AB+A’C+BC=AB+A’C
      AB+A’C+BC
      =AB+A’C+(A+A’)BC
      =AB+A’C+ABC+A’BC
      =AB+ABC+A’C+A’BC
      =AB(1+C)+A’C(1+B)
      =AB+A’C
    2. 基本定理
    1. 代入定理
      任何一个逻辑式代入原来式中所有的相同变量的位置,等式仍然成立。

    2. 反演定理

    3. 对偶定理
      若两逻辑等式相等,则他们的对偶式也相等
      对偶定理主要在某些情况下,证明某式成立时,可以通过证明其对偶式成立来简化证明。
      如:
      Y=A(B+C),则YD=A+BC
      Y=(AB+CD)’,则YD=((A+B)(C+D))’
      Y=AB+(C+D)’,则YD=(A+B)(CD)’
      在这里插入图片描述

    三、逻辑函数的两种标准式
    1. 最小项
      n个变量的最小项是含n个变量的与项,其中每个变量都是以原变量或反变量的形式出现一次。
      通常用mi表示各项。
      在这里插入图片描述
      在这里插入图片描述
      如:对于下面的逻辑表达式:
      在这里插入图片描述

    2. 最大项
      n个变量的最大项是含n个变量的或项,其中每个变量都是以原变量或反变量的形式出现一次。
      通常用Mi表示各项。

    3. 最大项和最小项的性质
      n变量的全部最小项之和恒为1,全部最大项之积恒为0.
      任意两个最小项之积恒为0,任意两个最大项之和恒为1.
      n变量的每一个最小项或者最大项有n个相邻项(相邻项是指两个最小项只有一个因子互为反变量,其余因子均相同,又称逻辑相邻项

    四、逻辑函数的卡洛图化简

    公式法化简逻辑函数其实就是用上面的公式来化简。
    主要介绍一下卡洛图化简。

    1. 相邻项
      首先需要知道相邻项的概念,即两个最小项只有一个因子互为反变量,其余因子均相同,又称逻辑相邻项
    2. 卡洛图
      把任意两个逻辑上相邻的最小项变为几何中的相邻,做到逻辑相邻和几何相邻
      2变量卡洛图:由代表四个最小项的四个方格组成:
      在这里插入图片描述
      三变量卡洛图由8个最小项组成,需要注意的是最小项编码和格雷码的编码类似,即相邻位置或者首尾是逻辑相邻。:
      在这里插入图片描述
      四变量如下(一般卡洛图的化简至多四-五个变量):
      在这里插入图片描述
    3. 逻辑函数在卡洛图的表示
      在这里插入图片描述
      如:
      在这里插入图片描述
    4. 卡洛图最小项合并规则
      任何两个为一的相邻最小项可以合并为一项,并消去一个变量(消去的是互为反变量的因子,保留公因子)
      在这里插入图片描述
      任何四个为一的相邻最小项(可以是循环相邻)可以合并为一项,并消去两个变量
      在这里插入图片描述
      在这里插入图片描述
    5. 图形法化简的基本步骤

    第一、将函数化为最小项之和的形式,然后做函数的卡洛图,确定卡洛图方格矩阵
    第二、画卡洛圈(要遵循卡洛圈最少,最大的原则)
    第三、写逻辑表达式(相同变量留下,不同变量去掉)

    五、Q-M法化简逻辑函数(奎恩-麦克拉斯基),也叫列表化简法

    卡洛图法化简虽然比较直观,简单,但是也有自身的缺点,如当逻辑变量大于五个之后,会变得很困难。
    而公式法化简虽然虽然不受变量数量的影响,但是化简过程并没有固定、通用的步骤。所以也很难借助计算机辅助进行化简。
    本节介绍一下Q-M法化简,本质上也是通过相邻最小项消去多余因子,来求逻辑函数的
    在这里插入图片描述
    先将函数表达式用最小项之和的形式表示:
    如下面的函数表达式:

    1. Y=Σm(0,3,4,5,6,7,8,10,11)
    2. 将其按照一个个数一次排列分组,如下:
      在这里插入图片描述
    3. 合并相邻的最小项
      即将上表中每一组的每一个最小项与相邻组所有的最小项逐一比较,若仅有一个因子不同,则可以合并,并消去不同的因子。如下,例如罪域m0和m4仅尤一位不一样,所以这一位可以合并为0-00,同时将上表中可以合并的用“对号”表示,不能合并的用Pi表示。
      按照同样的方法,可以在次合并下面左边的一列,可以合并的用“对号”表示,不能合并的用Pi表示。
      在这里插入图片描述
      因此经过以上的并向合并,留下了没有合并过的最小项Pi,所以就包含了函数Y的全部最小项,因此,可以表示为:
      Y=P1+P2+P3+P4+P5+P6+P7
      需要注意的是上面的表达式并不一定是最简结果,将所有Pi列成如下表格。

    在这里插入图片描述
    上表格中的m5、m6、m8都是只在Pi中只出现了一次所以最小项一定包含P1和P4,所以选取了这两项之后,以及包含了m4、m5、m6、m7、m8、m10这六个,除去之后剩下的m0、m3、m11如下表所示:

    mi 0 3 11
    P2 ×
    P3 ×
    P5 ×
    P6 × ×
    P7 ×

    现在就是化简上面的结果了,因为P2和P3都有m0,因此可以去任何一项作为最简项。
    对于P5、P6、P7,由于P5和P7行的所有项均包含在P6中,因此P6包含了P5、P7的所有最小项,故将P5、P7删掉。因此最终的结果是:
    Y=P1+P4+P3+P6

    展开全文
  • 前言 排序(Sorting) 是计算机程序设计中的一种重要操作,它的功能是将一个数据元素(或...通过对列表里的元素大小排序进行阐述。 原文地址:https://blog.zeruns.tech/index.php/archives/297/ 一、选择排序 选择...
  • 作者:闲鱼技术-齐悟玩平台背景    在闲鱼内我们把供给用户的闲鱼红包、支付宝红包、包邮券、宝卡等统称为用户权益。是闲鱼用户运营的重要策略,在拉新、留存、促活、裂变等方面都展现了其...
  • python 列表元组加减乘除

    千次阅读 2019-10-07 18:23:16
    元组(typle)列表(list)没有减法和除,但有加法和乘法。 1、加法,即把元素相加。只可以list和tuple相加,不能加其他类型。 t= (1, ) + (2, 3, 4) print(t, type(t))  输出为 (1, 2, 3, 4) <class '...
  • (2)从键盘输入各记录,分别以电话号码和用户名为关键字建立散列表; (3)采用一定的方法解决冲突; (4)查找并显示给定电话号码的记录; (5)查找并显示给定用户名的记录。 【选内容】 (1)系统...
  • 前段时间把博客迁到了腾讯云,感觉非常棒,再也不怕网站打开速度慢,再也不怕被人DDOS,再也不怕服务商跑路了……有朋友问我是怎么在腾讯云上博客的,专门为他写一个指引,希望对大家也有帮助。当然博客好建,难于...
  • WOW法师技能全列表(旧)

    万次阅读 2007-09-20 09:17:00
    Mage全技能表注解:1:所有魔法都可能学习,需要的只是钱2:凡是在等级1处标注[天赋]的,就是需要在天赋树里加到那个技能才能使用,如果那个技能分很多级,剩下的需要到训练师处购买3:DMP指的是Damage Per Mana,即...
  • 基础知识是后边学习的关键基石,必须扎实,死记硬背是不行的,不能深入理解就不能灵活运用,因此要反复演练,多问为什么这么,深究所以然让你更懂该语言,更了解创作者的初衷和想法。2,基础算法反复推敲,尤其...
  • 1.链地址 #include <stdio.h> #include <stdlib.h> #include <math.h> #define maxSize 100 typedef struct ListNode { int element; struct ListNode* next; }ListNode; typedef ListNode...
  •  之前老师就讲过了选择和冒泡,之后又提到了插入和排序,今天了一个小DEMO,对比了一下四种方法的效率,当然看了很多大牛也博客,其实算法还设计了时间复杂度和空间复杂度,对于这两个概念,我只能从表面...
  • 一个关键字会映射到同一个位桶中的情况,这种情况就就叫做哈希冲突,解决哈希冲突的有三种方案,一种叫做拉链(也叫作链接、链地址,一个意思),另外三种分别为开发地址和再散列。 一、拉链 ...
  • 构造哈希表以及二次探测

    千次阅读 2018-09-16 19:53:39
    构造哈希表(散列表)以及二次探测 今天笔试题时,遇到一道构造哈希表的题,hash函数是 k%11 ,然后一个数组记不清了,然后就是问二次探测进行,问下面那个是正确,懵逼啊,没过,不知道,乱选直接下...
  • 拉链(链地址

    万次阅读 多人点赞 2016-03-24 10:25:53
    当存储结构是链表时,多采用拉链,用拉链处理冲突的办法是:把具有相同散列地址的关键字(同义词)值放在同一个单链表中,称为同义词... 例如,按上面例9.4所给的关键字序列,用拉链构造散列表如图9.14所示。 
  • 头插和尾插建立单链表

    万次阅读 多人点赞 2018-07-24 22:45:37
    在进行单链表的基本运算之前必须先建立单链表,建立单链表的常用方法有两种:头插建表和尾插建表 头插建表,从一个空表开始,读取字符数组a中的字符,生成新节点,将读取的数据存放到新节点的数据域中,然后...
  • 列表及散列冲突解决方案

    千次阅读 2019-06-21 12:42:06
    在我们put了一条key-value数据后,如下图,程序会先将key通过hash(key)这个函数转化成整形,这个整形为数组的下标,插入数据或查找数据。 我们发现,散列表用的是数组支持按照下标随机访问数据的特性(时间...
  • 移动平均又称滑动平均、滑动平均模型 移动平均是用一组最近的实际数据值来预测未来一期或几期内公司产品的需求量、公司产能等的一种常用方法。移动平均适用于即期预测。当产品需求既不快速增长也不快速...
  • 番茄工作法法——Pomotime

    千次阅读 热门讨论 2013-07-21 19:55:40
    我也开始使用番茄这个软件学习工作,因为自己做事注意集中程度不太容易持续太长时间,所以算是别破使用了Pomotime……不得不承认番茄工作对学习效率的提高有不容小觑的作用。  1、概念:  将一个任务划分成几...
  • leetcode双周赛第31场,如何把过的题多前两题的链接。题目三:字符串的好分割数目(题号:5458)python代码题目四:形成目标数组的子数组最少增加次数(题号:5459)暴力python代码分治算法python代码一次遍历   ...
  • 频率采样FIR滤波器设计

    千次阅读 2019-04-14 12:14:57
    频率采样设计FIR滤波器频率采样功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants...
  • 若选定的散列表长度为m,则可将散列表定义为一个由m个头指针组成的指针数组T[0..m-1]。凡是散列地址为i的结点,均插入到以T[i]为头指针的单链表中。T中各分量的初值均应为空指针。在拉链中,装填因子α可以大于 1...
  • 哈希表的开散列(拉链

    千次阅读 2018-03-01 21:56:28
    开散列又叫链地址(开链)。 开散列:首先对关键码集合用散列函数计算散列地址,...设元素的关键码为37, 25, 14, 36, 49, 68, 57, 11, 散列表为HT[12],表的大小为12,散列函数为Hash(x) = x % 11 Hash(37)=...
  • Python基础之:数字字符串和列表

    千次阅读 2021-02-22 19:13:04
    Python的主要应用是进行科学计算,科学计算的基础就是数字,字符串和列表。本文将会详细的给大家介绍一下这三个数据类型的使用情况。
  • 一、哈希表 1、概念 ...这个映射函数就散列函数,存放记录的数组叫做散列表。 2、散列存储的基本思路  以数据中每个元素的关键字K为自变量,通过散列函数H(k)计算出函数值,以该函数值作为一块连
  • 如何研究?

    千次阅读 2006-02-07 11:17:00
    【转贴】麻省理工教授箴言:怎样研究生!麻省理工学院人工智能实验室AI Working Paper 316 1988年10月来自MIT人工智能实验室:如何研究?作者:人工智能实验室全体研究生编辑:David Chapman版本:1.3时间:1988...
  • 一:直接定址 二:数字分析 三:平方取中法 四:折叠 五:除留余数 六:随机数 这些方法原理都是将原来数字按某种规律变成另一个数字 一:直接定址 取关键字的某个线性函数值作为散列地址: ...
  • 用python个九九乘法表-够简单,能学会

    万次阅读 多人点赞 2020-12-17 08:40:00
    输出{行}x{列}={行乘列} print('{}x{}={}\t'.format(j, i, i*j), end='') print() 结果 九九乘法表 前备知识分解 range python range() 函数可创建一个整数列表,一般用在 for 循环中。 函数语法 range(start, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 187,282
精华内容 74,912
关键字:

列表法怎么做