精华内容
下载资源
问答
  • 分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!... /* * 把二元查找树转变成排序的...在遍历的过程中,更改它的逻辑结构。 */ #include <iostream> ...

    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net 

    /*
     * 把二元查找树转变成排序的双向链表 - by Chimomo
     *
     * 【思路】按照二叉树的中序遍历正好是按从小到大地顺序遍历全部节点。在遍历的过程中,更改它的逻辑结构。
     */
    
    #include <iostream>
    
    using namespace std;
    
    /**
     * The binary search tree node.
     */
    struct BSTreeNode {
        int m_nValue; // The value of node.
        BSTreeNode *m_pLeft; // The left child of node.
        BSTreeNode *m_pRight; // The right child of node.
    };
    
    typedef BSTreeNode DoublyLinkedList;
    DoublyLinkedList *pHead = nullptr;
    DoublyLinkedList *pDoublyLinkedList = nullptr;
    
    /**
     * Construct binary search tree recursively.
     * @param pCurrent The current pointer. Use & here since pCurrent will be changed in the function body.
     * @param value The value.
     */
    void ConstructBSTree(BSTreeNode *&pCurrent, int value) {
        if (pCurrent == nullptr) {
            auto pTree = new BSTreeNode();
            pTree->m_pLeft = nullptr;
            pTree->m_pRight = nullptr;
            pTree->m_nValue = value;
            pCurrent = pTree;
        } else {
            if (value > pCurrent->m_nValue) {
                ConstructBSTree(pCurrent->m_pRight, value);
            } else if (value < pCurrent->m_nValue) {
                ConstructBSTree(pCurrent->m_pLeft, value);
            } else {
                cout << "Invalid input, there already have the value!" << endl;
            }
        }
    }
    
    /**
     * Convert binary search tree node to doubly linked list node.
     * @param pCurrent The current pointer.
     */
    void ConvertBSTreeNodeToDoublyLinkedListNode(BSTreeNode *pCurrent) {
        pCurrent->m_pLeft = pDoublyLinkedList;
    
        if (pDoublyLinkedList == nullptr) {
            pHead = pCurrent;
        } else {
            pDoublyLinkedList->m_pRight = pCurrent;
        }
    
        pDoublyLinkedList = pCurrent;
    }
    
    /**
     * Traverse binary search tree (in-order) to convert binary tree to doubly linked list.
     * @param pCurrent The current pointer.
     */
    void TraverseBSTreeInOrder(BSTreeNode *pCurrent) {
        if (pCurrent == nullptr) {
            return;
        } else {
            if (pCurrent->m_pLeft != nullptr) {
                TraverseBSTreeInOrder(pCurrent->m_pLeft);
            }
    
            ConvertBSTreeNodeToDoublyLinkedListNode(pCurrent);
    
            if (pCurrent->m_pRight != nullptr) {
                TraverseBSTreeInOrder(pCurrent->m_pRight);
            }
        }
    }
    
    /**
     * Test program.
     * @param argc The argument count.
     * @param argv The argument array.
     * @return The int.
     */
    int main(int argc, char *argv[]) {
        int value;
        BSTreeNode *pBSTree = nullptr;
        cout << "Please input integers, -1 to end:";
        cin >> value;
    
        while (-1 != value) {
            ConstructBSTree(pBSTree, value);
            cin >> value;
        }
    
        TraverseBSTreeInOrder(pBSTree);
    
        cout << "Print BST:";
        while (pHead) {
            cout << pHead->m_nValue << ' ';
            pHead = pHead->m_pRight;
        }
    
        return 0;
    }
    
    // Output:
    /*
    Please input integers, -1 to end:6 7 8 5 1 3 9 2 4 0 10 -1
    6 7 8 5 1 3 9 2 4 0 10 -1
    Print BST:0 1 2 3 4 5 6 7 8 9 10
    */

     

    展开全文
  • 数据结构 查找表.ppt

    2020-07-19 18:29:21
    第6章查找表 6.1基本概念 查找表是一种以集合为逻辑结构以查找 为...记 为 在数据结构课程中,通常只考虑那些由具 有相同类型的数据元素构成的集合 6.1.2查找表的基本概念 査找是一种常用运算,其功能是从大 量的数据元素
  • Altera CycloneII 系列...查找表(Look-Up-Table)简称为LUT,LUT本质上就是一个RAM。目前FPGA中多使用4输入LUT,所以每一个LUT可以看成一个有4位地址线16x1RAM。当用户通过原理图或HDL语言描述了一个逻辑电...

    转自:http://blog.sina.com.cn/s/blog_6f36f4fb0100n3na.html

    Altera CycloneII 系列的FPGA是基于LUT结构的。查找表(Look-Up-Table)简称为LUT,LUT本质上就是一个RAM。目前FPGA中多使用4输入的LUT,所以每一个LUT可以看成一个有4位地址线的16x1的RAM。当用户通过原理图或HDL语言描述了一个逻辑电路以后,PLD/FPGA开发软件会自动计算逻辑电路的所有可能的结果,并把结果事先写入RAM,这样,每输入一个信号进行逻辑运算就等于输入一个地址进行查表,找出地址对应的内容,然后输出即可。
    下面是一个4输入与门的例子:

     

    我们知道,一个n输入的逻辑运算,不管是与或非运算还是异或运算等等,最多只可能存在2的n次方种结果,上图的4输入,共有16中输出结果。这样就将实际逻辑电路转换成了LUT结构。

    xilinx公司FPGA结构:CLB是FPGA内的基本逻辑单元,在xilinx FPGA中,一个CLB模块由多个(一般为4个)相同的Slice和附加逻辑构成。一个Slice由两个4/6输入的LUT、进位逻辑、算术逻辑、存储逻辑、和函数复用器组成。

    转载于:https://www.cnblogs.com/lbf-19940424/p/6564885.html

    展开全文
  • 查找表的原理与结构: 查找表(look-up-table)简称为LUT,LUT本质上就是一个RAM。目前FPGA中多使用4输入的LUT,所以每一个LUT可以看成一个有 4位地址线的16x1的RAM。当用户通过原理图或HDL语言描述了一个逻辑电路...

    查找表的原理与结构:
          查找表(look-up-table)简称为LUT,LUT本质上就是一个RAM。目前FPGA中多使用4输入的LUT,所以每一个LUT可以看成一个有 4位地址线的16x1的RAM。当用户通过原理图或HDL语言描述了一个逻辑电路以后,PLD/FPGA开发软件会自动计算逻辑电路的所有可能的结果,并把结果事先写入RAM,这样,每输入一个信号进行逻辑运算就等于输入一个地址进行查表,找出地址对应的内容,然后输出即可。
    什么是竞争与冒险现象:
                在组合电路中,某一输入变量经过不同途径传输后,到达电路中某一汇合点的时间有先有后,这种现象称竞争;由于竞争而使电路输出发生瞬时错误的现象叫做冒险。(也就是由于竞争产生的毛刺叫做冒险)
    判断方法:
    代数法(如果布尔式中有相反的信号则可能产生
    竞争和冒险现象);
    卡诺图:有两个相切的卡诺圈并且相切处没有被其他卡诺圈包围,就有
    可能出现竞争冒险;
    实验法:示波器观测;
    解决方法:
    1:加滤波电路,消除毛刺的影响;
    2:加选通信号,避开毛刺;
    3:增加冗余项消除逻辑冒险。 

    展开全文
  • 我认为,数据结构是一门学科,它教会我们“如何存储具有复杂关系数据更有助于后期对数据再利用”。 数据结构存储结构: 线性表,还可细分为顺序、链表、栈和队列; 树结构,包括普通树,二叉树,线索...

    目录

     

    数据结构基础知识概念

    数据结构的逻辑结构:

    线性表

    顺序表

    链表

    栈和队列

    栈的链式存储:

    队列的链式存储:

    树存储结构

    图存储结构

    一、数据结构基本概念

    1、数据结构的基本概念

    2、算法的基本概念

    二、线性表

    三、栈和队列

    四、树、二叉树

    五、图

    六、查找

    七、排序


     


     

    数据结构基础知识概念

     我认为,数据结构是一门学科,它教会我们“如何存储具有复杂关系的数据更有助于后期对数据的再利用”。

    数据结构就是研究数据的逻辑结构物理结构以及它们之间相互关系,并对这种结构定义相应的运算,而且确保经过这些运算后所得到的新结构仍然是原来的结构类型。

    1. 数据:所有能被输入到计算机中,且能被计算机处理的符号的集合。是计算机操作的对象的总称。
    2. 数据元素:数据(集合)中的一个“个体”,数据及结构中讨论的基本单位
    3. 数据项:数据的不可分割的最小单位。一个数据元素可由若干个数据项组成。
    4. 数据类型:在一种程序设计语言中,变量所具有的数据种类。整型、浮点型、字符型等等

    5. 逻辑结构:数据之间的相互关系。

      • 集合 结构中的数据元素除了同属于一种类型外,别无其它关系。
      • 线性结构 数据元素之间一对一的关系
      • 树形结构 数据元素之间一对多的关系
      • 图状结构或网状结构 结构中的数据元素之间存在多对多的关系
    6. 物理结构/存储结构:数据在计算机中的表示。物理结构是描述数据具体在内存中的存储(如:顺序结构、链式结构、索引结构、哈希结构)等
    7. 在数据结构中,从逻辑上可以将其分为线性结构和非线性结构
    8. 数据结构的基本操作的设置的最重要的准则是,实现应用程序与存储结构的独立。实现应用程序是“逻辑结构”,存储的是“物理结构”。逻辑结构主要是对该结构操作的设定,物理结构是描述数据具体在内存中的存储(如:顺序结构、链式结构、索引结构、希哈结构)等。
    9. 顺序存储结构中,线性表的逻辑顺序和物理顺序总是一致的。但在链式存储结构中,线性表的逻辑顺序和物理顺序一般是不同的。

    10. 算法五个特性: 有穷性、确定性、可行性、输入、输出

    11. 算法设计要求:正确性、可读性、健壮性、高效率与低存储量需求。(好的算法)
    12. 算法的描述有伪程序、流程图、N-S结构图等。E-R图是实体联系模型,不是程序的描述方式。
    13. 设计算法在执行时间时需要考虑:算法选用的规模、问题的规模
    14. 时间复杂度:算法的执行时间与原操作执行次数之和成正比。时间复杂度有小到大:O(1)、O(logn)、O(n)、O(nlogn)、O(n2)、O(n3)。幂次时间复杂度有小到大O(2n)、O(n!)、O(nn)
    15. 空间复杂度:若输入数据所占空间只取决于问题本身,和算法无关,则只需要分析除输入和程序之外的辅助变量所占额外空间

     

    数据结构的逻辑结构:

     

    线性表

    线性表结构存储的数据往往是可以依次排列的,就像小朋友手拉手,每位学生的前面和后面都仅有一个小朋友和他拉手,具备这种“一对一”关系的数据就可以使用线性表来存储。
    例如,存储类似 {1,3,5,7,9} 这样的数据时,各元素依次排列,每个元素的前面和后边有且仅有一个元素与之相邻(除首元素和尾元素),因此可以使用线性表存储。

    线性表并不是一种具体的存储结构,它包含顺序存储结构链式存储结构是顺序表和链表的统称。

    顺序表

    顺序表,简单地理解,就是常用的数组,只是换了个名字而已,例如使用顺序表存储 {1,3,5,7,9},如图 1 所示:


    顺序表结构
    图 1 顺序表结构

    由于顺序表结构的底层实现借助的就是数组,因此对于初学者来说,可以把顺序表完全等价为数组,但实则不是这样。数据结构是研究数据存储方式的一门学科,它囊括的都是各种存储结构,而数组只是各种编程语言中的基本数据类型,并不属于数据结构的范畴。

    链表

    我们知道,使用顺序表(底层实现靠数组)时,需要提前申请一定大小的存储空间,这块存储空间的物理地址是连续的

    链表则完全不同,使用链表存储数据时,是随用随申请,因此数据的存储位置是相互分离的,换句话说,数据的存储位置是随机的。

    为了给各个数据块建立“依次排列”的关系,链表给各数据块增设一个指针,每个数据块的指针都指向下一个数据块(最后一个数据块的指针指向 NULL),就如同一个个小学生都伸手去拉住下一个小学生的手,这样,看似毫无关系的数据块就建立了“依次排列”的关系,也就形成了链表,如图 2 所示:


    链表结构
    图 2 链表结构

    栈和队列

    栈和队列隶属于线性表,是特殊的线性表,因为它们对线性表中元素的进出做了明确的要求。

    栈中的元素只能从线性表的一端进出(另一端封死),且要遵循“先入后出”的原则,即先进栈的元素后出栈。
     

    栈结构示意图
    图 3 栈结构示意图


    栈结构如图 3 所示,像一个木桶,栈中含有 3 个元素,分别是 A、B 和 C,从在栈中的状态可以看出 A 最先进的栈,然后 B 进栈,最后 C 进栈。根据“先进后出”的原则,3 个元素出栈的顺序应该是:C 最先出栈,然后 B 出栈,最后才是 A 出栈。

    队列中的元素只能从线性表的一端进,从另一端出,且要遵循“先入先出”的特点,即先进队列的元素也要先出队列。


    队列结构示意图
    图 4 队列结构示意图
     

    队列结构如图 4 所示,队列中有 3 个元素,分别是 A、B 和 C,从在队列中的状态可以看出是 A 先进队列,然后 B 进,最后 C 进。根据“先进先出”的原则,3 个元素出队列的顺序应该是 A 最先出队列,然后 B 出,最后 C 出。

    栈的链式存储:

    top=top->next;

    队列的链式存储:

    头出尾进;

     

    树存储结构

    树存储结构适合存储具有“一对多”关系的数据。


    树存储结构示意图
    图 5 树存储结构示意图


    如图 5 所示,其中张平只有一个父亲,但他却有两(多)个孩子,这就是“一对多”的关系,满足这种关系的数据可以使用树存储结构。

    图存储结构

    图存储结构适合存储具有“多对多”关系的数据。


    图存储结构示意图
    图 6 图存储结构示意图
     

    如图 6 所示,从 V1 可以到达 V2、V3、V4,同样,从 V2、V3、V4 也可以到达 V1,这就是“多对多”的关系,满足这种关系的数据可以使用图存储结构。

     

     

    一、数据结构基本概念

    1、数据结构的基本概念

    数据:是信息的载体,是描述客观事物属性的数、字符以及所有能输入到计算机中并被计算机程序识别和处理的符号的集合。
    结构:数据元素相互之间的关系叫做“结构”
    数据结构:相互之间存在一种或多种特定关系的数据元素的集合。
    数据结构包括三方面内容:逻辑结构、存储结构、数据的运算。

    2、算法的基本概念

    算法:特定问题求解步骤的一种描
    特性:有穷性、确定性、可行性、输入、输
    算法效率的度量:
    1、时间复杂度:最深层循环内的语句的频率。
    常见的时间复杂度:

    O(1)<O(log2n)<O(n)<O(nlog2n)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n)
    

    2、空间复杂度:S(n),算法所耗费的存储空间

    二、线性表

    线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列。
    顺序表由数组下标、数据元素组成。
    顺序表不一定是数据按照大小排序的线性表。

    线性表的链式表示
    1、单链表 单链表的查找、插入、删除操作
    2、双链表 双链表的插入、删除操作
    3、循环链表

    三、栈和队列

    栈的定义:只允许在一端进行插入、删除操作的线性表
    特点:先进后出

    队列的定义:只允许在表的一端进行插入,在表的另一端进行删除。
    特点:先进先出

    四、树、二叉树

    1、二叉树的遍历
    前序遍历、中序遍历、后序遍历

    五、图

    日常工作对图的应用不是很多,是我平时接触的情景太low了吗?

    六、查找

    1、顺序查找:从线性表的一端开始,逐个检查关键字是否满足条件。找到则返回成功,没找到,则返回失败。

    int orderSearch(int searchKey, int[] array) {
            if (array == null || array.length < 1) {
                return -1;
            }
            
            for (int i = 0; i < array.length; i++) {
                if (searchKey == array[i]) {
                    return array[i];
                }
            }
            
            return -1;
        }
    

    2、二分查找

    int binarySearch(int searchKey, int[] array) {
            int low = 0;
            int high = array.length -1;
            while(low <= high) {
                int middle = (low + high) / 2;
                if (searchKey > array[middle]) {
                    low = middle + 1;
                } else if (searchKey < array[middle]) {
                    high = middle - 1;
                } else {
                    return middle;
                }
            }
            
            return -1;
        }
    

    3、分块查找

    /**
         * 分块查找
         * 
         * @param index  索引表,存放各块的最大值
         * @param st     顺序表
         * @param key    查找关键字
         * @param m      顺序表中各块长度相等
         * @return
         */
        int blockSearch(int[] index, int[] st, int key, int m) {
            int i = binarySearch(key, index);
            
            if (i >= 0) {
                int j = i > 0 ? i * m : i;
                int len = (i + 1) * m;
                
                // 在确定的块中用顺序查找方法查找key
                for (int k = j; k < len; k++) {
                    if (key == st[k]) {
                        return k;
                    }
                }
            }
            
            return -1;
        }
    

    4、散列表
    之前的查找都是基于比较进行查找,Hash表是通过哈希函数直接求出结点的地址,是关键字到地址的直接转换方法
    (1)哈希函数:一个把查找表中的关键字映射为该关键字对应的地址的函数
    (2)散列表:根据
    关键字而直接进行访问的数据结构

    处理冲突的方法:
    (1)开放定址法:如果两个数据元素的哈希值相同,则在哈希表中为后插入的数据元素另外选择一个表项。当程序查找哈希表时,如果没有在第一个对应的哈希表项中找到符合查找要求的数据元素,程序就会继续往后查找,直到找到一个符合查找要求的数据元素,或者遇到一个空的表项。  还有在散列;
    (2)拉链法:将哈希值相同的数据元素存放在一个链表中,在查找哈希表的过程中,当查找到这个链表时,必须采用线性查找方法。

    /**
         * Hash查找
         * 
         * @param hash
         * @param hashLength
         * @param key
         * @return
         */
        int searchHash(int[] hash, int hashLength, int key){
            int hashAddress = key % hashLength;  // 除留余数法
            
            // 指定的hashAddress对应值存在但不是关键值,则用开放寻址法继续定位
            while (hash[hashAddress] != 0 && hash[hashAddress] != key) {
                hashAddress = (++hashAddress) % hashLength;
            }
            
            // 查找到了开放单元,表示查找失败
            if (hash[hashAddress] == 0) {
                return -1;
            }
            
            return hashAddress;
        }
    

    七、排序

    1、排序的概念:重新排列表中的元素,使表中的元素满足按照关键字递增或递减的过程。
    2、插入排序:直接插入排序、折半插入排序、希尔排序
    直接插入排序:将元素从无序子序列取出,插入有序序列子序列中。

     

    private static void insertSort(int[] array) {
            int n = array.length;
            int i,j;
            for (i = 1; i < n; i++) { // 无序列表的第一位比较数据就是index = 1的数据
                int temp = array[i]; // 本次循环,待插入有序列表的数
                
                // 以下遍历有序表,从后往前查找待插入位置
                // 无序列表取出的temp小于前驱,则无序列表所有元素向后移一位
                for (j = i- 1; j >= 0 && temp < array[j]; j--) { 
                    array[j + 1] = array[j];
                }
                
                array[j + 1] = temp; // 插入元素
            }
            
            // 打印结果
            System.out.print("排序结果:");
            for (int k = 0; k < array.length; k++) {
                System.out.print(" " + array[k]);
            }
        }
    

    折半插入法:在遍历有序表查找待插入元素位置时使用二分查找法进行插入位置的确定,其余思路和直接插入法保持一致。

     

    private static void midInsertsort(int[] array) {
            int n = array.length;
            int i, j, low, high, mid;
            for (i = 1; i < n; i++) {
                int temp = array[i];
    
                // 以下为二分法在有序表中查找插入位置
                low = 1;
                high = i - 1;
                while (low <= high) {
                    mid = (low + high) / 2;
                    if (temp > array[mid]) { // 说明temp的位置在左半部分
                        low = mid + 1;
                    } else { // 说明temp的位置在有半部分
                        high = mid - 1;
                    }
                }
    
                // 有序表的元素向后移一位
                for (j = i - 1; j >= 0 && temp < array[j]; j--) {
                    array[j + 1] = array[j];
                }
    
                array[j + 1] = temp; // 插入元素
    
            }
    
            // 打印结果
            System.out.print("排序结果:");
            for (int k = 0; k < array.length; k++) {
                System.out.print(" " + array[k]);
            }
        }
    

    希尔排序:将整个无序序列分割成若干个子序列(由相隔某个“增量”的元素组成的)分别进行直接插入排序,然后依次缩减增量再进行排序,待整个序列中的元素基本有序时,再对全体元素进行一次直接插入排序。
    https://www.cnblogs.com/snowcan/p/6244391.html

    2、交换排序:冒泡排序、快速排序
    冒泡排序:对未排序范围内的相邻两个数进行比较,若后者比前者小,则互换位置,否则进入下一位继续比较(默认按照升序排列)

     

    private static void bubbleSort(int[] array) {
            int n = array.length;
            boolean exchange;
            
            for (int i = 0; i < n; i++) {
                exchange = false;
                for (int j = 0; j < n - (i + 1); j++) {  // 这里只对未排序部分进行遍历比较
                    if (array[j] > array[j + 1]) {
                        exchange = true;
                        int temp = array[j + 1];
                        array[j + 1] = array[j];
                        array[j] = temp;
                    }
                }
                
                if(!exchange) // 无序互换,跳出循环,进行下一次比较
                    break;
            }
            
            // 打印结果
            System.out.print("排序结果:");
            for (int k = 0; k < array.length; k++) {
                System.out.print(" " + array[k]);
            }
        }
    

    快速排序:通过一趟排序将要排序的数据分割成独立的两部分,使其中一部分比另一部分所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
    算法过程:
    1.设置 low=0, high=N-1。
    2.选择一个基准元素赋值给temp,即temp=a[low]。
    3.从high开始向前搜索,即由后开始向前搜索(high--),找到第一个小于temp的值,将a[high]和a[low]交换。
    4.从low开始向前后搜索,即由前开始向后搜索(low++),找到第一个大于temp的值,将a[high]和a[low]交换。
    5.重复第3步和第4步,直到 low==high ,3,4步中,若没找到符合条件的值,执行 high-- 或 low++ ,直到找到为止。进行交换时 low和high的位置不变。当low==high时循环结束。

     

    private static void quickSort(int[] array, int low, int high) {
            if (low < high) {
                /**
                 * 将数组一分为二
                 */
                int middle = getMiddle(array, low, high);
                
                /**
                 * 将小于基准元素的数据进行递归排序
                 */
                quickSort(array, low, middle - 1);
                
                /**
                 * 将大于基准元素的数据进行递归排序
                 */
                quickSort(array, middle + 1, high);
            }
        }
        
        private static int getMiddle(int[] array, int low, int high) {
            int temp = array[low]; // 数组第一个元素为基准元素
            while (low < high) {
                while (low < high && array[high] > temp) {
                    high--;
                }
                
                /**
                 * 比基准小的数据移到低端
                 */
                array[low] = array[high];  
            
                while (low < high && array[low] < temp) {
                    low++;
                }
                 /**
                 * 比基准大的记录移到高端
                 */
                array[high] = array[low];
            }
            
            /**
             * 此时 low == high
             */
            array[low] = temp;              
            return low;    
        }
    

    3、选择排序:简单选择排序、堆排序
    简单选择排序:在待排序数据中,选出最小的一个数与第一个位置的数交换;然后在剩下的数中选出最小的数与第二个数交换;依次类推,直至循环到只剩下两个数进行比较为止。
    0.初始状态 3,1,5,7,2,4,9,6(共8个数)

    1.n=8 个数中,最小数值为1,与第一个数交换:1,3,5,7,2,4,9,6

    2.剩下 n-1=7 个数中,最小数值为2,与第二个数交换:1,2,5,7,3,4,9,6

    3.剩下 n-2=6 个数中,最小数值为3,与第三个数交换:1,2,3,7,5,4,9,6

    4.剩下 n-3=5 个数中,最小数值为4,与第四个数交换:1,2,3,4,5,7,9,6

    5.剩下 n-4=4 个数中,最小数值为5,与第五个数交换:1,2,3,4,5,7,9,6

    6.剩下 n-5=3 个数中,最小数值为6,与第五个数交换:1,2,3,4,5,6,9,7

    7.剩下 n-6=2 个数中,最小数值为7,与第五个数交换:1,2,3,4,5,6,7,9

     

    private static void selectSort(int[] array) {
            int n = array.length;
            for (int i = 0; i < n; i++) {
                int k = i;
                for (int j = i + 1; j < n; j++) {
                    if (array[j] < array[i]) {
                        k = j;
                    }
                }
    
                if (k != i) { // 说明需要换位了,后一位比前一位小
                    int temp = array[i];
                    array[i] = array[k];
                    array[k] = temp;
                }
    
                print(array, n, i);
            }
    
            printResult(array, n);
        }
    
        private static void print(int[] a, int n, int i) {
            // TODO Auto-generated method stub
            System.out.print("第" + i + "次:");
            for (int j = 0; j < n; j++) {
                System.out.print(" " + a[j]);
            }
            System.out.println();
        }
    
        private static void printResult(int[] a, int n) {
            System.out.print("最终排序结果:");
            for (int j = 0; j < n; j++) {
                System.out.print(" " + a[j]);
            }
        }



     

    展开全文
  • LUT是如何实现千万种逻辑结构的

    千次阅读 2020-02-14 19:44:38
    FPGA是可编程器件,与传统逻辑电路和门阵列(如PAL,GAL及CPLD器件)相比,具有不同的结构,FPGA利用小型查找表(16×1RAM)来实现组合逻辑,每个查找表连接到一个D触发器输入端,触发器再来驱动其他逻辑电路或驱动I/O...
  • 专题1-线性表的逻辑结构 2.1 线性表的逻辑结构 数据元素之间的关系是什么 2.1 线性表的逻辑结构 数据元素之间的关系是什么 现实生活中许多问题抽象出的数据模型是线性表如何存储这种线性结构并实现插入删除查找等...
  • 逻辑结构:(就是在你大脑里面能产生,不考虑在计算机中存储) 线性(用一根直线穿) 在计算机中存储用: 数组 链表 栈和队列是一种特殊线性结构,是具体应用。 (操作受限线性结构,不受限应该是在任何地方...
  • FPGA第二篇:查找表结构(LUT)

    万次阅读 多人点赞 2016-04-20 15:14:57
    这篇博客为了阐明以下原理: ...(2)查找表的物理结构是SRAM,原理类似于ROM; (3)N个输入项的逻辑函数可以由一个2^N为容量的SRAM来实现; (4)N个输入的查找表可以实现任意N个输入变量的组合逻辑函数。
  • 而所谓文件的逻辑结构实际上说的就是文件的内部,数据逻辑上是如何组织起来的,是为在文件中查找数据而服务的。 因此,有结构文件中的索引文件,就是将文件内部分为索引与逻辑文件两部分。 文件的物理结构则是描述...
  • 把文件的逻辑结构转换成存储结构,设计便于顺序存取和直接存取的文件存储结构。 为了提高存储空间的利用率,一般采用链接文件的结构。链接文件可以存放在不连续的物理块中,使用链接字(又称指针)来指出文件中各个...
  • 8.2文件的逻辑结构

    2020-06-02 09:08:45
    第一个是主索引,第二个是次索引。 先按索引找到大概位置,然后顺序查找,之后根据索引得到实际数据。
  • 链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:...
  • 目录 1、顺序表初始化 2、顺序表插入元素 3、顺序表删除元素 4、顺序表查找元素 5、顺序表合并 ...线性表的顺序表示指的是用一组地址连续的存储... 并且顺序表的存储空间需要预先分配 1、方法简单,...
  • 线性表在逻辑上是线性结构,也就说是连续一条直线。但是在物理结构上并不一定是连续,线性表在物理上存储时,通常以数组和链式结构的形式存储。 2、顺序 2.1概念及结构 顺序是用一段物理地址连续存储...
  • 4.1_2_文件的逻辑结构

    2020-08-21 10:10:42
    结构文件:流式文件 有结构文件:每一个数据项有一个关键字(ID) 定长记录,可变长记录 ...索引本身是定长记录顺序文件 每个记录对应一个项 索引顺序文件 分组对应一个索引项 多级索引 计算平均查找次数 ...
  • 数据结构_线性表_顺序 创建,插入,删除,查找

    万次阅读 多人点赞 2016-05-04 21:13:02
    首先要了解顺序结构,顺序机构就是将中元素一个接一个存入一组连续存储单元中,这种存储结构是顺序结构。 其次要了解线性表线性 线性表是最基本、最简单、也是最常用一种数据结构。 线性表中数据元素...
  • 基于查找表的正弦波生成的研究

    千次阅读 2020-03-09 16:35:04
    正弦波发生器广泛应用于通信、控制、生物医学电子和音乐合成等领域,基于查找表(LUT)正弦波发生器由于其结构简单而成为一种常见实现方式。此外,LUT是一种通用功能逻辑器件,可以很好地适应可编程逻辑场景,这...
  • 然而它与线性表、树、图等结构不同是,前面几种结构,数据元素之间都存在某种逻辑关系,可以用连线图示表示出来,而哈希技术记录之间不存在什么逻辑关系,它只与关键字有关联。因此,哈希主要是面向查找的存储...
  • LUT查找表实现移位寄存器原理精讲

    千次阅读 2020-02-15 16:01:36
    在文章《LUT是如何实现千万种逻辑结构的》里面我们讲过了LUT原理,实现逻辑函数时,相当于一个ROM将结果预存,然后把通过输入信号当作地址对预存结果进行寻址。因此同样借助LUT加几个端口,就可以实现RAM。...
  • 链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:...
  • 1 mysql中的逻辑存储结构 2 数据结构 2.1 二分查找 2.2 二叉排序树 2.3 平衡二叉树 2.4 B树和B+树 3 B树索引 1 mysql中的逻辑存储结构 1 空间 基于InnoDB存储引擎的mysql数据库,存放在数据库中的数据...
  • 注意:从逻辑上来说,查找表数据元素之间没有本质关系。查找表可以不是线性表,树结构和图结构任意一种。查找操作分为两种:静态查找和动态查找。1.静态查找:1.1. 查询某个特定...
  • 然而它与线性表、树、图等结构不同是,前面几种结构,数据元素之间都存在某种逻辑关系,可以用连线图示表示出来,而哈希技术记录之间不存在什么逻辑关系,它只与关键字有关联。因此,哈希主要是面向查找的存储...
  • 目前FPGA使用最广泛的逻辑实现方式是查找表的实现方式(LUT)。 看网上的资料一大堆讲FPGA的逻辑实现的,讲的云里雾里。看完之后还不是很了解,于是自己买了本FPGA原理的书,总结一下FPGA的逻辑实现的原理和方法。 ...
  • PAGE 1 南昌大学实验报告 学生姓名 叶兴明 学 号 6109117055 专业班级 计算机类172班 实验类型 验证 综合 设计 创新 实验日期 实验成绩 实验一 线性表顺序表的实现 实验目的 掌握顺序表的逻辑结构存储结构操作并通过...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,529
精华内容 611
关键字:

查找表的逻辑结构是