数据结构做题笔记

1. 斐波那契数列：指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列以如下被以递归的方法定义：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=2，n∈N*）

2、字典中找最值

dogdistance = {'dog-dog': 33, 'dog-cat': 36, 'dog-car': 41, 'dog-bird': 42}

min(dogdistance, key=dogdistance.get)

返回最小值的键值：

'dog-dog'

max(dogdistance, key=dogdistance.get)

返回最大值的键值：

'dog-bird'

3. 字符串转数组
str = '1,2,3'
arr = str.split(',')

4. 数组转字符串
arr = ['a','b']
str = ','.join(arr)

arr = [1,2,3]

str = ','.join(str(i) for i in b)

4. 数组反转

1 2 3

arr = [1,2,3] arr.reverse() print(arr)

输出：

[3,2,1]

题目描述

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

 

class Solution:
    def deleteDuplication(self, pHead):
        # write code here
        if pHead == None or pHead.next == None:
            return pHead
        new_head = ListNode(0)
        new_head.next = pHead
        pre = new_head
        cur = pHead
        aft = None
        while cur != None and cur.next != None:
            aft = cur.next
            if cur.val == aft.val:
                while aft != None and aft.val == cur.val:
                    aft = aft.next
                pre.next = aft
                cur = aft
            else:
                pre = cur
                cur = cur.next
        return new_head.next

 

A，数组是连续地址的，插入和删除都需要移动大量元素，不适合插入删除操作

B，队列适合一端插入另一端删除的情况

C，链表适合插入和删除，不需要移动元素

D, 栈适合在同一端插入和删除的操作

 

2.集合中的元素是无关联的，不存在有序无序。 线性表中数据元素之间的关系是一对一，可以有序也可以无序。 但是，至于集合可不可以重复，这个要看对集合的定义是数学模型还是计算机存储模型的角度考虑，数学上来说，集合中元素必须互异。但从计算机的存储角度来说，数组，线性表都可以看做一种集合。。所以好复杂，，看数据结构跟算法数，也没讨论集合

 

3. 你首先要明白的是什么是长度：数组元素的个数称之为数组的长度。 现在再看问题 第一个是 字符串，第二个是字符数组 ，字符串以'\0'为结束符号，字符数组不用。

4. 稀疏矩阵可采用压缩存储，仅存储其中的非零元素。存储时，除了记下非零元素的值外，还要记录其行标i和列标j，即用(i，j，aij)三元组表示。由此可得出如下结论：稀疏矩阵可由表示非零元素的三元组及其行、列数唯一确定。
三元组结构：
typedef struct{
int i，j；#行标和列标
ElemType e；#元素值
} Triple；

非零 10*2*3加上存储非零个数行列的6个字节

5. 渐进时间复杂度是指n趋于无穷时的复杂度。向有序表中任意一个位置插入元素，插入位置之后的元素依次挪动一个位置，假设元素插入的位置坐标为k，则时间复杂度为O(k)，渐进时间复杂度为O(n)

6.1： 数组内存空间少比链表少

2：数组支持随机访问，链表不具有随机访问的特性

3：插入和删除是链表优于数组，数组需要移动被删除或者插入位置之后的元素

7. 有一个 100 × 90 的稀疏矩阵，非 0 元素有 10 ，设每个整型数占 2 个字节，则用三元组表示该矩阵时，所需的字节数是 。

稀疏矩阵可采用压缩存储，仅存储其中的非零元素。存储时，除了记下非零元素的值外，还要记录其行标i和列标j，即用(i，j，aij)三元组表示。由此可得出如下结论：稀疏矩阵可由表示非零元素的三元组及其行、列数唯一确定。
三元组结构：
typedef struct{
int i，j；#行标和列标
ElemType e；#元素值
} Triple；

非零 10*2*3加上存储非零个数行列的6个字节

8. 线性表最常用得操作是存取任一指定序号的元素和在最后进行插入和删除运算；

进行任意位置存取，这个最省时省力的就是数组了，也就是顺序表。

而且元素是在最后的位置进行插入和删除运算，也就不涉及其他元素进行位移的额外操作，最多涉及的就是去扩展空间了。

9. 把三维坐标想象成立方体。分配的空间A[5][6][7]表示层高为5、行数为6、列数为7

10.学java的童鞋看这里，这题应该是属于c++吧，在java中，如果整形数组放在全局变量会初始化为0️，如果放在局部变量则不会自动初始化，声明后直接使用则编译不会通过，不知道里面会是啥。（全局性质数组在会被初始化为0，局部性质数组初始化为乱码）

11. 数组在内存中是按顺序存放的，可以通过下标直接定位到某一个元素，这是随机存取

链表在内存中不是按顺序存放的，而是通过指针连在一起，为了访问某一元素，必须从链头开始顺着指针才能找到某一个元素，是顺序存取
 

顺序存取：就是存取第N个数据时，必须先访问前(N-1)个数据 （list）

随机存取：就是存取第N个数据时，不需要访问前(N-1)个数据,直接就可以对第N个数据操作 （array）

12. 题目考查的是数组的定义，声明，赋值，分类如下：

A选项只能算是一个数组的声明，而非定义，也不是赋值

B选项三条语句都是赋值

C选项是定义

D选项是定义，然后两条语句是赋值

13， java中的数据类型分类：
     基本数据类型（或叫做原生类、内置类型）8种：
                           整数：byte，short，int，long（默认是int类型）
                           浮点类型： float，double（默认是double类型）
                           字符类型：char
                           布尔类型：boolean
      引用数据类型3种：数组，类，接口
其中，基本数据类型之间除了boolean，其他数据类型之间可以任意的相互转换（强制转化或默认转换），这个与c++中有点区别。
个人认为c定义数组的方式是正确的，只不过少了一个分号。java中定义数组有两种方式，一种是int[ ] number，一种是int  number[ ]，推荐第一种，可读性更高。数组的大小一旦指定，就不可以进行改变。

14，一般情况下，我们认为把大的循环放在里面，效率会比较高

但是当如此题一样，涉及不同的内存存取时，把大的循环放在外面可以增大缓存命中率，大幅提高效率。

15，链式存储不但要存储节点的值，还有对应的指针信息。 同样的内存空间，顺序存储不需要额外的信息。顺序存储结构在物理上一般是连续存储，而链式存储一般不占用连续空间，相对而言，顺序存储的存储密度就大

16，short int : 2个字节

sizeof 返回的值表示的含义如下（单位字节）：

     数组 —— 编译时分配的数组空间大小；
     指针 —— 存储该指针所用的空间大小（存储该指针的地址的长度，是长整型，应该为 4 ）；
     类型 —— 该类型所占的空间大小；
     对象 —— 对象的实际占用空间大小；

     函数 —— 函数的返回类型所占的空间大小。函数的返回类型不能是 void 。

short a[100]  空间100*2   故选D

17，：&a和a做右值时的区别：&a是整个数组的首地址，而a是数组首元素的首地址。这两个在数字上是相等的，但是意义不相同。意义不相同会导致他们在参与运算的时候有不同的表现。
2：a和&a[0]做右值时意义和数值完全相同，完全可以互相替代。

18，