精华内容
下载资源
问答
  • 这篇博客目的是让尚未学会hash表朋友们对hash表有... hash表也叫做散列表,是一种通过键值快速访问数据的结构,hash表有两种常见定义形式:数组、数组和链表结合。 理解hash表关键: 1.散列 将字符组成...
        这篇博客的目的是让尚未学会hash表的朋友们对hash表有一个直观的理解,并且能根据本文定义出属于自己的第一个hash表,但算不上研究文,没有深究概念和成功案例。    
        什么是hash表?
        hash表也叫做散列表,是一种通过键值快速访问数据的结构,hash表有两种常见的定义形式:数组、数组和链表的结合。
        理解hash表的关键:
        1.散列法
            将字符组成的字符和字符串转换为固定长度的数值和索引值的方法,通过更短的hash值进行搜索比用原值搜索更快,通常用于数据库建立索引或者加解密。
        2.装填因子
            设m和n分别表示表长和表中填入的节点数,将α=n/m定义为散列表的装填因子,装填因子越大,越容易冲突。
        3.散列函数
            压缩待处理的键值,降低空间开销。
        4.冲突
            两个不同的键值具有同一个散列函数值,因而映射到散列表的同一位置,称为冲突或碰撞,冲突的两个键值称为同义词。
            冲突与散列函数有关,也和表的装填因子有关,hash表在即将填满时冲突几率提高,性能下降严重,但整体是一种极其高效的算法。
            hash表基本上无法避免冲突。
        5.处理冲突
            如果由键值得到的散列函数值(以后用hash地址称呼)已经存有记录,则继续寻找下一个空的hash地址。
            常见的处理冲突方法有开放寻址法、再散列法、拉链法、建立公共溢出区。
        以拉链法定义hash表为例:
        #include<stdio.h>
        #include<stdlib.h>
        #include<string.h>
        #include<Windows.h>
        using namespace std;
        //用于避免冲突的链表,同义键值插入链表
        //散列法中装填因子可以大于1,即待插入表元素总数可以大于表长度,但通常建议装填因子<=1,可以最大限度通过键值直接映射hash表
        struct Node
        {
    int data;
    struct Node* next;
        };
        //hash表主体,上面的链表是用来辅助解决冲突的
        struct Hash_Table
        {
    Node* Value[100];
        };
        //创建hash表
        Hash_Table* CreateHashTable()
        {
    Hash_Table* ptHash = (Hash_Table*)malloc(sizeof(Hash_Table));
    memset(ptHash, 0, sizeof(Hash_Table));
    return ptHash;
        }
        //在Hash表中寻找数据
        //hash法为除留余数法
        Node* FindHashData(Hash_Table* pHashTbl, int data)
        {
    Node* pNode;
    if (NULL == pHashTbl)
    return NULL;
    if (NULL == (pNode = pHashTbl->Value[data % 100]))    //该hash地址尚未插入数据,data%100就是此处应用的hash法
    return NULL;
    //遍历该hash地址指向的单链表的数据,如果键值等于hash表中存储的键值数据,匹配到就返回节点。
    while (pNode)
    {
    if (data = pNode->data)
    return pNode;
    pNode = pNode->next;
    }
    return NULL;
        }
        //在Hash表中插入数据
        BOOL InsertDataIntoHashTable(Hash_Table* pHashTbl, int data)
        {
    Node* pNode;
    if (NULL == pHashTbl)
    return NULL;
    if (NULL == pHashTbl->Value[data % 100])    //该节点尚未插入数据
    {
    pNode = (Node*)malloc(sizeof(Node));
    pNode->data = data;
    pNode->next = NULL;
    pHashTbl->Value[data % 100] = pNode;
    return TRUE;
    }
    //如果该键值已经插入hash表则插入失败,hash表存在同义键值,但不保存重复键值的数据
    if (NULL != FindHashData(pHashTbl, data))
    return FALSE;
    pNode = pHashTbl->Value[data % 100];
    while (NULL != pNode)
    pNode = pNode->next;
    //插入hash地址指向链表的末尾
    pNode->next = (Node*)malloc(sizeof(Node));
    pNode->next->data = data;
    pNode->next->next = NULL;
    return TRUE;
        }
        //从hash表中删除数据
        BOOL DeleteDataFromHashTable(Hash_Table* pHashTbl, int data)
        {
    Node* pNode,*pHead;
    if (NULL == pHashTbl)
    return FALSE;
    if (NULL == pHashTbl->Value[data % 100])
    return FALSE;
    if (NULL == (pNode = FindHashData(pHashTbl, data)))
    return FALSE;
    //如果查找到的hash节点是hash地址链表的首元素,重定向指针并删除。
    if (pNode == pHashTbl->Value[data % 100])
    {
    pHashTbl->Value[data % 100]->next = pNode->next;
    free(pNode);
    return TRUE;
    }
    //如果查找到的hash节点不是hash地址链表的首元素,定位到pNode的上一个节点后重定向指针并删除。
    pHead = pHashTbl->Value[data % 100];
    while (pHead->next != pNode)
    pHead = pHead->next;
    pHead->next = pNode->next;
    free(pHead);
    return TRUE;
        }
        上面的例子是读过一位前辈的例子后模仿的,前辈的例子已经非常精炼,很难有修改的地方,就加了一些注释方便大家理解,下面是学习开放定址法后自己写的一个例子,请大家指教。

        //依据hash处理冲突的开放寻址法

        //开放寻址法有三种探查技术:这里用的线性探测再散列方法
        typedef enum _USE_STATUS {
    STATUS_EMPTY = 0,
    STATUS_NORMAL_USE = 1,
    STATUS_DELETED = 2
        }USE_STATUS;
        struct HASH_DATA
        {
    int                  keyvalue;
    USE_STATUS  use;
        };
        struct HASH_TABLE
        {
    HASH_DATA data[100];
        };
        //定义哈希函数,又称散列函数
        int hash_func(int key)
        {
    return key%10;
        };
        //定义处理冲突的增量序列,线性探测再散列方法增量
        //线性探测的缺点:1.处理溢出需另编程序。2.删除工作困难,删除元素的时候需要将单元打上删除标记,不能直接设置元素为空,否则影响后续探测。
        //3.处理不确定的关键字域时很容易产生堆聚现象,堆聚具有一旦堆聚就更加容易堆聚的特点。
        int hash_di(int val)
        {
    return val;
        };
        HASH_TABLE* CreateHashTable()
        {
    HASH_TABLE* hash = new HASH_TABLE;
    memset(hash, 0, sizeof(HASH_TABLE));
    return hash;
        };
        //若是当前探查的单元为空,表示查找失败
        //若探查到T[d-1]仍然没有查找到,表示查找失败
        HASH_DATA* FindHashTable(HASH_TABLE* head, int key)
        {
    for(int i = 0; i < 100; i++)
    {
    if(head->data[(hash_func(key)+hash_di(i))%100].keyvalue == key && STATUS_NORMAL_USE == head->data[(hash_func(key)+hash_di(i))%100].use)
    {
    return &(head->data[hash_func(key)+i]);
    }
    if(STATUS_EMPTY == head->data[(hash_func(key)+hash_di(i))%100].use)
    return NULL;
    }
    return NULL;
        }
        //若是当前探查的单元中含有key,则插入失败
        //找到空元素或者已删除的元素就插入其中
        BOOL InsertHashNode(HASH_TABLE* head, int key)
        {
    for(int i = 0; i < 100; i++)
    {
    if(head->data[(hash_func(key)+hash_di(i))%100].use == STATUS_DELETED || head->data[(hash_func(key)+hash_di(i))%100].use == STATUS_EMPTY)
    {
    head->data[(hash_func(key)+hash_di(i))%100].keyvalue = key;
    head->data[(hash_func(key)+hash_di(i))%100].use = STATUS_NORMAL_USE;
    return TRUE;
    }
    }
    return FALSE;
        }
        //若是探查T[d-1]的时候仍然未找到包含key的单元,则删除失败
        //线性探查法找到待删除的元素时只能标记为已删除
        //当找到为空的元素仍然没有找到对应的key,则删除失败
        BOOL DeleteHashNode(HASH_TABLE* head, int key)
        {
    for(int i = 0; i < 100; i++)
    {
    if(head->data[(hash_func(key)+hash_di(i))%100].keyvalue == key && STATUS_NORMAL_USE == head->data[(hash_func(key)+hash_di(i))%100].use)
    {
    head->data[(hash_func(key)+hash_di(i))%100].use = STATUS_DELETED;
    return TRUE;
    }
    else if(STATUS_EMPTY == head->data[(hash_func(key)+hash_di(i))%100].use)
    {
    return FALSE;
    }
    }
    return FALSE;
        }

    转载于:https://www.cnblogs.com/learn-my-life/p/3726754.html

    展开全文
  • 《数据结构 1800题》

    热门讨论 2012-12-27 16:52:03
    17.以下属于逻辑结构的是(C )。【西安电子科技大学应用 2001一、1】 A.顺序表 B. 哈希表 C.有序表 D. 单链表 二、判断题 1. 数据元素是数据的最小单位。( ) 【北京邮电大学 1998 一、1(2分)】【青岛大学 ...
  • 插入排序属于内部排序,是对欲排序元素以插入方式寻找该元素适当位置,以达到排序目的 思想: 欢迎访问个人博客(点击进入) 把n个待排序元素看成一个有序表和无序表 开始时有序表只包含一个元素...

    1.算法原理

    插入排序属于内部排序法,是对欲排序的元素以插入的方式寻找该元素的适当位置,以达到排序的目的
    思想:

    欢迎访问我的个人博客(点击进入)

    1. 把n个待排序的元素看成一个有序表和无序表
    2. 开始时有序表只包含一个元素,即a[0],无序表就是有序表后面的n-1个元素
    3. 每次从无序表中取出一个元素,与有序表一次比较,将他插入到合适的位置

    插入排序类似于打扑克牌时整理牌的动作,将牌插入到合适的位置

    2.算法优化

    在每次排序时,有可能这个元素本来的位置就是合适的位置,不需要交换,所以需要一个判断条件,如果插入元素发生变化,则进行插入的动作

    3.代码实现

    public class InsertSort {
        public static void main(String[] args) {
    //        int[] arr = {101,34,119,1,-1,89};
            int arr[] = new int[80000];
            for (int i = 0; i < 80000; i++) {
                arr[i] = (int)(Math.random() * 80000000);//生成[0,8000000]数
            }
            long startTime = System.currentTimeMillis();
            insertSort(arr);
            long endTime = System.currentTimeMillis();
            System.out.println(endTime - startTime);
        }
    
        //插入排序
        public static void insertSort(int[] arr){
            int insertVal = 0;
            int insertIndex = 0;
            //第一轮
            //定义待插入的数
            for (int i = 1; i < arr.length; i++) {
                insertVal = arr[i];
                insertIndex = i - 1; //即arr[1]前面的下标
                while (insertIndex >= 0 && insertVal < arr[insertIndex]){ //待插入数没找到适当位置
                    //101,101,119,1
                    arr[insertIndex + 1] = arr[insertIndex];
                    insertIndex --;
                }
                if(insertIndex + 1 != i){
                    //退出循环时,插入位置找的,insertIndex + 1
                    arr[insertIndex + 1] = insertVal;
                }
            }
    
        }
    
    }
    
    
    
    展开全文
  • 4.下述文件中适合于磁带存储的是( )。【中科院计算所 2000 一、7(2分)】 A. 顺序文件 B. 索引文件 C. 散列文件 D. 多关键字文件 5. 用ISAM和VSAM组织文件属于( )。 A. 顺序文件 B. 索引文件 C. 散列文件 ...
  • 数据结构(C++)有关练习题

    热门讨论 2008-01-02 11:27:18
    2、要求的图如下,也可以自己构造图,但是需要注意的是,图不能是退化的单链表: 实验报告要求: 1、 按要求记录下图的类的完整实验代码; 2、 纪录你所使用的图; 3、 按要求记录下要求的输出...
  • 归并排序是分治法的一个好例子,属于基于比较的内部/外部排序算法。普通的归并算法具有 O(n * log(n)) 的时间和 O(n) 的空间复杂度。就地归并算法能帮助降低额外空间开销,使得归并排序更高效。归并排序之所以可以...

    归并排序是分治法的一个好例子,属于基于比较的内部/外部排序算法。普通的归并算法具有 O(n * log(n)) 的时间和 O(n) 的空间复杂度。就地归并算法能帮助降低额外空间开销,使得归并排序更高效。

    时间复复杂度的推导也非常的典型:

    T(N)=2T(N2)+N

    T(N)N=T(N/2)N/2+1

    T(N)N=11+logN

    T(N)=O(NlogN)

    归并排序之所以可以轻松应用到外部排序上,是因为归并排序的归并过程是顺序扫描的,可以用来处理顺序存储的文件,多路归并还可以用多线程或是并行计算来加速,这样处理大文件就方便了。而想随机访问一个文件,就没那么快了。

    排序数组

    void merge(int a[], int temp[], int left, int right, int rightEnd) {
        int leftEnd = right - 1;
        int numElement = rightEnd - left + 1;
        int i = left;
        while (left <= leftEnd && right <= rightEnd) {
            if (a[left] < a[right])
                temp[i++] = a[left++];
            else
                temp[i++] = a[right++];
        }
    
        while (left <= leftEnd)
            temp[i++] = a[left++];
    
        while (right <= rightEnd)
            temp[i++] = a[right++];
    
        for (i = 0; i < numElement; i++, rightEnd--)
            a[rightEnd] = temp[rightEnd];
    }
    
    void mergeSort(int a[], int temp[], int leftBegin, int rightEnd) {
        int mid;
        if (leftBegin < rightEnd) {
            mid = (leftBegin + rightEnd)/2;
            mergeSort(a, temp, leftBegin, mid);
            mergeSort(a, temp, mid + 1, rightEnd);
            merge(a, temp, leftBegin, mid + 1, rightEnd);
        }
    }
    
    
    int main () {
        int a[10] = {9, 2, 8, 3, 4, 1, 5, 18, 11, 14};
        int  temp[10];
        mergeSort(a, temp, 0, 9);
        for (int i = 0; i < 10 ; i++)
            printf("%d#", a[i]);
        printf("\n");
    }

    合并两个有序的链表

    leetcode 21 题正是应用归并排序来实现两个有序链表的合并。

    下面代码可以通过测试。

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     ListNode *next;
     *     ListNode(int x) : val(x), next(NULL) {}
     * };
     */
        ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
            if (l1 == NULL)
                return l2;
            if (l2 == NULL)
                return l1;
            ListNode *head = new ListNode(0);
            ListNode *pos = head;
            int temp;
    
            while(l1 && l2) {
                if (l1->val < l2->val) {
                    temp = l1->val;
                    l1 = l1->next;
                }
                else {
                    temp = l2->val;
                    l2 = l2->next;
                }
                pos->next = new ListNode(temp);
                pos = pos->next;
            }
    
            while(l1 != NULL) {
                pos->next = new ListNode(l1->val);
                pos = pos->next;
                l1 = l1->next;
            }
    
            while(l2 != NULL) {
                pos->next = new ListNode(l2->val);
                pos = pos->next;
                l2 = l2->next;
            }
            return head->next;
        }
    展开全文
  • 我们可以用siz来记录这个连通块大小,vis来记录这个点是否被访问到,sd记录每个点属于哪个连通块,因此利用bfs深搜性质可得到所有连通块大小。然后我们再逐个点处理,如果这个点是B,那么我们考虑如果将这个点...

    题目描述:题目链接

    题意分析:
    n个节点 n-1条边,非常明显的树形结构(题目中就有说 ),因此不需要考虑环的情况。
    树上有两种颜色,一种是白色一种是黑色,我们可以推断出这题应该是考虑连通块的大小,那么考虑两种思路,一种是bfs,一种是并查集。

    1.bfs
    我们可以用siz来记录这个连通块的大小,vis来记录这个点是否被访问到,sd记录每个点属于哪个连通块,因此利用bfs深搜的性质可得到所有连通块的大小。然后我们再逐个点处理,如果这个点是B,那么我们考虑如果将这个点染成白色之后的连通块大小,下面贴上代码

    #include <bits/stdc++.h>
    using namespace std;
    const int N = 100010;
    int n, m, cc, k, Maxsize;
    int vis[N], sd[N], siz[N];
    vector<int> g[N];
    char ss[N];
    void bfs(int s) {
        queue<int> q;
        q.push(s);
        vis[s] = 1;
        siz[k]++;
        sd[s] = k;
        while (q.size()) {
            int u = q.front();
            q.pop();
     
            for (auto v : g[u]) {
                if (!vis[v] && ss[v] == 'W') {
                    vis[v] = 1;
                    sd[v] = k;
                    siz[k]++;
                    q.push(v);
                }
            }
        }
        Maxsize = max(Maxsize, siz[k]);
    }
     
    int main() {
        cin >> n;
        cin >> ss + 1;
        for (int i = 1; i <= n; i++) if (ss[i] == 'B') cc++;
     
        for (int i = 1; i < n; i++) {
            int x, y;
            cin >> x >> y;
            g[x].push_back(y);
            g[y].push_back(x);
        }
     
        for (int i = 1; i <= n; i++) {
            if (!vis[i] && ss[i] == 'W') {
                k++;
                bfs(i);
            }
        }
        int Max = 0;
        for (int i = 1; i <= n; i++) {
            int ans = 0;
            if (ss[i] == 'B') {
                for (auto v : g[i]) {
                    ans += siz[sd[v]];
                }
            }
            Max = max(Max, ans + 1);
        }
        if (!cc) cout << Maxsize;
        else cout << Max;
    }
    

    2.并查集
    同样我们可以利用并查集的性质将点与点联系起来,类似于kruskal算法中的应用。然后同理利用siz记录每个连通块的大小,最后对每个B节点处理过程如上。
    下面给出代码:

    #include <bits/stdc++.h>
    using namespace std;
    const int N = 100010;
    int fa[N], cc;
    char ss[N];
    int siz[N], n, Maxsize;
    vector<int> g[N];
    int find(int x) {
    	if (x == fa[x]) return x;
    	else return fa[x] = find(fa[x]);
    }
    
    void combine(int x, int y) {
    	int t1 = find(x), t2 = find(y);
    	if (t1 != t2) {
    		if (siz[t1] >= siz[t2]) {
    			fa[t2] = t1;
    			siz[t1] += siz[t2];
    		}
    		else {
    			fa[t1] = t2;
    			siz[t2] += siz[t1];
    		}
    	}
    }
    
    int main() {
    	cin >> n;
    	cin >> ss + 1;
    	for (int i = 1; i <= n; i++) {
    		fa[i] = i;
    		if (ss[i] == 'W') siz[i] = 1;
    		else cc++;
    	}
    	for (int i = 1; i < n; i++) {
    		int x, y;
    		cin >> x >> y;
    		g[x].push_back(y);
    		g[y].push_back(x);
    		if (ss[x] == ss[y] && ss[x] == 'W') combine(x, y);
    	}
    
    	int Max = 0;
    	for (int i = 1; i <= n; i++) {
    		int ans = 0;
    		if (ss[i] == 'B') {
    			for (auto v : g[i]) {
    				if (ss[v] == 'W') ans += siz[find(v)];
    			}
    		}
    		Max = max(Max, ans + 1);
    	}
    	if (!cc) cout << n;
    	else cout << Max;
    
    }
    

    并查集:

    bfs:

    最后对比发现并查集在时间复杂度上确实优于bfs。

    展开全文
  • 1. 在各种系统开发方法中...3. 通过构造目标系统基本要求,通过追加、完善、演化成最终系统方法属于()范畴。 A. 结构化方法 B. 面向对象方法 C. 原型 D. 功能点 4. 计算机操作系统主要功能是() A.
  • C#数组使用

    2019-10-02 03:52:12
    C#基础语法中得数组,定义就是:数组是一种数据结构,包含同一个类型多个元素。从CLR角度来看,首先数组是引用类型,堆栈分配属于分配于堆上,其次数组在内存中是连续存储,所以索引速度很快,而且赋值与...
  • (2) 以下数据结构中不属于线性数据结构的是(C) A. 队列 B. 线性表 C. 二叉树 D. 栈 (3) 在一棵二叉树上第5层的结点数最多是(B) 注:由公式2k-1得 A. 8 B. 16 C. 32 D. 15 (4) 下面描述中,符合结构化程序设计风格...
  • JavaScript不具备传统面向对象的编程语言中所支持的类和接口等基本结构,所以用类的概念描述一个引用类型不是特别的精确...这里方括号表示法的优点是可以通过变量来访问属性,但是日常还是以点表示法为主。 Array类...
  • (2) 以下数据结构中不属于线性数据结构的是______。(C) A. 队列 B. 线性表 C. 二*树 D. 栈 (3) 在一棵二*树上第5层的结点数最多是______。(B) A. 8 B. 16 C. 32 D. 15 (4) 下面描述中,符合结构化程序设计风格的是__...
  • 下列属于面向对象开发方法的是(A B C D)。 A) Booch B) UML C) Coad D) OMT 6. 软件危机的主要表现是(B D)。 A) 软件成本太高 B) 软件产品的质量低劣 C) 软件开发人员明显不足 D) 软件生产率低下 7...
  • ASP.NET网页代码模型及生命周期

    热门讨论 2009-07-28 14:22:11
    在客户端浏览器访问该页面时,浏览器会给IIS发送请求消息,IIS则会开始执行ASP.NET编译过程,如果不存在编译过后DLL文件,则加载编译类并创建对象。当创建对象完成,生成创建对象后代码并生成一个ASPX页面代码...
  • 系统,和汇编相比,C 在功能上、结构性、可读性、可维护性上有明显优 势,因而易学易用。 Keil c51 软件提供丰富库函数和功能强大集成开发调试工具,全 Windows 界面。另外重要一点,只要看一下编译后生成...
  • 例如:火车进遂道,最先进遂道的是火车头,最后是火车尾,而火车出遂道的时候也是火车头先出,最后出的是火车尾。若有队列: Q =(q1,q2,…,qn) 那么,q1为队头元素(排头元素),qn为队尾元素。队列中的元素是按照q1...
  • BFS算法

    2021-02-01 01:20:06
      单源最短路径算法(Dijkstra)和最小生成树算法(Prim)都采用了和宽度优先搜索类似思想,属于一种盲目搜寻,目的是系统地展开并检查图中所有节点,以找寻结果。换句话说,它并不考虑结果可能位置,彻底地...
  • 选择式排序也属于内部排序,是从欲排序数据中,按指定规则选出某一元素,再依规定交换位置后达到排序目的。 2 选择排序思想 尚硅谷Java数据结构和算法更多Java–大数据–前端–python人工智能-区块链资料...
  • 为使设计透明和执行灵活 ,遵循 ISO /OSI标准模型 , CAN 总线结构划分为两层: 物理层和数据链路层 (包括逻辑链路控制子层 LLC和媒体访问控制子层 M AC)。 CAN分层结构和功能如图1所示。 其中 , LLC子层为数据传递和...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    17.1 .Net 框架结构提供 I/O 方式 .215 17.2 文件存储管理 .217 17.3 读 写 文 件 .222 17.4 异步文件操作 .227 17.5 小 结 .234 第十八章 高 级 话 题 .235 18.1 注册表编程 .235 18.2 在 C #代码...
  • Microsoft+.NET企业级应用架构设计

    热门讨论 2012-02-20 17:54:59
     ·深入探究数据访问模式和最佳实践  ·为对象和数据之间转换提供良好解决方案  ·降低开发工作量,避免过度设计,建造更强壮系统 第1章 当代架构师和架构  1.1 软件架构到底是什么  1.1.1 将架构...
  • C#微软培训资料

    2014-01-22 14:10:17
    17.1 .Net 框架结构提供 I/O 方式 .215 17.2 文件存储管理 .217 17.3 读 写 文 件 .222 17.4 异步文件操作 .227 17.5 小 结 .234 第十八章 高 级 话 题 .235 18.1 注册表编程 .235 18.2 在 C #代码...
  •  以下关于结构化开发方法的叙述中,不正确的是 (5) 。 (5)A. 总的指导思想是自顶向下,逐层分解 B. 基本原则是功能的分解与抽象 C. 与面向对象开发方法相比,更适合于大规模、特别复杂的项目 D. 特别适合于...
  • 并查集总结

    2020-07-28 21:50:12
    并查集是一种树型数据结构,用于处理一些不相交集合合并及查询问题 集合定义方法:“代表元”,每个集合选择一个节点作为整个集合代表,最根部父亲节点 二、基本操作 Find——查询一个元素属于哪一个集合 ...
  • php高级开发教程说明

    2008-11-27 11:39:22
    前面提到每一种语言代表一种解决问题特定方法,这些问题多属于具有特殊要求某 一特殊种类。因为这些语言集中在一个有限应用领域内,他们成功性也限制在这些领域。 像C和P a s c a l这样语言变得如此流行...
  • •为用户提供统一方法(以数据记录逻辑单位),访问存储在物理介质上信息。 2、文件分类 (1)按文件性质与用途分:系统文件、库文件、用户文件 (2)按操作保护分:只读文件、可读可写文件、可...
  • 11.2.1 将一个结构作为另一个结构的成员 414 11.2.2 声明结构的结构 415 11.2.3 将结构指针用作结构成员 416 11.2.4 双向链表 420 11.2.5 结构位字段 423 11.3 结构与函数 424 11.3.1 结构作为函数变...
  • 11.2.1 将一个结构作为另一个结构的成员 414 11.2.2 声明结构的结构 415 11.2.3 将结构指针用作结构成员 416 11.2.4 双向链表 420 11.2.5 结构位字段 423 11.3 结构与函数 424 11.3.1 结构作为函数变...
  • Visual C++ 2005 入门经典 详细书签版

    热门讨论 2013-02-02 16:39:43
    7.1.4 访问结构的成员 297 7.1.5 伴随结构的智能帮助 300 7.1.6 RECT结构 301 7.1.7 使用指针处理结构 302 7.2 数据类型、对象、类和实例 303 7.2.1 类起源 305 7.2.2 类操作 305 7.2.3 术语 ...

空空如也

空空如也

1 2 3 4
收藏数 73
精华内容 29
关键字:

属于结构访问法的是