18版考研数据结构天勤课后习题代码-线性表【完】

#include <iostream>
using namespace std;
#define maxSize 101
//顺序表插入元素 天勤P26 例2-1
/*
 typedef struct Sqlist
 {
 int data[maxSize];
 int length;
 };
 void insert(Sqlist &s,int x)
 {
 int cnt=0;
 for(int i=0;i<s.length;i++)
 {
 if(s.data[i]>x)
 {
 cnt=i;
 break;
 }
 }
 for(int i=s.length-1;i>=cnt;i--)  //!易错点处，一定要从后往前，从前往后会导致元素覆盖
 {
 s.data[i+1]=s.data[i];
 }
 s.data[cnt]=x;
 s.length++;
 }
 int main() {
 // std::cout << "Hello, World!" << std::endl;
 Sqlist s;
 s.length=0;
 for(int i=0;i<10;i++)
 {
 s.data[i]=i;
 s.length++;
 }
 //cout<<s.length<<endl;
 insert(s,5);
 // cout<<s.length<<endl;
 for(int i=0;i<s.length;i++)
 cout<<s.data[i]<<endl;
 return 0;
 }
 */

/*
 //删除线性表中下标为P的元素 天勤P28 例2-2
 typedef struct Sqlist
 {
 int data[maxSize];
 int length;
 }Sqlist;
 //引用型
 //int Delete(Sqlist &s,int &e,int p)
 //{
 //    if(p<0||p>s.length-1)
 //   {
 //        return 0;
 //   }
 //    e=s.data[p];
 //    for(int i=p+1;i<s.length;i++)
 //    {
 //        s.data[i-1]=s.data[i];
 //    }
 //    s.length--;
 //    return 1;
 //
 //}
 //int main()
 //{
 //    Sqlist s;
 //    s.length=0;
 //    for(int i=0;i<10;i++)
 //    {
 //        s.data[i]=i;
 //        s.length++;
 //    }
 //    int d;
 //    Delete(s,d,5);
 //    cout<<d<<endl;
 //    for(int i=0;i<s.length;i++)
 //    {
 //        cout<<s.data[i]<<endl;
 //    }
 //}
 
 //指针型
 int Delete(Sqlist *&s,int &e,int p)
 {
 if(p<0||p>s->length-1)
 {
 return 0;
 }
 e=s->data[p];
 for(int i=p+1;i<s->length;i++)
 {
 s->data[i-1]=s->data[i];
 }
 s->length--;
 return 1;
 
 }
 int main()
 {
 Sqlist *s=(Sqlist*)malloc(sizeof(Sqlist));
 s->length=0;
 for(int i=0;i<10;i++)
 {
 s->data[i]=i;
 s->length++;
 }
 int d;
 Delete(s,d,5);
 cout<<d<<endl;
 for(int i=0;i<s->length;i++)
 {
 cout<<s->data[i]<<endl;
 }
 }
 */

//合并两个有序的表 天勤P29 例2-3
/*
 //顺序表
 /*
 typedef struct Sqlist
 {
 int data[maxSize];
 int length;
 };
 void merge(Sqlist &a,Sqlist &b,Sqlist &c)
 {
 int len1=a.length;
 int len2=b.length;
 int i=0,j=0,k=0;
 while(i<len1&&j<len2)
 {
 while(i<len1&&j<len2&&a.data[i]<=b.data[j])  //i<len1&&j<len2一定要写上！！！
 {
 c.data[k++]=a.data[i];
 i++;
 }
 while(i<len1&&j<len2&&b.data[j]<=a.data[i])
 {
 c.data[k++]=b.data[j];
 j++;
 }
 }
 while(i<len1)
 {
 c.data[k++]=a.data[i];
 i++;
 }
 while(j<len2)
 {
 c.data[k++]=b.data[j];
 j++;
 }
 c.length=k;
 }
 int main()
 {
 Sqlist a,b,c;
 a.length=5;
 b.length=9;
 for(int i=0;i<5;i++)
 cin>>a.data[i];
 for(int j=0;j<9;j++)
 cin>>b.data[j];
 merge(a,b,c);
 for(int i=0;i<c.length;i++)
 {
 cout<<c.data[i]<<endl;
 }
 }
 //测试用例
 2 5 7 9 11
 2 3 4 5 7 11 13 14 16
 
 
 //链表
 typedef struct LNode
 {
 int data;
 struct LNode* next;
 }LNode;
 void merge(LNode *a,LNode *b,LNode *&c)
 {
 LNode *p=a->next;
 LNode *q=b->next;
 c=a;
 //c->next=NULL;
 LNode *r=c;
 while(p!=NULL&&q!=NULL)
 {
 while(p!=NULL&&q!=NULL&&p->data<=q->data)
 {
 r->next=p;
 p=p->next;
 r=r->next;
 }
 while(p!=NULL&&q!=NULL&&q->data<=p->data)
 {
 r->next=q;
 q=q->next;
 r=r->next;
 }
 }
 r->next=NULL;
 while(p!=NULL)
 {
 r->next=p;
 p=p->next;
 r=r->next;
 }
 while(q!=NULL)
 {
 r->next=q;
 q=q->next;
 r=r->next;
 }
 }
 int main()
 {
 LNode *a=(LNode*)malloc(sizeof(LNode));
 a->next=NULL;
 LNode *p=a;
 LNode *b=(LNode*)malloc(sizeof(LNode));
 b->next=NULL;
 LNode *q=b;
 for(int i=0;i<5;i++)
 {
 LNode *k=(LNode*)malloc(sizeof(LNode));
 k->data=i;
 k->next=NULL;
 p->next=k;
 p=k;
 }
 for(int i=0;i<9;i++)
 {
 LNode *k=(LNode*)malloc(sizeof(LNode));
 k->data=i;
 k->next=NULL;
 q->next=k;
 q=k;
 }
 //    while(b->next!=NULL)
 //    {
 //        cout<<b->next->data;
 //        b=b->next;
 //    }
 LNode *c=(LNode*)malloc(sizeof(LNode));
 c->next=NULL;
 merge(a,b,c);
 LNode *s=c->next;
 while(s!=NULL)
 {
 cout<<s->data<<endl;
 s=s->next;
 }
 }
 
 */

/*
 //删除链表中值为x的节点  天勤P32 例2-4
 typedef struct LNode
 {
 int data;
 struct LNode* next;
 }LNode;
 int Delete(LNode *&s,int x)
 {
 LNode *pre=s;
 LNode *p=s->next;
 int flag=0;
 while(p!=NULL)
 {
 if(p->data==x)
 {
 flag=1;
 pre->next=p->next;
 p=pre->next;
 }
 else {
 p = p->next;
 pre = pre->next;
 }
 }
 if(flag==0)
 return 0;
 else
 return 1;
 }
 int main()
 {
 LNode *a=(LNode*)malloc(sizeof(LNode));
 a->next=NULL;
 LNode *p=a;
 for(int i=0;i<5;i++)
 {
 LNode *k=(LNode*)malloc(sizeof(LNode));
 cin>>k->data;
 k->next=NULL;
 p->next=k;
 p=k;
 }
 int d=Delete(a,3);
 while(a->next!=NULL)
 {
 cout<<a->next->data;
 a=a->next;
 }
 }
 */

/*
 //求两个有序单链表的差值  天勤P35 真题仿造 2
 typedef struct LNode
 {
 int data;
 struct LNode* next;
 }LNode;
 void Difference(LNode *&a,LNode *b)
 {
 LNode *p=a->next;
 LNode *q=b->next;
 LNode *r=a;
 while(p!=NULL&&q!=NULL)
 {
 while(p->data<q->data)
 {
 p=p->next;
 r=r->next;
 }
 while(q->data<p->data)
 {
 q=q->next;
 }
 if(p->data==q->data)
 {
 r->next=p->next;
 p=p->next;
 q=q->next;
 }
 }
 }
 int main()
 {
 LNode *a=(LNode*)malloc(sizeof(LNode));
 LNode *p=a;
 for(int i=0;i<5;i++)
 {
 LNode *k=(LNode*)malloc(sizeof(LNode));
 cin>>k->data;
 k->next=NULL;
 p->next=k;
 p=k;
 }
 LNode *b=(LNode*)malloc(sizeof(LNode));
 b->next=NULL;
 LNode *q=b;
 for(int i=0;i<9;i++)
 {
 LNode *k=(LNode*)malloc(sizeof(LNode));
 cin>>k->data;
 k->next=NULL;
 q->next=k;
 q=k;
 }
 Difference(a,b);
 while(a->next!=NULL)
 {
 cout<<a->next->data<<endl;
 a=a->next;
 }
 
 }
 //2 4 5 7 8
 //4 6 7 8 10 11 12 13 17
 */

/*
 //将顺序表中所有元素逆置  天勤P40 （二）1.（3）
 typedef struct Sqlist
 {
 int data[9];
 int length;
 };
 void Reverse(Sqlist &s)
 {
 int i=0,j=s.length-1;
 while(i!=j)
 {
 int t=s.data[i];
 s.data[i]=s.data[j];
 s.data[j]=t;
 i++;
 j--;
 }
 }
 int main()
 {
 Sqlist s;
 for(int i=0;i<9;i++)
 {
 cin>>s.data[i];
 }
 Reverse(s);
 for(int i=0;i<9;i++)
 {
 cout<<s.data[i]<<endl;
 }
 }
 */

/*
 //将所有小于表头元素的整数放前半部分  天勤P40 （二）1.（5）
 typedef struct Sqlist
 {
 int data[10];
 int length;
 }Sqlist;
 void sort(Sqlist &s)
 {
 int t=s.data[0];
 int i=0,j=s.length-1;
 while(i<j)   //一定要以基准元素作为交换
 {
 while(i<j&&s.data[j]>t)
 {
 j--;
 }
 if(i<j)  //while循环中要严格控制好循环条件
 {
 s.data[i]=s.data[j];
 }
 while(i<j&&s.data[i]<t)
 {
 i++;
 }
 if(i<j)
 {
 s.data[j]=s.data[i];
 }
 }
 s.data[i]=t;
 }
 
 
 int main()
 {
 Sqlist s;
 for(int i=0;i<10;i++)
 {
 cin>>s.data[i];
 }
 s.length=10;  //s.length一定要记得初始化！！！
 sort(s);
 for(int i=0;i<10;i++)
 {
 cout<<s.data[i]<<endl;
 }
 }
 
 //5 2 8 1 9 2 4 2 10 11
 
 //2
 //2
 //4
 //1
 //2
 //5
 //9
 //8
 //10
 //11
 */

/*
 //将所有小于表头元素的整数放前半部分  天勤P40 （二）1.（6）
 typedef struct LNode
 {
 int data;
 struct LNode *next;
 }LNode;
 void Delete(LNode *&s)
 {
 LNode *p=s->next;
 LNode *q=p->next;
 while(q!=NULL)
 {
 if(q->data==p->data)
 {
 p->next=q->next;
 }
 p=p->next;
 q=p->next;
 }
 }
 int main()
 {
 LNode *a=(LNode*)malloc(sizeof(LNode));
 a->next=NULL;
 LNode *p=a;
 for(int i=0;i<5;i++)
 {
 LNode *k=(LNode*)malloc(sizeof(LNode));
 cin>>k->data;
 k->next=NULL;
 p->next=k;
 p=k;
 }
 Delete(a);
 while(a->next!=NULL)
 {
 cout<<a->next->data;
 a=a->next;
 }
 }
 */

/*
 //删除单链表最小值  天勤P40 （二）1.（7）
 typedef struct LNode
 {
 int data;
 struct LNode *next;
 }LNode;
 void DeleteMin(LNode *s)
 {
 LNode *p=s->next;
 LNode *q=s->next;
 int min=p->data;
 while(p!=NULL)
 {
 if(p->data<min)
 {
 min=p->data;
 }
 p=p->next;
 }
 LNode *pre=s;
 while(q!=NULL)
 {
 if(q->data==min)
 {
 pre->next=q->next;
 break;
 }
 q=q->next;
 pre=pre->next;
 }
 }
 int main()
 {
 LNode *a=(LNode*)malloc(sizeof(LNode));
 a->next=NULL;
 LNode *p=a;
 for(int i=0;i<5;i++)
 {
 LNode *k=(LNode*)malloc(sizeof(LNode));
 cin>>k->data;
 k->next=NULL;
 p->next=k;
 p=k;
 }
 DeleteMin(a);
 while(a->next!=NULL)
 {
 cout<<a->next->data<<endl;
 a=a->next;
 
 }
 }
 */

/*
 //单链表逆置  天勤P40 （二）1.（8）
 typedef struct LNode
 {
 int data;
 struct LNode *next;
 }LNode;
 void inverse(LNode *&s)
{
    LNode *p=s->next->next;
    LNode *r=s;
    LNode *q=s->next;
    q->next=NULL;
    while(p!=NULL)
    {
        LNode *x=p->next;
        p->next=q;
        r->next=p;
        q=p;
        p=x;
    }
}
int main()
{
    LNode *a=(LNode*)malloc(sizeof(LNode));
    a->next=NULL;
    LNode *p=a;
    for(int i=0;i<9;i++)
    {
        LNode *k=(LNode*)malloc(sizeof(LNode));
        cin>>k->data;
        k->next=NULL;
        p->next=k;
        p=k;
    }
    inverse(a);
    while(a->next!=NULL)
    {
        cout<<a->next->data<<endl;
        a=a->next;
    }
}
*/

/*
//单链表拆分 天勤P40 （二）1.（9）
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode;
void Splite(LNode *&a,LNode *&b)
{
    LNode *p=a->next;
    LNode *pre=a;
    LNode *q=b;
    while(p!=NULL)
    {
        int t=p->data;
        if(p!=NULL&&t%2==1)  //注意p！=NULL这个条件，否则和else搭配会把最后一个节点删除
        {
            pre=pre->next;
            p=pre->next;
        }
        else if(p!=NULL&&t%2==0)
        {
           pre->next=p->next;
            p->next=NULL;
            q->next=p;
            q=q->next;
            p=pre->next;   //此时pre不需要移动！！！易错点！！
        }
    }
}
int main()
{
    LNode *a=(LNode*)malloc(sizeof(LNode));
    a->next=NULL;
    LNode *p=a;
    for(int i=0;i<9;i++)
    {
        LNode *k=(LNode*)malloc(sizeof(LNode));
        cin>>k->data;
        k->next=NULL;
        p->next=k;
        p=k;
    }
    LNode *b=(LNode*)malloc(sizeof(LNode));
    b->next=NULL;
    Splite(a,b);
    while(a->next!=NULL)
    {
        cout<<a->next->data<<" ";
        a=a->next;
        
    }
    cout<<endl;
        while(b->next!=NULL)
        {
            cout<<b->next->data<<" ";
            b=b->next;
    
        }
}

//5 2 8 1 9 2 4 2 10 11
 */

/*
//找最小值 天勤P40 （二）2.（1）
int findMin(int a[],int n)
{
    int i=0;
    a[0]=a[0]+a[0]*10;
    for(i=1;i<n;i++)
    {
        if(a[i]%10<a[i-1]/10)
        {
            a[i]=a[i]+a[i]*10;
        }
        else
        {
            a[i]=a[i]+(a[i-1]/10)*10;   //使用十进制位储存最小值。这个地方a[i-1]记得除以10
        }
       // cout<<a[i]<<endl;
    }
    return a[n-1]/10;
}
int main()
{
    int n,a[101];
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    cout<<findMin(a,n);
}

//6
//9 3 2 1 4 6
 */

/*
//逆序打印单链表数据 天勤P40 （二）2.（2）
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode;
void inversePrint(LNode *L)
{
    LNode *p=L->next;
    int stack[maxSize];
    int top=-1;
    while(p!=NULL)
    {
        stack[++top]=p->data;   //用栈暂时存储
        p=p->next;
    }
    while(top!=-1)
    {
        cout<<stack[top]<<endl;
        top--;                      //一定不能忘记指针移动，while循环中一要控制好循环结束条件，而要不要忘记指针移动
    }
}
int main()
{
    LNode *a=(LNode*)malloc(sizeof(LNode));
    a->next=NULL;
    LNode *p=a;
    for(int i=0;i<9;i++)
    {
        LNode *k=(LNode*)malloc(sizeof(LNode));
        cin>>k->data;
        k->next=NULL;
        p->next=k;
        p=k;
    }
    inversePrint(a);
}

//9 3 2 1 4 6 2 1 9
*/

/*
//找最大值最小值 天勤P40 （二）2.（2）
void Search(int a[],int n,int &min,int &max)
{
    min=a[0];
    max=a[0];
    for (int i=1;i<n;i++)
    {
        if(a[i]<min)
        {
            min=a[i];
        }
        else if(a[i]>max)
        {
            max=a[i];
        }
    }
}
int main()
{
    int n,a[101];
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    int min,max;
    Search(a, n, min, max);
    cout<<min<<" "<<max<<endl;
}
//
 9
 9 3 2 1 4 6 2 1 9
*/

/*
//比较两个集合的大小 天勤P40 （二）2.（2）
typedef struct Sqlist
{
    int data[maxSize];
    int length;
}Sqlist;
int Compare(Sqlist a,Sqlist b)
{
    int k=0,i=0,len1=a.length,len2=b.length;
    while(i<len1&&i<len2)
    {
        if(a.data[i]==b.data[i])
        {
            i++;
            k++;
        }
        else if(a.data[i]!=b.data[i])
        {
            break;
        }
    }
    cout<<k<<endl;
    if(k==len1&&k==len2)
    {
        return 0;
    }
    else if((k==len1&&k!=len2)||(k!=len1&&k!=len2&&a.data[k]<b.data[k]))
    {
        return -1;
    }
    else
        return 1;
}
int main()
{
    Sqlist s1;
    for(int i=0;i<9;i++)
    {
        cin>>s1.data[i];
    }
    s1.length=9;  //s.length一定要记得初始化！！！
    Sqlist s2;
    for(int i=0;i<10;i++)
    {
        cin>>s2.data[i];
    }
    s2.length=10;  //s.length一定要记得初始化！！！
    int d=Compare(s1,s2);
    cout<<d<<endl;
}
//
 4 6 2 1 9 3 2 1 4
 4 6 2 1 9 4 2 1 3 3
 */

/*
 //找k 天勤P41 （二）1
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode;
int Search(LNode *head,int k,int &d)
{
    LNode *p=head;
    LNode *q=head;
    int i=0;
    while(p->next!=NULL)
    {
        i++;
        p=p->next;
        if(i==k-1)   //记得跳出去！！
            break;
    }
    if(i<k-1)
    {
        return 0;
    }
    while(p->next!=NULL)
    {
        q=q->next;
        p=p->next;
    }
    d=q->data;
    return 1;
}
int main()
{
    LNode *a=(LNode*)malloc(sizeof(LNode));
    a->next=NULL;
    LNode *p=a;
    for(int i=0;i<9;i++)
    {
        LNode *k=(LNode*)malloc(sizeof(LNode));
        cin>>k->data;
        k->next=NULL;
        p->next=k;
        p=k;
    }
    int h,d;
    cin>>h;
    int t=Search(a,h,d);
    if(t==1)
    {
        cout<<d<<endl;
    }
    else
    {
        cout<<0<<endl;
    }
}

//4 6 2 1 9 3 2 1 4
//4
*/

/*
//循环左移 天勤P41 （二）2
void Reverse(int a[],int n1,int n2)
{
    int i=n1,j=n2;
    while(i<j)
    {
        int t=a[i];
        a[i]=a[j];
        a[j]=t;
        i++;
        j--;
    }
}
int main()
{
    int a[101];
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    int p;
    cin>>p;
    Reverse(a,0,p-1);
    Reverse(a,p,n-1);
    Reverse(a,0,n-1);
    for(int i=0;i<n;i++)
        cout<<a[i]<<endl;
}
*/

/*
//找主元素（元素出现次数>n/2) 天勤P41 （二）3
int FindMain(int a[],int n)
{
    int min=a[0],max=a[0];
    for(int i=1;i<n;i++)
    {
        if(a[i]>max)
        {
            max=a[i];
        }
        else if(a[i]<min)
        {
            min=a[i];
        }
    }
    int count[n];
    for(int i=0;i<n;i++)
    {
        count[i]=0;
    }
    for(int i=0;i<n;i++)
    {
        count[a[i]]++;
    }
    for(int i=min;i<=max;i++)
    {
       // cout<<count[a[i]]<<endl;
        if(count[a[i]]>n/2)
        {
            return a[i];
        }
    }
    return -1;
}
int main()
{
    int n,a[101];
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    int d=FindMain(a,n);
    cout<<d<<endl;
}

//8
//0 5 5 3 5 1 5 7

//0 5 5 3 5 7 5 5
*/