精华内容
下载资源
问答
  • 列表之链接

    千次阅读 2015-06-14 12:38:37
    列表之链接列表的定义 散列表的基本操作 散列表的编码实现 散列表的设计 主测试文件 编译运行 结论注意: 本文中的所有代码你可以在这里 ...或者这里 ...

    注意:
    本文中的所有代码你可以在这里
    https://github.com/qeesung/algorithm/tree/master/chapter11/11-2/hashTable(这里会及时更新)
    或者这里
    http://download.csdn.net/detail/ii1245712564/8804203
    找到

    散列表之链接法

    在之前的文章《散列表之直接寻址表》中介绍了散列表中一种最基本的类型,直接寻址表。直接寻址表是通过键值直接来寻找在在数组里面的映射位置,但是直接寻址表存在一个缺陷,在键值范围较大且元素个数不多的时候,空间利用率不高,比如现在我们只需要映射两个元素(key:1,data1)(key:10000,data2),此时我们需要分配一个大小为10001的数组,将第一个元素放到数组的1位置,第二个元素放到数组的最后一个位置,剩下的所有数组位置都没有被用到,造成空间的浪费。

    于是,针对上面的情况,我们想到了下面的解决方案

    hash(key)={01,key=1,key=10000

    通过散列函数hash,来将key映射到合适的位置上,即通过hash(key)来找到在数组上的位置,最后我们只需要一个大小为2的数组就可以了。

    散列表的定义

    在直接寻址的方式下,具有关键字k的元素被放到数组位置k中。在散列方式下,该元素放在数组的hash(k)位置中,即通过散列函数hash(hash function)传入键值k来计算元素在数组中合适的位置。

    假设我们有一集合U={d1,d2,d3,...dn},集合中过的每一个元素di都有一个键值keyi和一个数组值datai;新建一个数组T=[0...m],遍历一遍集合U,将集合中的每一个元素都放到数组的hash(key)位置上。

    这里的散列表大小m一般要比集合的大小U小的多,可以说是具有关键字k的元素被散列到hash(k),也就是说hash(k)是键值k的散列值。

    Alt text

    散列表的基本操作

    散列表的基本操作有:

    • INSERT:插入一个元素
    • DELETE:删除一个元素
    • SEARCH:搜索一个元素

    在我们进行编码实现之前,先来考虑一下下面几个问题

    问题1:散列函数hash该怎么设计?
    回答1:散列函数的设计关乎到整个散列表的运行效率,所以不可等闲待之,需要针对输入的元素集合来设计合适的散列函数,这也是散列表中最大的难点,比如在之前的例子中,我们设计的散列函数很简单,如果输入的key是1,就返回0,如果输入的key是1000,那么就返回1.如果把这个集合运用到其他集合上,那么就是一个很差劲的散列函数


    问题2:因为集合U的大小|U|远大于散列表的大小m,所以经常会发生不同键值却有相同散列值的情况,于是散列表的同一个位置就会发生冲突,这时应该怎么办?
    回答2:我们可以采用链表的形式,将散列值相同的元素放入同一链表里面,再将列表挂在散列表的对应位置上。
    Alt text

    散列表的编码实现

    下面是用到的文件,我们只列出部分的文件的内容,你可以在这里获得全部内容:
    https://github.com/qeesung/algorithm/tree/master/chapter11/11-2/hashTable

    .
    ├── hash_table.cc 散列表源文件
    ├── hash_table.h 散列表头文件
    ├── hash_table_test.cc 散列表测试源文件
    ├── hash_table_test.h 散列表测试头文件
    ├── link_list.cc 链式链表源文件
    ├── link_list.h 链式链表头文件
    ├── list.h 链表接口文件
    ├── main.cc 主测试文件
    ├── Makefile
    └── README.md
    
    0 directories, 10 files

    散列表的设计

    hash_table.h

    #ifndef  HASHTABLE_INC
    #define  HASHTABLE_INC
    
    #include "link_list.h"
    #include <vector>
    
    /**
     *        Class:  LinkHashTable
     *  Description:  链接法散列表
     */
    template < class T >
    class LinkHashTable
    {
        public:
            /** ====================  LIFECYCLE     ======================================= */
            LinkHashTable (int table_size=0 , int(*_HASH)(const T &)=0);                             /** constructor */
            /** ====================  MUTATORS      ======================================= */
            bool hash_insert(const T &); /*插入操作*/ 
            bool hash_delete(const T &);  /*删除操作*/ 
            std::vector<T> hash_search(int) const; /*查找操作*/ 
            void clear();
            void printToVec(std::vector<std::vector<T> > & );
        private:
            /** ====================  DATA MEMBERS  ======================================= */
            int (*HASH)(const T &);// 定义一个散列函数指针
            LinkList<T> * array; //链表的数组 
            const size_t table_size;// 散列表的大小
    }; /** ----------  end of template class LinkHashTable  ---------- */
    
    #include "hash_table.cc"
    #endif   /* ----- #ifndef HASHTABLE_INC  ----- */

    散列表的成员中有一个散列函数的指针HASH,用户在构造散列表的时候需要制定对应的散列函数,还有一个array指针,是用来指向散列表的起始地址的。

    hash_table.cc

    #include "link_list.h"
    /**
     *       Class:  LinkHashTable
     *      Method:  LinkHashTable
     * Description:  
     */
    template < class T >
    LinkHashTable < T >::LinkHashTable (int _table_size , int(*_HASH)(const T &)) :\
            table_size(_table_size),HASH(_HASH)
    {
        array = new LinkList<T>[table_size]();
    }  /** ----------  end of constructor of template class LinkHashTable  ---------- */
    
    
    template < class T >
    bool LinkHashTable<T>::hash_insert (const T & ele)
    {
        int index = HASH(ele);
        if(index >= table_size || index <0)
            return false;
        return array[index].insert(ele);
    }       /** -----  end of method LinkHashTable<T>::hash_insert  ----- */
    
    
    template < class T >
    bool LinkHashTable<T>::hash_delete (const T & ele)
    {
        int index = HASH(ele);
        if(index >= table_size || index <0)
            return false;
        return array[index].remove(ele);
    }       /** -----  end of method LinkHashTable<T>::hash_delete  ----- */
    
    
    template < class T >
    std::vector<T> LinkHashTable<T>::hash_search (int k) const
    {
        if(k < 0 || k >= table_size)
            return std::vector<T>(); 
        std::vector<int> vec;
        array[k].printToVec(vec);
        return vec;
    }       /** -----  end of method LinkHashTable<T>::hash_search  ----- */
    
    
    
    template < class T >
    void LinkHashTable<T>::clear ()
    {
        for(int i =0 ; i < table_size ; ++i)
        {
            array[i].clear();
        }
        return ;
    }       /** -----  end of method LinkHashTable<T>::clear  ----- */
    
    
    template < class T >
    void LinkHashTable<T>::printToVec (std::vector<std::vector<T> > & vec)
    {
        for(int i =0 ; i < table_size ; ++i)
        {
            std::vector<int> tempVec;
            array[i].printToVec(tempVec);
            vec.push_back(tempVec);
        }
        return ;
    }       /** -----  end of method LinkHashTable<T>::printToVec  ----- */

    主测试文件

    main.cc

    #include <stdlib.h>
    #include "hash_table_test.h"
    #include <cppunit/ui/text/TestRunner.h>
    #include <cppunit/TestCaller.h>
    #include <cppunit/TestSuite.h>
    
    
    
    /** 
     * +++  FUNCTION  +++
     *         Name:  main
     *  Description:  测试的主函数
     */
    int main ( int argc, char *argv[] )
    {
        CppUnit::TextUi::TestRunner runner; 
        CppUnit::TestSuite * suite = new CppUnit::TestSuite();
    
        suite->addTest(new CppUnit::TestCaller<HashTableTest>("Test insert by qeesung", &HashTableTest::test_insert));
        suite->addTest(new CppUnit::TestCaller<HashTableTest>("Test delete by qeesung", &HashTableTest::test_delete));
        suite->addTest(new CppUnit::TestCaller<HashTableTest>("Test search by qeesung", &HashTableTest::test_search));
        runner.addTest(suite);
        runner.run("",true);
        return EXIT_SUCCESS;
    
        return EXIT_SUCCESS;
    }               /** ----------  end of function main  ---------- */

    编译运行

    编译方法

    • 如果你安装了cppunit
    make
    • 如果没有安装cppunit,你需要这样编译
    g++ hash_table_test.cc youSourceFile.cc -o target

    运行方法

    ./hashTest(or your target)

    结论

    散列表最重要的是设计一个性能良好的散列函数(hash function),这也是散列表的难点,如果散列函数设计差劲的话,有可能造成数据分布的不平衡,删除和查找操作性能变差。我们考虑最差劲的散列函数,就是将所有的键值都映射为同一个散列值,那么对散列表的查找和删除操作的运行时间将和操作一个链式链表一样,都为O(n)。我们将在后面的文章中详细讲解散列函数的设计,敬请关注(づ ̄3 ̄)づ╭❤~

    展开全文
  • 表格/列表法之分部积分

    千次阅读 2020-05-28 18:13:32
    在求积分的过程中,我们经常使用微积分里的分布积分,但对于一些复杂的函数,需要运用多次分布积分,比如你可能见过这样的, 处理起来很是头疼,然而用表格就能起到这样的效果 下面说明一下如何使用这种方法 ...

    在求积分的过程中,我们经常使用微积分里的分布积分法,但对于一些复杂的函数,需要运用多次分布积分,比如你可能见过这样的,
    在这里插入图片描述
    处理起来很是头疼,然而用表格法就能起到这样的效果
    在这里插入图片描述
    在这里插入图片描述
    下面说明一下如何使用这种方法
    对积分vudx\int vu\,dx
    列成表格
    在这里插入图片描述
    第一行表示求导,第二行求原函数
    表中内容可分为三部分,连线的地方将他们相乘
    图中红色地方表示正
    比如vudx,vudxv\int u\,dx,v''\int\int\int u\,dx
    图中黑色地方表示负
    比如vudx-v'\int\int u\,dx
    绿色地方表示
    (1)n(vn()nu)dx(-1)^n\int (v^n(\int)^nu)dx 注意:这里的n表示求导或积分的总次数
    最后把这三部分加起来即可,不理解的话请看下面这个例子


    Cn=2l0lx(lx)sinnπxldxCn =\frac{2}{l}\int_0^l x(l-x)sin\frac{nπx}{l}dx
    正常计算:
    在这里插入图片描述
    表格法:

    x(lx)x(l-x) l2xl-2x 2-2
    2lsinnπxl\frac2lsin\frac{nπx}{l} 2nπcosnπxl-\frac{2}{nπ}cos\frac{nπx}{l} 2ln2π2sinnπxl-\frac{2l}{n^2π^2}sin\frac{nπx}{l}

    Cn=[x(lx)(2nπcosnπxl)(l2x)(2ln2π2sinnπxl)]l0+Cn=\left[x(l-x)(-\frac{2}{nπ}cos\frac{nπx}{l})\right.\\-(l-2x)(-\frac{2l}{n^2π^2}sin\frac{nπx}{l})]\begin{vmatrix} l \\ 0\end{vmatrix}+(1)20l(2)2ln2π2sinnπxldx (-1)^2\int_0^l(-2) \frac{-2l}{n^2π^2}sin\frac{nπx}{l}dx
    =04l2n3π3cosnπxll0=0-\frac{4l^2}{n^3π^3}cos\frac{nπx}{l}\begin{vmatrix} l \\ 0\end{vmatrix}
    =4l2n3π3(1cosnπ)=\frac{4l^2}{n^3π^3}(1-cosnπ)

    如果还不太懂可以看一下文章开头的那个例子,自己算一下

    运用表格法只需进行对被积函数进行求导积分运算,一步得结果,大大减少了出错率。

    在这里插入图片描述

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

    千次阅读 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  ----- */

    总结

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

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

    展开全文
  • 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

    展开全文
  • 列表-拉链

    千次阅读 2014-09-30 11:48:29
    若选定的散列表长度为m,则可将散列表定义为一个由m个头指针组成的指针数组T[0..m-1]。凡是散列地址为i的结点,均插入到以T[i]为头指针的单链表中。T中各分量的初值均应为空指针。在拉链中,装填因子α可以大于1,...
  • 列表(上)——开放定址

    万次阅读 2017-09-20 19:23:15
    概述散列表,又称哈希表,hash表。散列表是一种特殊的数据结构,它同数组、链表以及二叉排序树等相比较有很明显的区别,它能够快速定位到想要查找的记录,而不是与表中存在的记录的关键字进行比较来进行查找。这个...
  • 列表相关题目(线性探测再散列

    千次阅读 多人点赞 2020-12-02 02:05:00
    列表相关题目(线性探测再散列) 一、题目 将关键字序列(7、8、30、11、18、9、14)散列存储到散列表中。散列表的存储空间是一个下标从0开始的一维数组,散列函数为H(key)=(key×3) mod 7,处理冲突采用线性...
  • 在Java 9+版本中,接口的内容可以有: 1.成员变童其实是常童,格式: [public] [static] [final] 数据类型 常置名称 = 数据值...[public] [abstract] 返回值类型 方法名称(参数列表〉; 注意:实现类必须覆盖重写...
  • R语言注意事项列表

    千次阅读 2014-10-15 17:30:04
    在使用R语言的过程中,会村
  • 【人事】电话面试时需要注意什么

    万次阅读 2018-05-12 18:44:51
    电话面试时需要注意的地方,主要是一些细节上的注意事项。 1、电话突然打来怎么办 企业突然来电,往往令你措手不及,也许你正在上课,也许正在运动,也许正在公车上,此时没有任何准备,建议你首先试探看看对方...
  • 数字电路基础知识——数字逻辑代数(逻辑代数公式、卡洛图的运用、Q-M法化简(列表法)) 本节主要介绍逻辑代数的公式、及逻辑函数的化简、包括公式法化简、卡洛图化简、Q-M列表法化简。 一、逻辑代数的三个基本运算 ...
  • https://github.com/996icu/996.ICU/blob/master/blacklist/README.md#名单列表 “996”工作制,即每天早 9 点到岗,一直工作到晚上 9 点,每周工作 6 天。 “996”工作制的周工作时间为最低 12x6=72 小时。 中国...
  • 列表--线性探测

    千次阅读 2014-10-13 15:36:49
    下面对散列表的构造方式加以说明,注意表1中的关键字7和14,30和9, 11和18,这三组关键子的H(Key)值相同,这在构建散列表时就会产生冲突,因为他们的地址相同,所以要通过一定的冲突处理方法来解决这个问题。...
  • Web测试需要注意的点

    万次阅读 多人点赞 2019-04-16 16:35:24
    测试用例是测试的核心,测试用例的设计是一种思维方式的体现,在用例的设计中,用的比较多的方法是边界值分析和等价类划分,下面主要从输入框,搜索功能,添加、修改功能,删除功能,注册、登录功能以及上传图片...
  • 列表(Hash table,也叫哈希表),是根据关键字(Key value)而直接访问在内存存储位置的数据结构。也就是说,它通过把键值通过一个函数的计算,映射到表中一个位置来访问记录,这加快了查找速度。这个映射函数...
  • WOW法师技能全列表(旧)

    万次阅读 2007-09-20 09:17:00
    Mage全技能表注解:1:所有魔法都可能学习,需要的只是钱2:凡是在等级1处标注[天赋]的,就是需要在天赋树里加到那个技能才能使用,如果那个技能分很多级,剩下的需要到训练师处购买3:DMP指的是Damage Per Mana,即...
  • 什么是番茄工作

    千次阅读 多人点赞 2021-02-14 22:58:03
    1什么是番茄工作 2番茄工作的基本原则 3番茄工作的目的 4番茄工作的做法 5番茄工作的五个基本流程 6番茄工作的经验技巧 7番茄工作案例[1] 什么是番茄工作 番茄工作是简单易行的时间管理...
  • 注意力机制最新综述解读

    万次阅读 多人点赞 2019-04-16 18:02:24
    注意力模型(Attention Model,AM)已经成为神经网络中的一个重要概念,并在不同的应用领域进行了充分的研究。这项调查提供了一个结构化和全面的概述关于attention的发展。我们回顾了注意力机制被纳入的不同的神经网络...
  • 给定一系列整型关键字和素数P,用除留余数定义的散列函数将关键字映射到长度为P的散列表中。用线性探测解决冲突。 输入格式: 输入第一行首先给出两个正整数N(≤1000)和P(≥N的最小素数),分别为待插入的...
  • 列表之散列函数

    千次阅读 2015-06-26 13:38:20
    全域散列列表之散列函数我们在之前的文章《散列表之链接》中已经提到过,散列函数是散列表的一个难点,一个好的散列可以很大程度上提升散列表的查找和删除操作的速度,而一个设计差劲的散列表的,查找和删除...
  • 又称帕累托分析或巴雷托分析、柏拉图分析、主次因分析 、ABC分析、分类管理、物资重点管理、ABC管理、abc管理、巴雷特分析,平常我们也称之为“80对20”规则,EMBA、MBA等主流商管教育均对ABC分类...
  • Android切图注意事项

    千次阅读 2014-07-22 11:24:26
    Android切图注意事项 1. 切图需要两套分辨率的图:480*800,720*1280。分被放在不同的文件夹中,同一张图片,在两个文件夹中的名字要一致。 2. 如遇到可拉伸可平铺的图片,使用9Patch进行制作,产生xxx.9.png图片...
  • 散列(2)线性探测和双重散列

    万次阅读 2015-04-22 17:08:16
    我们依靠空的存储空间解决冲突:设计表长M大于元素数目N,开放地址,最简单的开放地址是线性探测:初始化该符号表的实现将元素保存到大小是元素个数两倍的散列表中。void HashTableInit(in
  • Python基础之:数字字符串和列表

    千次阅读 2021-02-22 19:13:04
    Python的主要应用是进行科学计算,科学计算的基础就是数字,字符串和列表。本文将会详细的给大家介绍一下这三个数据类型的使用情况。
  • 散列(hash、关键字地址计算)

    千次阅读 2016-08-06 14:04:19
    散列,又称为hash或者关键字地址计算。时间复杂度为0(理想情况下),是一种key-value的存储方法。核心就是由hash函数决定关键字值和散列地址之间的关系,通过这种关系来组织存储并进行查找等操作。散列面临的...
  • c语言:折半查找(二分查找

    千次阅读 2019-07-25 17:53:56
    折半查找(half-interval search) ...注意:折半查找仅适用于对已有顺序的数组、数据进行操作!!! 例如:要在数组arr[]={8,7,9,6,4,1,2,5,3,10,11};中查找key=7的位置;首先,我们要先将数组arr中...
  • 回溯与分支限界

    万次阅读 2016-11-30 19:25:02
    回溯解题的一个显著特征是在搜索过程中动态产生问题的解空间。在任何时刻,算法只保存从根结点到当前扩展结点的路径。
  • 移动平均又称滑动平均、滑动平均模型 移动平均是用一组最近的实际数据值来预测未来一期或几期内公司产品的需求量、公司产能等的一种常用方法。移动平均适用于即期预测。当产品需求既不快速增长也不快速...
  • 目录: 一:直接定址 二:数字分析 三:平方取中法 四:折叠 五:除留余数 ...六:随机数 ...但问题是这需要事先知道关键字的分布情况 适合查找表较小且连续的情况 由于这样的限制,在现...
  • 跟客户谈需求时,应注意什么

    千次阅读 2016-09-14 18:04:04
    在做项目时,经常会碰到这样的事情.... 客户向我们反映在和你们的工程师谈论需求时,他们总是满口答应没问题。...而开发人员也在诉苦:用户什么都不懂,而且他们的需求老是变动,时间又这么紧,你让我们怎么办

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 181,475
精华内容 72,590
关键字:

列表法需要注意什么