数据结构-------线性表

最新推荐文章于 2024-04-13 02:53:43 发布

一刻不学习就是15分钟

最新推荐文章于 2024-04-13 02:53:43 发布

阅读量670

点赞数

分类专栏： # 数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/weixin_44445446/article/details/119086010

版权

数据结构专栏收录该内容

4 篇文章 0 订阅

订阅专栏

第二章线性表

**线性表：**具有相同数据类型的n个数据元素的有限序列。

顺序表

**顺序表：**线性表的顺序存储又叫顺序表。它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。

特点：

随机访问(通过首地址和元素序号可在时间O(1)内找到指定的元素)；
存储密度高(每个节点只存数据元素)；
扩展容量不方便；
插入删除数据元素不方便。

从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删除的元素的值，空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行。

**思路：**搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填补到空出的位置

bool Del_Min(sqList &L, ElemType &value){
    if(L.length == 0){
        return false;
    }
    value = L.data[0];
    int pos = 0;   					//用来标记最小值的位置
    for(int i = 1; i < L.length; i++){
        if(L.data[i] < value){
            value = L.data[i];
            pos = i;
        }
    }
    L.data[pos]=L.data[length-1];  //空出位置用最后一个元素填补
    L.length--;
    return true;
}

将顺序表L的所有元素逆置，要求算法的空间复杂度为O(1)

**思路：**扫描顺序表的前半部分，与后半部分进行交换

void Reverse(SqList &L){
    ElemType temp;
    for(int i=0;i<L.length/2;i++){
        temp=L.data[i];
        L.data[i]=L.data[L.length-1];
        L.data[L.length-1]=temp;
    }
}

对长度为n的顺序表L，编写一个时间复杂度为O(n)，空间复杂度为O(1)的算法，该算法删除线性表中所有值为x的数据元素

**思路1：**用k记录顺序表L中不等于x的元素个数，将不等于x的元素向前移动k个位置，最后修改L的长度

void del_X_1(SqList &L, ElemType x){
    int k=0;						//记录不为x的值，初始为0
    for(int i=0;i<L.length;i++){
        if(L.data[i]!=x){
            L.data[k]=L.data[i];
            k++;
        }
    }
    L.length=k;
}

**思路2：**用k记录顺序表中等于x的元素个数，将不等于x的元素向前移动k个位置，最后修改L的长度

void del_X_2(SqList &L,ElemType x){
    int k=0,i=0;
    while(i<L.length){
        if(L.data[i]==x)
            k++;
        else
            L.data[i-k]=L.data[i];
        i++;
    }
    L.length=L.length-k
}

从有序顺序表中删除其值在给定值s与t之间(要求s<t)的所有元素，如果s或t不合法或顺序表为空，则显示错误信息并退出。

**思路：**先寻找大于等于s的第一个元素，然后寻找大于t的第一个元素，要将这段元素删除，只需直接将后面的元素迁移

bool Del_s_t2(SqList &L,int s, int t){
    int i,j;
    if(s>=t || L.length==0)
        return false;
    for(i=0;i<L.length&&L.data[i]<s;i++);
    if(i >= L.length)
        return false;
    for(j=i;j<L.length&&L.data[j]<=t;j++);
    for(;j<L.length;i++,j++)
        L.data[i]=L.data[j];
    L.length=i;
    return true;
}

从顺序表中删除其值在给定值s与t之间(要求s<t)的所有元素，如果s或t不合法或顺序表为空，则显示错误信息并退出。

**思路：**从前到后扫描顺序表L，用k记录元素值在s到t之间元素的个数。对于当前扫描的元素，若其值不在范围内，则前移k个位置，否则执行k++。

bool Del_s_t(SqList &L,int s,int t){
    int i,k=0;							//k记录在范围内的数
    if(L.length==0 || s>=t)
        return false;
    for(i=0;i<L.length;i++){
        if(L.data[i]>=s&&L.data[i]<=t)
            k++;
        else
            L.data[i-k]=L.data[i];
    }
    L.length-=k;
    return true;
}

从有序表中删除所有其值重复的元素，使表中所有的元素的值均不同

**思路：**有序表中重复元素相邻，初始将第一个元素视为非重复的有序表。依次判断后面的元素是否与前面非重复有序表的最后一个元素相同，若相同继续向后判断，若不同则插入到非重复有序表的最后。

bool Delete_Same(SeqList &L){
    if(L.length ==0)
        return false;
    int i,j;
    for(i=0,j=1;j<L.length;j++){
        if(L.data[i]!=L.data[j])
            L.data[++i]=L.data[j];	//插入到非重复有序表的末尾
    }
    L.length=i+1;
    return true;
}

将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表

**思路：**按顺序不断取下两个顺序表表头较小的结点存入新的顺序表中，将表剩余的部分加入到新的顺序表的后面

bool Merge(SeqList A, SeqList B, SrqList &C){
    if(A.length+B.length>C.maxSize)
        return false;
    int i=0,j=0,k=0;
    while(i<A.length&&j<B.length){
        if(A.data[i]<=B.data[j])
            C.data[k++]=A.data[i++];
        else
            C.data[k++]=B.data[j++];
    }
    while(i<A.length)
        C.data[k++]=A.data[i++];
    while(j<B.length)
        C.data[k++]=B.data[j++];
    C.length=k;
    return true;
}

已知在一维数组A[m+n]中依次存放两个线性表，编写一个函数，将数组中两个顺序表的位置互换。

**思路：**先将全部元素原地逆置，在对前n个元素和后m个元素分别使用逆置算法

typedef int DataType;void Reverse(DataType A[], int left,int right,int arraySize){    if(left>=right||right>=arraySize)        return;    int mid = (left+right)/2;    for(int i=0;i<=mid-left;i++){        DataType temp=A[left+i];        A[left+i]=A[right-i];        A[right-i]=temp;    }}void Exchange(DataType A[],int m,int n,int arraySize){    Reverse(A,0,m+n-1,arraySize);    Reverse(A,0,n-1,arraySize);    Reverse(A,n,m+n-1,arraySize);}

线性表中的元素递增有序且按顺序存放到一维数组R中，在最少的时间内在表中查找到值为x的元素，若找到将其与后置元素位置交换，若找不到则将其插入表中使仍然有序

**思路：**要求用最少时间，则采用折半查找

void SearchExchangeInsert(ElemType A[],ElemType x){    int low=0,high=n-1,mid;    while(low<=high){        mid=(low+high)/2;        if(A[mid]==x) break;        else if(A[mid]<x) low=mid+1;        else high=mid-1;    }    if(A[mid] == x&&mid!=n-1){        t=A[mid];        A[mid]=A[mid+1];        A[mid+1]=t;    }    if(low>high){				//查找失败        for(i=n-1;i>high;i++)            A[i+1]=A[i];        A[i+1]=x;    }}

设将n(n>1)个整数存放到一维数组R中，将R中保存的序列循环左移p(0<p<n)个位置，即将R中的数据由(X₀,X₁,X₂,…,X_n-1)变换为(X_p,X_p-1,…,X_n-1,X₀,X₁,X_p-1)。

***思路：***可将这个问题视为数组ab转换成数组ba(a代表数组的前p个元素，b代表数组的余下n-p个元素)，先将a逆置得到a^-1b，再将b逆置得到a^-1b^-1，将整个a^-1b^-1逆置得到ba。

void Reverse(int R[],int from,int to){    int i,temp;    for(i=0;i<(to-from+1)/2;i++){        temp=R[from+1];        R[from+i]=R[to-i];        R[to-i]=temp;    }}void Converse(int R[],int n,int p){    Reverse(R,0,p-1);				//时间复杂度：O(p/2)    Reverse(R,p,n-1);				//时间复杂度：O(n-p/2)    Reverse(R,0,n-1);				//时间复杂度：O(n/2)}//时间复杂度：O(n) 空间复杂度(1)

找出两个升序序列的中位数

***思路：***分别求两个升序序列A,B的中位数，设为a和b。若a=b，则a或b为所求中位数；若a<b，则舍弃A中较小的一半，同时舍弃B中较大的一半，要求两次舍弃的长度相等；若a>b，则舍弃A中较大的一半，同时舍弃B中较小的一半，要求舍弃的长度相等。重复以上过程，知道两个序列中均只含一个元素为止，较小者即为所求。

int M_Serach(int A[], int B[], int n){    int s1=0,d1=n-1,m1,s2=0,d2=n-1,m2; 		//分别表示A B的首位数、末位数和中位数    while(s1!=d1||s2!=d2){        m1=(s1+d1)/2;        m2=(s2+d2)/2;        if(A[m1]==B[m2])            return A[m1];					//a=b的情况        if(A[m1]<B[m2]){					//a<b的情况            if((s1+d1)&2==0){				//元素个数为奇数                s1=m1;                d2=m2;            }            else{							//元素个数为偶数,舍弃中间点及中间点之前的部分                s1=m1+1;                d2=m2;            }        }        else{            if((s2+d2)%2==0){				//元素个数为奇数                d1=m1;                s2=m2            }            else{							//元素个数为偶数                d1=m1;                s2=m2+1            }        }    }    return A[s1]<B[s2]?A[s1]:B[s2];}//时间复杂度log以2为底的n次，空间复杂度O(1)

在一个整数序列中存在多个相同的数，记为m，若m>n/2，则称m为A的主元素。设计一个算法找出A的主元素，若存在m，则输出；若不存在，则返回-1。

***思路：***将第一个遇到的整数Num保存到c中，记录Num出现次数为1，若遇到下一个整数仍等于Num，则计数加一，否则计数减一。当计数为0时，将遇到的下一个整数保存到c中，计数重新记为1，开始新一轮计数。判断c中元素是否是真正的主元素。再次扫描该数组，统计c出现的次数，若大于n/2，则为所求，否则，不存在主元素。

int Majority(int A[],int n){    int i,c,count=1;			//c用来保存候选主元素，count用来计数    c=A[0];    for(i=1;i<n;i++){        if(A[i]==c)            count++;        else{            if(count>0)            	count--;            else{                c=A[i];                count=1;            }        }       }    if(count>0){			        for(i=count=0;i<n;i++){            if(A[i]==c)                count++;		//统计候选主元素的实际出现次数        }    }    if(count>n/2)        return c;    else        return -1;}//时间复杂度O(n),空间复杂度O(1)

给定一个含n个整数的数组，找出数组中未出现的最小正整数。

***思路：***分配一个用于标记的数组B，循环A数组，对A中符合条件的数(0<x<=n)存入到数组B对应下标减一(因为数组下标从0开始)的位置。循环B数组，找到值为0的下标，返回下标加一即为结果。

int findMissMin(int A[],int n){    int i,*B;    B=(int *)malloc(sizeof(int)*n);    memset(B,0,sizeof(int)*n);    for(i=0;i<n;i++){        if(A[i]>0&&A[i]<=n)            B[A[i]-1]=1;    }    for(i=0;i<n;i++){        if(B[i]==0)            break;    }    return i+1;}

单链表

**单链表：**线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。每一个链表结点，除存放元素自身的信息外，还需要存放一个指向其后继的指针。

data	next

**双链表：**双链表结点中有两个指针prior和next，分别指向其前驱结点和后继结点。按值查找和按位查找的操作与单链表相同，插入删除操作时间复杂度仅为O(1)。

**循环单链表：**表中最后一个结点的指针不是NULL，而是指向头结点，从而整个链表形成一个环。可以从表中任意一个结点开始遍历整个链表。

**循环双链表：**头结点的prior指针指向表尾结点。

**静态链表：**静态链表借助数组来描述线性表的链式存储结构。结点也有数据域data和指针域next。这里的指针是指数组下标，与顺序表一样，静态链表也需要预先分配一块连续的内存空间。静态链表的插入删除操作与动态链表的相同，只需修改指针，而不需要移动元素。

一刻不学习就是15分钟

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
1
评论
数据结构-------线性表

第二章线性表课后习题一从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删除的元素的值，空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行。**思路：**搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填补到空出的位置bool Del_Min(sqList &L, ElemType &value){ if(L.length == 0){ return false; } value = L.da
复制链接

扫一扫