线性表

最新推荐文章于 2024-01-20 11:02:39 发布
最新推荐文章于 2024-01-20 11:02:39 发布
阅读量676 收藏 3
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/halox/p/xian-xing-biao.html
版权

线性表是由 \(n\)个元素\((n \ge 0)\)组成的有限序列，线性表的特征

  • 所有数据元素类型相同
  • 线性表是由有限个元素构成
  • 线性表中的数据元素是与位置是有关的，这一点表明线性表不同于集合，线性表中每个元素都有一个对应的序号，线性表中的元素可以重复出现。

线性表的逻辑结构一般表示为:\( a_1,a_2,...,a_{i-1},a_i,a_{i+1},...,a_n \)

  • 除起始元素没有\(a_1\) 没有前驱元素之外，其他元素\(a_i\)有且仅有一个前驱元素\(a_{i-1},\)
  • 除终端元素没有后继元素外，其他元素 \(a_i\) 有且仅有一个后继元素\(a_{i+1}\)

线性表是一种逻辑结构，线性表的存储结构有

  • 顺序存储
  • 链式存储
顺序表

顺序表的特点

  • 属于直接映射（逻辑上相邻的元素，其物理位置也相邻),
  • 具有随机存取特性（ 通过首地址和元素序号可以在 \(O(1)\) 时间内找到指定元素 )
  • 删除和插入元素需要移动大量元素。
    • 插入元素移动的平均次数\(=\frac{1}{n}\sum_{i=1}^{n}(n-i+1)=\frac{n}{2}\), 因此时间复杂度为\(O(n)\)
    • 删除元素移动的平均次数\(=\frac{1}{n}\sum_{i=1}^{n}(n-i)=\frac{n-1}{2}\)，因此时间复杂度为 \(O(n)\)
  • 存储密度高，其值为\(1\)。\(存储密度=节点数据本身所占用的存储量/节点结构占用的存储量\)

描述顺序结构的三个属性

  • 顺序表的起始地址
  • 顺序表的最大长度
  • 顺序表的当前长度
# define MaxSize 100
typedef struct
   {
       int data[MaxSize];
       int length;
   } SqList;

给定一个有 \(n\) 个元素的整型数组\(arr\),其中连续的相等元素构成的子序列称为平台，设计一个算法求 \(arr\)中最长平台的长度。

int maxLength(int arr[], int n)
{
    int len = 1;
    int max = 1;
    int start = 0;

    for (int i = 1; i < n; i++)
    {
        if (arr[i] == arr[start])
            len++;
        else
        {
            if (len > max)
                max = len;

            start = i;
            len = 1;
        }
    }

    if (len > max)
        max = len;

    return max;
}

设有一个顺序表\(L\), 其元素为整型数据，设计一个算法将\(L\)中所有小于\(0\)的整数放在前半部分，大于等于\(0\)的整数放在后半部分。

void change(SqList &L)
{
    int tmp;
    int i = 0, j = L.length - 1;
    while (i < j)
    {
        while (i < j && L.data[i] < 0)
            i++;
        while (i < j && L.data[j] >= 0)
            j--;
        if (i < j)
        {
            tmp = L.data[i];
            L.data[i] = L.data[j];
            L.data[j] = tmp;
        }
    }
}

设有一个顺序表\(L\)，其元素为整型。设计一个尽可能高效的算法，以第一个元素为分界线，将所有小于等于它的元素移到该元素前面，将所有大于它的元素移到该元素的后面。

void move(SqList &L)
{
    int i = 0;
    j = L.length - 1;
    int pivot = L.data[0];
    int tmp;

    while (i < j)
    {
        while (i < j && L.data[j] > pivot)
            j--;
        while (i < j && L.data[i] <= pivot)
            i++;

        tmp = L.data[i];
        L.data[i] = L.data[j];
        L.data[j] = tmp;

    }

    if (L.data[i] < pivot)
    {
        tmp = L.data[0];
        L.data[0] = L.data[i];
        L.data[i] = tmp;
    }
}

void move(SqList &L)
{
    int i = 0, j = L.length - 1;
    int pivot = L.data[0];

    while (i < j)
    {
        while (i < j && L.data[i] > pivot)
            j--;
        L.data[i] = L.data[j];
        i++;
        while (i < j && L.data[i] <= pivot)
            i++;
        L.data[j] = L.data[i];
        j--;
    }

    L.data[i] = pivot;
}


void move(SqList &L)
{
    int i = 0;
    int pivot = L.data[0];
    int tmp;

    for (int j = 1; j < L.length; j++)
    {
        i++;
        if (i != j)
        {
            tmp = L.data[i];
            L.data[i] = L.data[j];
            L.data[j] = tmp;
        }
    }
    tmp = L.data[0];
    L.data[0] = L.data[i];
    L.data[i] = tmp;
}

已知长度为 \(n\) 的线性表 \(L\) 采用顺序存储结构，编写一个时间复杂度为\(O(n)\),空间复杂度为\(O(1)\) 的算法，该算法删除线性表中所有值为\(x\)的数据元素。

void deleteSameElements(SqList &L, int x)
{
    int base = 0;

    for (int i = 0; i < L.length; i++)
    {
        if (L.data[i] != x)
        {
            L.data[base] = L.data[i];
            base++;
        }
    }
    L.length = base;
}

void deleteSameElements(SqList &L, int x)
{
    int count = 0;
    int i = 0;

    while (i < L.length)
    {
        if (L.data[i] == x)
            count++;
        else
            L.data[i - count] = L.data[i];
        i++;
    }
    L.length = L.length - count;
}

已知长度为 \(n\) 的线性表 \(L\) 采用顺序存储结构，试设计一个时间复杂度空间复杂度两方面都尽可能高效的算法，该算法删除线性表中元素值为\([x,y]\)之间的所有数据元素。

单链表

单链表是用任意一组存储单元存放线性表中的元素，每个节点通过一个指针指向后继节点。这组存储单元可以是连续的也可以是不连续的。

  • 通过头节点(带头节点的单链表）或首节点(不带头节点的单链表）的指针来标识一个链表
  • 从一个已知节点出发，只能访问该节点和通过\(next\)指针访问其后继节点，无法直接找到该节点之前的其他节点
  • 在单链表中插入一个节点或者删除一个节点必须已知其前驱节点，插入和删除操作不需要移动节点
typedef struct LinkedNode
{
  T data;  //T表示数据类型
  struct LNode* next;
}LinkedList;

建立单链表的两种方式

  • 头插法「逆序了」

    void creatLinkedList（LinkedList* &L, int a[],int n)
{
 LinkedList* s;
 L=(LinkedList*)malloc(sizeof(LinkedList));
 L->next=NULL;

 for(int i=0;i<n;i++)
 {
   s=(LinkedList*)malloc(sizeof(LinkedList));
   s->data=a[i];
   s->next=NULL;
   L->next=s;
 }
}

  • 尾插法「还是原来的顺序」

    void creatLinkedList（LinkedList* &L, int a[],int n)
{
 LinkedList* s，*r;
 L=(LinkedList*)malloc(sizeof(LinkedList));
 r=L; //r始终指向终端节点，开始时指向头结点

 for(int i=0;i<n;i++)
 {
   s=(LinkedList*)malloc(sizeof(LinkedList));
   s->data=a[i];
   r->next=s;
   r=s;
 }
 r->next=NULL;
}

单链表的基本操作

  • 按序号查找节点值算法

    int findNode(LinkedList *L,int i,int &e)
{
int j=0;
LinkedList *ptr=L;

while(ptr!=NULL && j<i)
{
  j++;
  ptr=ptr->next;
}
if(NULL==ptr) return 0;
else
{
 e=ptr->data;
 return 1;
}
}

  • 按元素值查找序号算法

    int findNode(LinkedList *L,int key)
{
LinkedList *ptr=L->next;
int index=0;

while(ptr!=NULL && ptr->data!=key)
{
  index++;
  ptr=ptr->next;
}

if(ptr!=NULL) return index;
else return 0;
}

  • 插入元素：将值为\(x\)的元素的新节点插入到第\(i\)个节点的位置上，即先在单链表中找到插入节点的前驱节点，即第\(i-1\)个节点，再在其后插入新节点。

    s->next=p->next;
p->next=s;

  • 删除元素:将单链表中的第 \(i\) 个节点删除。

    q=p->next;
p->next=q->next;
free (q);

有一个线性表\((a_1,a_2,...,a_n)\) 采用带头节点的单链表\(L\)存储，设计一个就地算法将其就地逆置，所谓“就地”是指算法的辅助空间为\(O(1)\).

void reverse(LinkedList * & L)
{
  LinkedList *ptr=L->next;
  LinkedList *q;
  L->next=NULL;
  while(ptr!=NULL)
  {
    q=ptr->next;
    ptr->next=L->next;
    L->next=ptr;
    ptr=q;
  }
}

设\(C=\{a_1,b_1,a_2,b_2,...,a_n,b_n\}\) 为一线性表，采用带头节点的\(hc\)单链表存放，设计一个就地算法，将其拆分为两个线性表（它们都是用单链表存放）使得\(A=\{a_1,a_2,...,a_n\},B=\{b_1,b_2,...,b_n\}\)

void split(LinkedList *hc,LinkedList *&ha,LinkedList *&hb)
{
  LinkedList *r=ha;
  LinkedList *p=hc->next;
  LinkedList *q;
  
  hb->next=NULL;
  while(p!=NULL)
  {
    r->next=p;
    r=p;
    
    p=p->next;
    
    q=p->next;
    p->next=hb->next;
    hb->next=p;
    p=q;
  }
  r->next=NULL;  //别忘了
}
王道题讲解

有一个带头结点的单链表\(L\),设计一个算法使其元素递增有序。

void sort（LinkedList * &L)
{
  LinkedList *p=L->next;
  LinkedList *q=p->next;
  LinkedList *pre,tmp;
  
  p->next=NULL:   //含有一个元素的有序单链表
  p=q;
  
  while(p!=NULL)
  {
    q=p->next;
    pre=L;   //单链表只能从头开始往后寻找节点
    
    tmp=pre->next;
    while(tmp!=NULL && tmp.data < p->data)
    {
      pre=tmp;
      tmp=tmp->next;
    }
    
    p->next=pre->next;
    pre->next=p;
    
    p=q;
  }
}

给定两个单链表，编写算法找出其公共的节点
分析：从头到尾扫描单链表\(A\)，判断当前元素是否在单链表\(B\)中出现，若在则插入到单链表\(C\)中。

void findSameNode(LinkedList *A,LinkedList *B,LinkedList *&C)
{
  LNode *p=A->next;
  LNode *q=B->next;
  LNode *r;
  
  C=(LNode*)malloc(sizeof(LNode));
  C->next=NULL;
  r=C;
  while(p!=NULL)
  {
    q=B->next;
    while(q!=NULL && q.data!=p.data)
         q=q->next;
    
    if(q!=NULL)
    {
      r->next=p;
      r=p;
    }
    p=p->next;
  }
}

\(2010\)年联考真题
设将\(n\) 个整数存放到一维数组R中。试设计一个在时间和空间尽可能高的算法。将\(R\)中保存的序列循环左移\(p （0 \lt q\lt n)\)个位置，即将\(R\)中的数据由\((X_0,X_1,...,X_{n-1})\) 变换为\((X_p,X_p+1,...,X_{n-1},X_0,X_1,....,X_{p-1})\)

void reverse(int R[],int left,int right)
{
 int i=left,j=right;
 int tmp;
 while(i<j)
 {
   tmp=R[i];
   R[i]=R[j];
   R[j]=tmp;
   i++;
   j--;
 }
}

void leftShift(int R[],int n,int p)
{
  if(p>0 &&p<n)
  {
   reverse(R,0,n-1);
   reverse(R,0,n-p-1);
   reverse(R,n-p,n-1);
  }
}

\(2011\)年联考真题
给定两个数组\(A\)和\(B\),数组的长度为\(n\),两个数组都分别有序，求出两个数组中的所有数的中位数。

int search(int A[],int B[],int n)
{
  int i,j,k;
  i=j=k=0;
  while(i<n &&j<n)
  {
    k++;
    if(A[i]<B[j])
    {
      if(k==n)
        return A[i];
       i++;
    }
    else
    {
      if(k==n)
        return B[j];
      j++;
    }
  }
}

分别求出两个升序序列\(A\)，\(B\)的中位数，记为\(a\),\(b\)。若\(a=b\),则\(a\)或\(b\)即为所求，否则舍弃\(a,b\)中较小者所在序列的较小一半，同时舍弃较大者所在序列的较大一半，要求两次舍弃的元素个数相同（每次从左侧和右侧删除相同个数的元素后，新的两个数组，它们的中位数与原始数组的中位数是相同的）。重复上述过程，直到两个序列均只含一个元素为止，则较小的即为所求的中位数。

int searchMid(int A[],int B[],int n)
{
  int startA,midA,endA;
  int startA,midB,endB;
  
  startA=0; endA=n-1; 
  startB=0; endB=n-1;
  
  while(startA!=endA || startB!=endB)
  {
     midA=(startA+endA)/2;
     midB=(startB+endB)/2;
     
     if(A[midA]==B[midB])
        return A[midA];
        
     if(A[midA]<B[midB])
     {
       if((startA+endA)%2==0)//若元素个数为奇数时
       {
         startA=midA;  //舍弃A中间点以前的部分且保留中间点
         endB=midB;    //舍弃B中间点以后的部分且保留中间点
       }
       else  //若元素个数为偶数时
       {
        startA=midA+1;  //舍弃A的前半部分,每次舍弃的长度相同，可以保证同时到达
        endB=midB;      //舍弃B的后半部分
       }
     }
     else if(A[midA] > B[midB])
     {
       if((startA+endA)%2==0)//若元素个数为奇数时
       {
         endA=midA;  //舍弃A中间点以后的部分且保留中间点
         startB=midB;//舍弃B中间点以前的部分且保留中间点
       }
       else  //若元素个数为偶数时
       {
        endA=midA;       //舍弃A的后半部分
        startB=midB+1;   //舍弃B的前半部分
       }
     }
  }
  
  return A[startA]<B[startB]?A[startA]:B[startB];
}
  • 若\(A\)和\(B\)数组的长度为\(2k+1\)，取\(A\)数组的中位数为\(A[k]\)，\(B\)数组的中位数为\(B[k]\)，\(A\)和\(B\)组合起来的中位数应该是第\(2k+1\)大的那个数。如果\(A[k]==B[k]\)，则\(A[k]\)必定为第\(2k+1\)大的数，是所有数字的中位数。如果\(A[k]\gt B[k]\)，则\(A[k]\)至少为第\(2k+2\)大的数，\(B[k]\)至多为第\(2k+1\)大的数，中位数介于\(B[k]\)和\(A[k]\)之间。
  • 若\(A\)和\(B\)数组的长度为\(2k\)，按照题目所述条件，则\(A\)的中位数为\(A[k-1]\),则\(B\)的中位数为\(B[k-1]\),\(A\)和\(B\)组合起来的中位数应该是第\(2k\)大的那个数，若\(A[k-1]==B[k-1]\),则\(B[k-1]\)必为第\(2k\)大的那个数，即所有数字的中位数。如果\(A[k-1]\gt B[k-1]\)，则\(A[k-1]\)至少为第\(2k\)大的数，\(B[k-1]\)至多为第\(2k-1\)大的数，中位数介于\(B[k-1]\)和\(A[k-1]\)之间。

\(2013\)年联考真题
chrome_2016-06-26_16-46-33.png
主元素问题方法一：对数组中元素进行计数，然后查看出现次数最多的元素，若次数大于一半，则为主元素。这种方式只需要对数组扫描一遍，时间复杂度为\(O(n)\),空间复杂度为\(O(n)\)。

int mainElement(int A[],int n)
{
  int *p=(int*)malloc(sizeof(int)*n);
  int max=0;
  
  for(int i=0;i<n;i++) p[i]=0;
  
  for(int i=0;i<n;i++)
  {
    p[A[i]]++;
    if(p[A[i])>p[A[max]]) max=A[i];
  }
  
  if(p[max]>(n/2)  return max;
  else return -1;
}

使用快速排序，然后统计相同元素出现的最大次数

void quickSort(int A[],int left,int right)
{
 int i=left,j=right;
 int tmp;
 
 if(i<j)
 {
    tmp=A[i];
    while(i<j)
    {
      while(i<j && A[j]>tmp) j--;
      A[i]=A[j];
      i++;
      while(i<j && A[i]<=tmp) i++;
      A[j]=A[i];
      j--;
    }
    A[i]=tmp;
    quickSort(A,left,i-1);
    quickSort(A,i+1,right);
 }
}
//然后使用平台算法

数组中存在主元素时，所有的非主元素个数和必少于一半。如果让主元素与一个非主元素"配对“，则最后多出来的元素（没有元素与之配对）就是主元素。从前往后扫描数组元素，假定遇到的当前值选定为主元素，再次遇到它时计数加1，遇到不等的值时，计数减1。当计数减为0后，将遇到的下一个值重新选定为主元素。扫描完毕，当前选定的元素（计数值大于0）可能是主元素，但未必是主元素。还需要对数组再进行一次扫描，记录它出现的实际个数，以判定它是否是主元素。

void mainElemment(int A[],int n)
{
 int base=A[0];
 int count=1;
 int count2=0;
 for(int i=1;i<n;i++)
 {
   if(A[i]==base)
      count++;
   else 
   {  
       if(count>0) count--;
       else 
       {
        base=A[i];
        count=1;
       }
    }
 }
 
 if(count>0)
 {
    count2=0;
    for(int i=0;i<n;i++)
    {
      if(base==A[i])
        count2++;
    }
 }
 if(count2>(n/2))  return base;
 else return -1;
}

转载于:https://www.cnblogs.com/halox/p/xian-xing-biao.html

weixin_30569001
关注
数据结构之线性表
qq_45716514的博客
04-10 777
定义：零个或多个数据元素的有限序列 数据元素之间是一对一的关系 关于定义的说明： 1.若不是空表（数据元素不是零个），则第一个元素没有前驱，最后一个元素没有后继，其余只且只有一个前驱和后继。 2.线性表的元素个数是有限个的。 顺道一提：线性表中数据元素个数n，称为线性表的长度。 常见函数和意义 操作名称 意义 InitList( *L ) 初始化操作，建立一个空的线性表L Li...
数组最大－最小元素的查找算法
estream的专栏
11-16 3595
数组最大－最小元素的查找算法给定数组A[0...n-1]，要求找出A中元素的最大值Max和最小值Min。求最大值和最小值的程序为：// Program Min// Purpose: 求数组元素的最小值int Min(int *A, int nSize){ int k; int nMin; nMin = A[0]; for (k = 1; k   if (A[k]  return nMi
线性表基础知识
qq_45816034的博客
07-19 568
线性表是由n（n≥0）个相同类型的数据元素组成的有限序列。线性表有唯一的开始和结束，除了第一个元素外，每个元素都有唯一的直接前驱；除了最后一个元素外，每个元素都有唯一的直接后继。 线性表有两种存储方式：顺序存储和链式存储。 采用顺序存储的线性表称为顺序表，采用链式存储的线性表称为链表。 顺序表 逻辑上相邻的数据在计算机内的存储位置也是相邻的。 顺序表的优点：操作简单，存储密度高，可以随机存取。 顺序表的缺点：需要预先分配大量的空间，插入和删除操作需要移动大量元素。 单链表 ...
数据结构与算法（三）线性表
qq_34342887的博客
08-19 781
3. 线性表** 3.1. 定义 线性表(List)：由零个或多个数据元素组成的有限序列，线性表元素的个数n(n>=0)定义为线性表的长度，当n=0时，称为空表。若将线性表记为（a1,…,ai-1,ai,ai+1,…an）,则表中ai-1领先于ai,ai领先于ai+1,称ai-1是ai的直接前驱元素,ai+1是ai的直接后继元素。 几个关键的地方： 首先它是一个序列，也就是说元素之间是有个先来后到的； 若元素存在多个。则第一个元素无前驱，而最后一个元素无后继，其他元素都有且只有一个前驱和后继； 线性
线性表的定义和特点
bobocccc的博客
05-24 1284
线性表的特点及形式化定义
数据结构实验报告-线性表-两个有序线性表的归并算法
04-10
具体来说，实验要求学生通过键盘输入数据来建立两个有序线性表，并最终将这两个有序线性表合并成一个新的有序线性表。 #### 实验内容与要求详解 1. **线性表的构建**： - 实验首先要求从键盘输入数据，构建两个...
数据结构学习--线性表及其应用--顺序表
06-25
线性表是数据结构的基础，它是由n（n>=0）个相同类型元素构成的有限序列。线性表按照存储方式可以分为顺序表和链表。顺序表是将线性表中的元素顺序地存储在一块连续的内存空间里，通常采用数组作为其底层实现。这种...
C++通过类实现线性表
08-19
C++ 通过类实现线性表 本文详细介绍了 C++ 通过类实现线性表的知识点，包括线性表的基本概念、类实现线性表的思路、类成员函数的实现等。 线性表的基本概念 线性表是一种基本的数据结构，线性表是由零个或多个...
数据结构实验报告1线性表的顺序存储结构.doc
07-11
实验报告的主题是“数据结构实验报告1：线性表的顺序存储结构”，旨在通过实践让学生掌握线性表在顺序存储结构中的基本操作，包括创建、插入和删除等。实验使用了Visual C++作为开发环境，并涉及到了C++编程语言。 ...
线性表文档之线性表
二木成林
04-05 1979
线性表文档之线性表
数据结构线性表：从基础到应用
最新发布
W_2005的博客
01-20 629
线性表作为数据结构中最基础的一种，其重要性不言而喻。通过本文的介绍，相信大家对线性表有了更深入的了解。希望读者能够通过学习，掌握线性表的基本概念、特性和实现方式，并能够灵活运用线性表解决实际问题。数据结构是编程世界中的基石，深入了解它将对您的编程能力产生深远的影响。
【数据结构】线性表的介绍
WINGREZ‘S BLOG
07-31 2058
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 线性表 线性结构的特点 （以下针对数据元素的非空有限集讨论） （1）存在唯一一个被称作“第一个”的数据元素； （2...
2 线性表
fgh123的博客
04-26 392
文章目录2.1线性表的定义2.1.1什么是线性表2.1.2线性表的抽象数据类型描述2.2线性表的顺序存储结构2.2.1线性表的顺序存储结构--顺序表2.2.2顺序表基本运算的实现1.建立顺序表 线性表是典型的线性结构,最常用的一种数据结构。 线性表的抽象数据类型、 线性表的两种存储结构、 相关运算算法设计和线性表的应用。 2.1线性表的定义 先:线性表的定义 对线性表的抽象数据类型描述 后面...
期末复习——线性表的概念及顺序存储
ChanCherry的博客
06-09 862
之前学的时候没太在意，现在期末复习的时候还是做一下笔记吧，不然内心有点不安φ(．．) 线性表的概念 定义：线性表是由n(n≥0)个类型相同的数据元素a1,a2,…,an组成的有限序列，记作（a1,a2,…,an）。 数据元素之间是一对一的关系，即每个数据元素最多有一个直接前驱和一个直接后驱。 特点： 同一性：线性表由同类数据元素组成，每一个ai必须属于同一数据对象。 有穷性：线性表由有限个数据元素组成，表长度就是表中数据元素的个数。 有序性：线性表中相邻元素之间存在着序偶关系<ai,a.
数据结构复习题（线性表）
热门推荐
努力的程序员
06-01 1万+
数据结构复习题（2）线性表选择题填空题判断题 线性表 选择题 用单链表方式存储的线性表，存储每个节点需要两个域，一个是数据域，另一个是( ) A 当前结点所在地址域 B 指针域 C 空指针域 D 空闲域 下列有关线性表的叙述中，正确的是( )。 A 线性表中的元素之间是线性关系 B 线性表中至少有一个元素 C 线性表中任何一个元素有且仅有一个直接前趋 D 线性表中任何一个元素有且仅有一个直接后继 下列有关线性表的叙述中，正确的是( )。 A 线性表中的元素之间是线性关系 B 线性表中至少有一个元素 C 线性
MOOC数据结构 第五周
weixin_46226815的博客
08-01 6112
1.下面关于串的叙述中，正确的是（ A）。 A.串是一种特殊的线性表 B.串中元素只能是字母 C.空串就是空白串 D.串的长度必须大于零 2.两个字符串相等的条件是（D ）。 A.串的长度相等 B.含有相同的字符集 C.都是非空串 D.两个串的长度相等且对应位置的字符相同 3.若串str=“Software”，其子串的个数是（D ）。 A.8 B.9 C.36 D.37 4.一个链串的节点类型定义为 #define NodeSize 6 typedef struct node { char data[
【C语言】数组循环右移问题
m0_51237680的博客
12-07 1万+
贵大OJ 数组元素循环右移问题 题目描述编制程序，输入整型变量N和M，创建一个长度为N的一维整型数组并输入所有数组元素。将数组中的元素循环右移M个位置后按顺序输出该数组所有元素。 例如：原数组为： 1 2 3 4 5 循环右移3个位置后应该变为 3 4 5 1 2 注意：M的值如果大于等于5该如果处理 输入描述​输入第1行给出正整数N和整数M（≥0）；第2行给出N个整数，其间以空格分隔 输出描述​在一行中输出循环右移M位以后的整数序列，之间用空格分隔,序列结尾不能有多余空格。 ...
C语言实现线性表操作
本文档是关于线性表的实现，使用C语言编写的。文档中包含了一个名为`XianXingBiao`的类，该类用于表示线性表，并提供了初始化、获取长度、插入元素、添加元素以及删除元素等操作。 线性表是一种基本的数据结构，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值