码迷，mamicode.com
首页 > 其他好文 > 详细

线性表

时间：2017-04-17 22:06:05      阅读：234      评论：0      收藏：0      [点我收藏+]

标签：max   通过   奇数   int start   指针   str   大量   --   开始   

线性表是由 \(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\)年联考真题
技术分享?
主元素问题方法一：对数组中元素进行计数，然后查看出现次数最多的元素，若次数大于一半，则为主元素。这种方式只需要对数组扫描一遍，时间复杂度为\(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;
}

线性表

标签：max   通过   奇数   int start   指针   str   大量   --   开始   

原文地址：http://www.cnblogs.com/halox/p/xian-xing-biao.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！