寒假作业Day 10

寒假作业Day 10

一、选择题

1、下列数据结构中，不属于线性表的是( )
A.队列 B.顺序表 C.二叉树 D.链表

A. 队列：队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。因此，队列是线性表。
B. 顺序表：顺序表是用一段地址连续的存储单元依次存储线性表的数据元素。它也是线性表的一种实现方式。
C. 二叉树：二叉树是每个节点最多有两个子节点的树结构，通常子节点被称作“左孩子”和“右孩子”。二叉树并不是线性表，因为它的元素不是按照线性顺序排列的。
D. 链表：链表是一种物理存储单元上非连续的、非顺序的线性数据结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。因此，链表也是线性表的一种实现方式。

2、对于一个头指针为 head 的带头结点的单链表，判断该表为空的条件是（ ）
A. head=NULL B. head→next==NULL C. head→next=head D. head!=NULL

因为头节点只是哨兵位，是不参与单链表的增删查改的，所以头节点的下一个节点才是真正的头节点，所以判断该表为空的条件为head->next==NULL

3、当线性表的元素总数基本稳定，且很少进行插入和删除操作，但要求以最快的速度存取线性表中的元素时，应采用什么存储结构？（ ）
A. 顺序表 B. 单链表 C. 循环链表 D. 双链表

因为要以最快的速度存取元素，并且很少插入和删除，所以我们选择顺序表，因为其他几个链表都需要遍历才可以存取元素，而顺序表可以直接通过下标查找

这个画图可以很清晰噢~

把head当作L指向的内容，而3当作p指向的内容，那么很明显，p->next==L,L->prior ==p

选择C噢，要先把新节点跟旧节点后面的节点连接起来，再把新节点与旧节点连接起来，不然会丢掉后续节点

二、编程题

int search(int* nums, int numsSize, int target) {  
    int n = numsSize;  
      
    // 如果数组为空，则直接返回-1表示未找到目标值  
    if (!n) {  
        return -1;  
    }  
      
    // 如果数组只有一个元素，直接判断这个元素是否等于目标值  
    if (n == 1) {  
        return nums[0] == target ? 0 : -1;  
    }  
      
    // 定义搜索范围的起始和结束索引  
    int begin = 0, end = n - 1;  
      
    // 当搜索范围有效时继续循环  
    while (begin <= end) {  
        // 计算中间元素的索引  
        int mid = (begin + end) / 2;  
          
        // 如果中间元素等于目标值，直接返回其索引  
        if (nums[mid] == target) return mid;  
          
        // 检查左侧部分是否是有序的  
        if (nums[0] <= nums[mid]) {  
            // 如果目标值在有序部分的范围内，更新结束索引  
            if (nums[0] <= target && target < nums[mid]) {  
                end = mid - 1;  
            } else {  
                // 否则，更新起始索引  
                begin = mid + 1;  
            }  
        } else {  
            // 检查右侧部分是否是有序的  
            // 如果目标值在有序部分的范围内，更新起始索引  
            if (nums[mid] < target && target <= nums[n - 1]) {  
                begin = mid + 1;  
            } else {  
                // 否则，更新结束索引  
                end = mid - 1;  
            }  
        }  
    }  
      
    // 如果循环结束还没有找到目标值，则返回-1  
    return -1;  
}

int getDecimalValue(struct ListNode* head) {
    ListNode* phead=head;
    int count=0;  
    int result=0;  
    
    while(phead){
        count++;//遍历链表先记录有多少个节点
        phead=phead->next;
    }

    phead=head;//刷新位置
    while(phead){
        if(phead->val==1)
            result+=pow(2,count-1);//遍历的同时加值，count-1的原因是因为假如有3个节点，101，最高的位置也是2^2，而非2^3，这是需要注意的问题

        count--;//次方逐步下降
        phead=phead->next;
    }

    return result;
}

这是简单粗暴的解法，很容易看出，它的时间复杂度是O(N^2)，过于高，如果数据过大，效率很受影响，所以我们还有另外一种解法

int getDecimalValue(ListNode* head) {
        ListNode* cur = head;
        int ans = 0;
        while (cur != NULL) {
            ans = ans * 2 + cur->val;
            cur = cur->next;
        }
        return ans;
}

很明显可以看出，这里的时间复杂度就只有O(N)了，它是从最高位开始，在遍历的过程逐步乘2；比如101，第一个1乘了2次，第2个0乘了1次，第三个1乘了0次，也就是按照原本的值计算，这是一种更加巧妙的方法，虽然一开始不容易想到，但是效率高了很多