数据结构中的顺序表（线性表）的题

 由于时间的关系，只有部分做了调试，大家可以根据题目去搜答案。

 

 

#include<stdio.h> 
#include<math.h>
#define  MaxSize 50
typedef struct{
    int data[MaxSize];//顺序表中的元素空间 
    int length;//长度    
}Sqlist;//静态分配方式 

//顺序表的初始化
Sqlist L;
Sqlist L1;
Sqlist L2;
Sqlist L3;
void InitSqlist(Sqlist &L);
bool InsertData(Sqlist &L,int i,int e);
bool DeletData(Sqlist &L,int i,int e);
int FindSqlist(Sqlist &L,int e);
int DeletMinData(Sqlist &L);
void DaoZhiSqlist(Sqlist &L);
int DelelX(Sqlist &L,int e);
int deleyXY(Sqlist &L,int X,int Y);
int ComData(Sqlist &L);
bool HeBingSqlist(Sqlist A,Sqlist B,Sqlist C);
bool ChangeList(int *Arr,Sqlist A,Sqlist B);
void Reverse(int *A,int Left,int Right,int ArraySize);
void Exchange(int *A,int Left,int Right,int ArraySize);
void FindX(Sqlist L,int e);
int Max(int A,int B,int C); 
void ComSqlist(Sqlist &A,Sqlist &B,Sqlist &C,int n);
void MoveSqlist(Sqlist &A,int P); 
int MidNum(Sqlist &A,Sqlist &B,Sqlist &C);
int FindMinData(Sqlist &A);
int main(){
    int DataTemp = 0; 
    InitSqlist(L);
    InitSqlist(L1);
    InitSqlist(L2);
    InitSqlist(L3);
    
    //给顺序表中添加元素 
/*    for(int i=0;i<8;i++){
        printf("请往静态分配的方式链表中输入数值\n");
        scanf("%d",&DataTemp); 
        L.data[i]=DataTemp;
        L.length++;
    }
*/
        for(int i=0;i<8;i++){
        printf("请往L1静态分配的方式链表中输入数值\n");
        scanf("%d",&DataTemp); 
        L1.data[i]=DataTemp;
        L1.length++;
    }
    for(int i=0;i<8;i++){
        printf("请往L2静态分配的方式链表中输入数值\n");
        scanf("%d",&DataTemp); 
        L2.data[i]=DataTemp;
        L2.length++;
    }
    
    HeBingSqlist(L1,L2,L3);
    printf("%d\n\n",L3.length);
    for(int i=0;i<L3.length;i++){
        printf("L3的值为：%d\n",L3.data[i]);
    }

}
//fun:初始化头结点 
//brief:@顺序表
//return:NULL 
void InitSqlist(Sqlist &L){
    L.length = 0;
} 

//fun:在顺序表中插入一个数值 
//brief:@顺序表@位置@数值 
//return:true/false 
bool InsertData(Sqlist &L,int i,int e){
    //输入的值在链表之外 
    if(i<1||i>L.length){
        return false;
    }
    //存储空间以满 
    if(L.length>MaxSize){
        return false;
    }
    //依次把i到 L.length的值往后移动一个数值 
    for(int j=L.length;j>=i;j--){
        L.data[j]=L.data[j-1];
    }
    L.data[i-1]=e;
    L.length+=1;
    return true;
}

//fun:删除顺序表中的一个数值 
//brief:@顺序表@位置@数值
//return::true/fals 
bool DeletData(Sqlist &L,int i,int e){
    if(i<0||i>L.length){
        return false;
    }
    for(int j=i;j<L.length;j++){
        L.data[j-1]=L.data[j];
    }
    L.length--;
    return true;
} 

//fun:寻找顺序表中的一个数值 
//brief:@顺序表@数值
//return：数的位置  
int FindSqlist(Sqlist &L,int e){
    if(L.length==0){
        //空表 
        return 0;
    }
    for(int i=0;i<L.length;i++){
        if(L.data[i]==e)
        {
            return i+1;
        } 
    } 
    return 0;
}
//fun:如果顺序表为空就返回NULL,有数值就返回最小值 ,最小值的位置就有最后一个值来填补 
//brief:@顺序表
//return：最小值 
int DeletMinData(Sqlist &L) {
    if(L.length<=0){
        printf("Sqlist is NULL\n");
        return NULL;
    } 
    int i = 0 ;
    int Pos = 0;
    int TempValue = L.data[0];
    for(i;i<L.length;i++){
        if(TempValue>=L.data[i]){
            TempValue=L.data[i];
            Pos=i;
        }
    }
    L.data[Pos]=L.data[L.length-1];
    L.length--;
    return TempValue;
}

void DaoZhiSqlist(Sqlist &L){
    int DataTemp = 0;
    for(int i = 0;i<L.length/2;i++){
        DataTemp=L.data[L.length-1-i];
        L.data[L.length-1-i]=L.data[i];
        L.data[i]=DataTemp;
    }
    printf("\n\n\n");
    for(int j=0;j<L.length;j++){
        printf("%d\n",L.data[j]);
    }
}
//fun:在顺序表中删除一个e的元素 
//brief:@顺序表@要删除的元素 
//return:有多少个x的元素 
int DelelX(Sqlist &L,int e){
    int k=0;
    for(int i = 0;i<L.length;i++){
        if(L.data[i]!=e){
            L.data[k]=L.data[i];
            k++;
        }
    }
    return L.length-k;
}
//fun:删除一个链表猴子那个XY之间的数 
int deleyXY(Sqlist &L,int X,int Y){
    if(L.length=0||(X>=Y)){
        return 0;
    }
        
    int k=0;
    for(int i=0;i<L.length;i++){
        printf("dfafdasdd\n");
        if(L.data[i]>=Y||L.data[i]<=X){
            L.data[k]=L.data[i];
            k++;
        }
    }
    for(int j=0;j<L.length;j++){
        printf("%d\n",L.data[j]);
    }
    L.length=k;
    return k;
}

//fun:删除链表中相同的元素
//brief:@链表
//return:相同元素的个数
int ComData(Sqlist &L){
    int TempData=0;
    if(L.length<=0)
        return 0;
    for(int i=0;i<L.length;i++){
        TempData=L.data[i];
        int k=0;
        for(int j=0;j<L.length;j++){
            if(TempData!=L.data[j]){
                L.data[k]=L.data[j];
                k++;
            }
        }
        L.length = k;
    }
    
    printf("\n\n\n");
    for(int m=0;m<L.length;m++){
        printf("%d\n",L.data[m]);
    }
    printf("\n\n\n");
    return L.length;
} 

//fun:将两个顺序表合并成一个新的顺序表
//brief:@顺序表@顺序表
//return:新顺序表
bool HeBingSqlist(Sqlist A,Sqlist B,Sqlist C){
     if(A.length+B.length>MaxSize){
         return false;
     }
     int i=0,j=0,k=0;
     for(i,j,k;i<A.length&&j<B.length;){
         if(A.data[i]<B.data[j]){
             C.data[k++]=A.data[i++];
         }
        else if(A.data[i]>B.data[j]){
            C.data[k++]=A.data[j++];
        }
        printf("ahfahfkajhfka\n");
     }
     while(i<A.length) {
         C.data[k++]=A.data[i++];
     }
     while(j<A.length) {
         C.data[k++]=B.data[j++];
     }
     return true;
     
} 
//fun:将连个链表中的数据存入数组后然后将两个链表数据元素交换位置 
//brief:@数组@链表@链表 
//return:true/false 
bool ChangeList(int *Arr,Sqlist A,Sqlist B){
    //pandu
    if(A.length<1||B.length<1){
        return false;
    }
    int k=0;
    int TempData = 0; 
    for(int i=0;i<A.length;i++){
        Arr[k++]=A.data[i];
    }
    for(int j=0;j<A.length;j++){
        Arr[k++]=A.data[j];
    }
    
    if(A.length<=B.length){
        for(int i=0;i<A.length;i++){
            TempData=Arr[i];
            Arr[i]=Arr[A.length+B.length-i-1];
            Arr[A.length+B.length-i-1]=TempData;
        }
        
    }
    else if(A.length>=B.length){
        for(int i=0;i<B.length;i++){
            TempData=Arr[i];
            Arr[i]=Arr[A.length+B.length-i-1];
            Arr[A.length+B.length-i-1]=TempData;
        }
    }
}
//fun:交换数组中的位置 
//brief:@数组@左边位置@右边位置@数组的最大长度 
//return:NULL
void Reverse(int *A,int Left,int Right,int ArraySize){
    int TempData;
    if(Left>=Right||Right<=ArraySize)
    return;
    int mid=(Left+Right)/2;
    for(int i=0;i<=mid;i++){
        TempData=A[i];
        A[i]=A[Right-i];
        A[Right-i]=TempData;
    }
}
//fun:调用Reverse 
//brief:@数组@左边位置@右边位置@数组的最大长度 
//return:NULL
void Exchange(int *A,int Left,int Right,int ArraySize){
    Reverse(A,0,Left+Right-1,ArraySize); 
    Reverse(A,0,Left-1,ArraySize);
        Reverse(A,Left,Left+Right-1,ArraySize);
}
//fun:查找递增链表中的一个特定元素，没有 就插入 
//brief:@链表@特定值 
//return:NULL
void FindX(Sqlist L,int e){
    int mid=L.length/2;
    int TempData = 0;
    if(L.length<1)
        return;
    if(L.data[mid]>=e){
        for(int i=0;i<=mid;i++){
            if(L.data[i]==e){
                TempData=L.data[i];
                L.data[i]=L.data[i+1];
                TempData=L.data[i+1];
            }
            else if(L.data[i]<e&&L.data[i+1]>e){
                for(int j=0;j<L.length-i;j++){
                    L.data[L.length-1-j]=L.data[L.length-j];
                }
                L.data[i]=e;
                
            }
                
        }
    }
    if(L.data[mid]<=e){
        for(int i=mid;i<L.length;i++){
            if(L.data[i]==e){
                TempData=L.data[i];
                L.data[i]=L.data[i+1];
                TempData=L.data[i+1];
            }
            else if(L.data[i]<e&&L.data[i+1]>e){
                for(int j=0;j<L.length-i;j++){
                    L.data[L.length-1-j]=L.data[L.length-j];
                }
                L.data[i]=e;

            }    
        }
    }
}
//fun:三个数比较
//brief:@int@int@int
//return :最大整数 
int Max(int A,int B,int C){
    if(A>B){
        if(A>C)
            return A;
        if(C>A)    
            return C;
    }
    if(B>C){
        if(A>B)
            return A;
        if(B>A)
            return B;
    }
    if(A>C){
        if(A>B)
            return A;
        if(B>A)
            return B;
    } 
}
//fun三个链表中找出相同的值 
//brief:@链表 @链表@链表@链表的个数 
//
void ComSqlist(Sqlist &A,Sqlist &B,Sqlist &C,int n){
    int i=0;int j=0;int k=0;
    while(i<n&&j<n&&k<n){
        if(A.data[i]==B.data[j]==C.data[k]){
            printf("%d\n",A.data[i]);
            i++;
            j++;
            k++;
        }
        else{
            int MaxNum=Max(A.data[i],B.data[j],C.data[k]);
            if(MaxNum>A.data[i])
                i++;
            if(MaxNum>B.data[j])
                j++;
            if(MaxNum>C.data[j])
                k++;
        } 
    }
}
//fun：将一个连表中的数值依次向左移动p个单位
//brief:@链表@P
//return :NULL 
void MoveSqlist(Sqlist &A,int P) {
    int TempData=0;
    if(P>A.length||P<0)
        return;
    //需要移动的次数 
    for(int i=0;i<P;i++){
        //将第一个数值放入TempData 
        TempData = A.data[0];
        //第一个数值后面的数值依次往前移动 
        for(int j=0;j<A.length;j++){
            A.data[i]=A.data[i+1];
        }
        //将TempData中数值放入最后一个数值数值的位置 
        A.data[A.length-1]=TempData;
    }
}

//fun:找出两个链表的中位数
// brief:@数组@数组
//return :中位数
int MidNum(Sqlist &A,Sqlist &B,Sqlist &C){
    int i=0,j=0,k=0;
    int MidData=0;
    while(i<A.length&&j<B.length){
        if(A.data[i]<B.data[j]){
            C.data[k++]=B.data[j];
            j++;
        }
        else{
            C.data[k++]=B.data[i];
            i++;    
        }
    }
    while(i<A.length){
        C.data[k++]=B.data[i];
        i++;
    }
    while(j<A.length){
        C.data[k++]=B.data[j];
        j++;
    }
    //c的数字已经排列好，直接取出中间的数就可
    return C.data[C.data[j/2]];    
} 

//fun:找出一个链表中的未出现的整数
//brief:@链表
//return:最小整数
int FindMinData(Sqlist &A){
    int TempData=A.data[0];
    for(int i=0;i<A.length;i++){
        if(A.data[i]<TempData){
            TempData=A.data[i];
        }
    }
    return TempData-1;
    /*使用空间 换时间的方法
         int MinData(int A[],int n){
             int i,*B;
             B=(int *)malloc(sizeof(int)*n);
             meset(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;
                 }
            retutn i+1;
             }
         } 
    */
}