《数据结构》练习1-线性表

各位好,我是小饼干,一个编程界的小学生,每天都希望学习一点点编程相关。最近在CSDN上看到好多的小伙伴都在学数据结构,今天我分享一些习题供大家巩固一下知识,,有些题附上我自己的一些见解,感谢各位的驻足,笔芯♥。

这里写目录标题

    • ‍ 判断
    • ‍选择
    • ‍程序填空题
    • ‍函数题

‍ 判断

1.算法分析的两个主要方面是时间复杂度和空间复杂度的分析。✅

有些问题的一再研究就是为了减低时间复杂度和空间复杂度。

2.对于某些算法,随着问题规模的扩大,所花的时间不一定单调增加。✅

3.抽象数据类型中基本操作的定义与具体实现有关。❎

4.算法可以没有输入,但是必须有输出。❎

输入输出都是非必须的

5.若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算,则利用顺序表存储最节省时间。✅

6.对于顺序存储的长度为N的线性表,删除第一个元素和插入最后一个元素的时间复杂度分别对应为O(1)和O(N)。❎

因为是顺序表所以“第一”“最后一个”相当于指定了位置,不需要进行遍历,所以时间复杂度均为O(1)。

7.顺序存储方式只能用于存储线性结构。❎

8.在顺序表中取出第i个元素所花费的时间与i成正比。❎

非线性关系,因为是顺序表并且知道是第i个,相当于知道了具体位置。所以时间复杂度为O(1)

9.线性表采用链式存储结构时,各个数据元素的存储单元地址一定是不连续的。❎

既可以是连续的也可以是不连续的。

10.线性表L如果需要频繁地进行不同下标元素的插入、删除操作,此时选择顺序存储结构更好。❎

了解顺序表和线性表的优缺点这道题就很轻松

‍选择

分数 2

  • 当输入规模为n时,下列算法渐进复杂性中最低的是

    A.5n
    B.n^2
    C.2n^2
    D.n!

  • 如果某数据结构的数据元素的集合为S={A,B,C,D,E,F,G},数据元素之间的关系为R={<A,D>,<A,G>,<D,B>,<D,C>,<G,E>,<G,F>},则该数据结构是一种( )。

    A.线性结构
    B.树结构
    C.图结构
    D.链表结构

  • 下面算法的时间复杂度为 ▁▁▁▁▁。

    int foo(int *a, int n)
    {
        int i, s = 0;
        for (i = 0; i < n; ++i)
        {
            s += a[i];
        }
        return s;
    }
    

    A.O(nlog 2 n)
    B.O(n2 )
    C.O(n)
    D.O(n√n )

  • 下面算法的时间复杂度为 ▁▁▁▁▁。

    int foo(int **a, int n)
    {
        int i, j, s = 0;
        for (i = 0; i < n; ++i)
        {
            for (j = 0; j < n; ++j)
            {
                s += a[i][j];
            }
        }
        return s;
    }
    

    == A.O(n2)==
    B.O(nlog 2 n)

    C.O(n)

    D.O(n √n )

  • 在一个长度为n的顺序表中,删除第i个元素(1≤i≤n)时需要移动( )个元素。
    A.n-i

    B.n-i+1

    C.n-i-1

    D.i

    i和i之前的都是不用移动的

  • 在n个数据元素的顺序表中,算法时间复杂度为O(1)的操作是( )
    (1) 访问第i个结点(1≤i≤n)
    (2) 求第i个结点的直接前驱(2≤i≤n)
    (3) 求第i个结点的直接后继(1≤i≤n-1)
    (4) 在第i个结点后插入一个新结点(1≤i≤n)
    (5) 删除第i个结点(1≤i≤n)
    (6) 排序

    A.(1)(2)(3)(4)(5)

    B.(1)(2)(3)

    C.(4)(5)

    D.(6)

  • 顺序表中第1个元素的存储地址是2000,每个元素的长度为4,则第5个元素的地址是( )

    A.2020

    B.2016

    C.2024

    D.2012

  • 假设某个带头结点的单链表的头指针为head,则判定该表为空表的条件是( )

    A.head==NULL

    B.head->nextNULL==

    C.head!=NULL

    D.head->next==head

  • 在单链表中,指针域为next,要将q所指结点链接到p所指结点之后,其语句序列应为( )

    A.q->next=p->next; p->next=q;

    B.p->next=q; q->next=p->next;

    C.q->next=p+1; p->next=q;

    D.p->next=q; q->next=p;

    就是将q放到p之后,所以p的下一个结点的地址要给q->next,再把q的地址给p->next。这两个顺序不能改变

  • 在双向链表中,前驱指针为prior,后继指针为next,在p指针所指的结点后插入q所指向的新结点,其语句序列是( )

    A.q->prior=p; q->next=p->next; p->next=q; p->next->prior=q;

    B.q->prior=p; q->next=p->next; p->next->prior=q; p->next=q;

    C.p->next=q; p->next->prior=q; q->prior=p; q->next=p->next;

    D.p->next=q; q->prior=p; p->next->prior=q; q->next=q;

‍程序填空题

‍♀️本题目要求利用尾插法建立单链表。
‍♂️输入格式:

‍♀️ 输入数据为若干正整数,最后以-1表示结尾(-1不算在序列内,不要处理)。‍♂️所有数据之间用空格分隔。

#输入样例:

1 2 3 4 5 6 7 8 9 -1
#输出样例:

1 2 3 4 5 6 7 8 9

#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

LinkList Create();
void print( LinkList L);

int main()
{
    LinkList L = Create();
    print(L);
    return 0;
}
LinkList Create()
{
    LinkList L,p,s;
    ElemType e;
    L = (LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    
p=L
;
    scanf("%d",&e);
    while(e!=-1)
    {
        s = (LinkList)malloc(sizeof(LNode));
        s->data=e;
        
p->next=s
;
        
p=p->next
;
          scanf("%d",&e);
    }
    p->next=NULL;
    
return L
;
}
void print(LinkList L)
{ 
    LinkList p;
    p=L->next;
    while (p)
    {
         printf("%d ", p->data);
         p =p->next;
    }
}

‍♂️本题目要求以头插法建立单链表。
‍♀️ 输入格式:

‍♂️输入数据为若干正整数,最后以-1表示结尾(-1不算在序列内,不要处理)。‍♀️所有数据之间用空格分隔。

#输入样例:

1 2 3 4 5 6 7 8 9 -1
#输出样例:

9 8 7 6 5 4 3 2 1



#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

LinkList Create();
void print( LinkList L);

int main()
{
      LinkList L = Create();
      print(L);
      return 0;
}
LinkList Create()
{
    LinkList L,s;
    ElemType e;
    L = (LinkList)malloc(sizeof(LNode));
    
L->next=NULL
;
    scanf("%d",&e);
    while(e!=-1)
    {
        s = (LinkList)malloc(sizeof(LNode));
        s->data=e;
        
s->next=L
;
        
L=s
;
        scanf("%d",&e);
    }
    
return L
;
}
void print(LinkList L)
{ 
    LinkList p;
    p=L->next;
    while (p)
    {
         printf("%d ", p->data);
         p =p->next;
    }
}

‍本题要求采用尾插法建立单链表并输出链表



#include<stdio.h>
#include<stdlib.h>

typedef int DataType;
struct Node {
    DataType      data;
    struct Node*  next;
};
typedef struct Node  *PNode;
typedef struct Node  *LinkList;

LinkList SetNullList_Link()
{
    LinkList head = (LinkList)malloc(sizeof(struct Node));
    if (head != NULL) head->next = NULL;
    else printf("alloc failure");
    return head;
}

void CreateList_Tail(struct Node* head)
{
    PNode p = NULL; PNode q = head; int data;
    scanf("%d", &data);
    while (data != -1) 
    {  
        p = (struct Node*)malloc(sizeof(struct Node));
        p->data = data;
    p->next = NULL;
q->next=p;
q=p;

        scanf("%d", &data);
    }
}
void print(LinkList head)
{
    PNode  p = head->next;
    while (p) 
    {
        printf("%d ", p->data);
        
p=p->next

    }
}
void DestoryList_Link(LinkList head)
{
    PNode  pre = head; 
    PNode p = pre->next;
    while (p) 
    {
        free(pre);
        pre = p;
        p = pre->next;
    }
    free(pre);
}

int main()
{
    LinkList head = NULL;
    head = SetNullList_Link();
    CreateList_Tail(head);
    print(head);
    DestoryList_Link(head);
    return 0;
}

‍ 顺序表插入操作



#include<iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define MAXSIZE 100
typedef int datatype;

typedef struct {
    datatype *elem; 
    int length;
} SqList;

int ListInsert_Sq(SqList &L, int i, datatype e) { 
    if ((i < 1) || (i > L.length + 1))
        return ERROR;
    if (L.length == MAXSIZE)
        return ERROR; 
    for (int j = L.length - 1; j >= i - 1; j--)
    
L.elem[j+1] = L.elem[j]
; 
    
L.elem[i-1] = e
; 
    ++L.length;
    return OK;
}

int main() {
    SqList L;
    int i = 0, n,a;
    datatype e;
    L.elem = new datatype[MAXSIZE];
    L.length = 0;
    cin >> n;
    for (i=0;i<n;i++) 
        cin >> L.elem[i];
    L.length = i;
     cin >> a >> e;
    if (ListInsert_Sq(L, a, e))
    {
      for (i = 0; i < L.length; i++)
          if(i==0)
            cout  << L.elem[i];
                  else
                cout  << " " << L.elem[i];                
    }
    else
        cout << "ERROR";
    return 0;
}

‍函数题

‍♀️删除顺序表中的偶数
‍♂️本题要求实现一个函数,可删除顺序表中的偶数元素。

‍♀️函数接口定义: void Del_even(SqList *L); 其中 L是待删除元素的顺序表,也是删除后返回的顺序表。

裁判测试程序样例:
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
typedef int DataType;
#define LISTSIZE  100 
typedef struct
{
    DataType items[LISTSIZE]; /* 存放顺序表元素的数组 */
    int length;                /* 表示线性表的当前表长 */
}SqList;
int InitSqList(SqList *L)
{ /* L为指向顺序表的指针 */
    L->length = 0;
    return 1;
}
int SqListEmpty( SqList L )
{/* L为顺序表 */
    if( L.length <= 0 )
        return 1;
    else
        return 0;
}
int SqListInsert( SqList *L, int pos, DataType item )
{     
    int j;
    if ( L->length == LISTSIZE )                // "溢出”处理
    {     
        printf("overflow!\n");
        return 0; 
    }
    if ( (pos<=0) || (pos > L->length+1) )    // pos值"超出”处理
    {    
        printf("position is error!/n");
        return 0;  
    }
    for (j = L->length -1; j >=pos-1; j--)
        L-> items[j+1] = L-> items[j];    //后移一个位置
    L-> items[pos-1] = item;              //新的数据元素写入
    L->length++;                          //线性表的长度增加1
    return 1;
}
int SqListDelete ( SqList *L, int pos, DataType *item ) 
{/* L为指向顺序表的指针,pos为删除位置,用于item返回被删元素 */    
    int i;
    if( SqListEmpty(*L) )
    {
        printf("顺序表为空表,无法进行删除操作!");
        return 0;
    }
    if ( ( pos<1 ) || ( pos>L->length ) )  
        // 判断pos值是否超出所允许的范围
    {
        printf("删除位置不合法,其取值范围应该是[1,length]");
        return 0; 
    }
    *item = L->items[pos-1];          // 把第pos个元素赋给*item 
    for ( i=pos ; i<L->length ; i++ )   
        L->items[i-1]= L->items[i]; // 第i个元素后的所有元素依次前移  
    L->length--;                    // 顺序表长度减 1
    return 1;       
}

int TraverseSqList(SqList L)
{    /* L为顺序表 */
    int i;
    for (i=0;i<L.length;i++)
    {
        printf("%d ",L.items[i]);
    }
    printf("\n");
    return 1;
}
void Del_even(SqList *L);

int main()
{
    SqList A;
    DataType x;
    char ch;
    int i,j,pos = 1;
    InitSqList(&A);
    do
    {  
        scanf("%d",&x);
        SqListInsert( &A , pos++ , x );        
    }while ((ch=getchar())!='\n');
    Del_even(&A);
    TraverseSqList(A);
    return 0;
}
/* 请在这里填写答案 */

输入样例: 21 54 56 78 94 11 13 53 64 97 66 68 72 19
输出样例: 21 11 13 53 97 19

void Del_even(SqList* L) {
    DataType item;
    for (int i = L->length; i > 0; i--)
        if ((L->items[i - 1]) % 2 == 0) 
           SqListDelete(L, i , &item);
}

你可能感兴趣的