数据结构习题代码

设计一个带头结点的单链表中删除一个最大值结点的算法。

//设计一个带头结点的单链表中删除一个最大值结点的算法。
#include <iostream>
#include <bits/stdc++.h>
#define test cout<<"****"<<endl;
using namespace std;
typedef struct Node{
  int val;
  struct Node *next;
}Node;
int Max=0;
Node *head=(Node*)malloc(sizeof(Node));

void getlist(int n){
    Node *p=(Node*)malloc(sizeof(Node));
    p=head;
  for(int i=0;i<n;i++){
      Node *q=(Node*)malloc(sizeof(Node));
      cin>>q->val;
      p->next=q;
      q->next=NULL;
      p=q;
  }
}

void Delete(Node *head){
    struct Node *p,*max;
    int tmp;
    p=head;
    tmp=p->val;
    max=head;
    while(p->next!=NULL){
        p=p->next;
        if(p->val>tmp){
            max=p;
            tmp=p->val;
        }
    }
    if(max->next!=NULL){
        tmp=max->next->val;
        max->val=tmp;
        max->next=max->next->next;
    }else{
        Node *k=(Node*)malloc(sizeof(Node));
        k=head;
        while(k->next!=NULL){
            if(k->next==max){
                break;
            }
            k=k->next;
        }
        k->next=NULL;
    }
}
void output(){
    struct Node *p;
    p=head;
    while(p->next!=NULL){
        p=p->next;
        cout<<p->val<<" ";
    }
    cout<<endl;
}
int main(){
    int n;
    cout<<"输入链表长度：";
    cin>>n;
    getlist(n);
    Delete(head);
    output();
    return 0;
}

设计一个算法，从顺序表hq中删除a到b的元素，并保证剩余元素相对次序不变。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cstring>
#define size 100
#define test   cout<<"****"<<endl;
typedef struct{
  int date[size];
  int length;
}List;
bool k[100];
void init(List *l,int n){
  printf("输入顺序表的元素：");
  for(int i=0;i<n;i++){
    scanf("%d",&l->date[i]);
  }
  l->length=n;
}
void delet(List *l){
  int a,b;
  printf("输入要删除的区间范围：");
  scanf("%d%d",&a,&b);
  int j=0;
  for(int i=0;i<l->length;i++){
      if(!(l->date[i]>=a&&l->date[i]<=b))
        l->date[j++]=l->date[i];
  }
  l->length=j;
}
void output(List *l){
  printf("输出去掉a到b的值的链表：");
  for(int i=0;i<l->length;i++){
    printf("%d ",l->date[i]);
  }
  printf("
");
}
int main(){
  int m;
  List l;
  printf("输入线性表的长度：");
  scanf("%d",&m);
  // test;
  init(&l,m);
  memset(k,0,sizeof(k));
  delet(&l);
  output(&l);
  return 0;
}

设计一个算法从顺序表L中删除所有值为x的元素

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cstring>
#define size 100
#define test   cout<<"****"<<endl;
typedef struct{
    int date[size];
    int length;
}List;

using namespace std;

void init(List *l,int n){
    printf("输入顺序表的元素：");
    for(int i=0;i<n;i++){
      scanf("%d",&l->date[i]);
    }
    l->length=n;
}

void Delete(List *L){
    int x;
    printf("输入所要删除的X：");
    scanf("%d",&x);
    int j=0;
    for(int i=0;i<L->length;i++){
        int y=L->date[i];
        if(y!=x){
            L->date[j++]=L->date[i];
        }
    }
    L->length=j;
}

void output(List *l){
    printf("输出去掉x的值的链表：");
    for(int i=0;i<l->length;i++){
        printf("%d ",l->date[i]);
    }
    printf("
");
}
int main(){
    int n;
    printf("输入线性表的长度：");
    scanf("%d",&n);
    List l;
    init(&l,n);
    Delete(&l);
    output(&l);
    return 0;
}

设有一个线性链表，其头指针为head，试编写一个算法计算数据域为x的结点个数。

#include <iostream>
#include <bits/stdc++.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
typedef struct LinkList{
  int val;
  struct LinkList *next;
}LinkList;
using namespace std;

LinkList *head=(LinkList*)malloc(sizeof(LinkList));

void getlist(int n){
    LinkList *p=(LinkList*)malloc(sizeof(LinkList));
    p=head;
  for(int i=0;i<n;i++){
      LinkList *q=(LinkList*)malloc(sizeof(LinkList));
      cin>>q->val;
      p->next=q;
      q->next=NULL;
      p=q;
  }
}

void count(LinkList *L) {
  int sum=0;
  int x;
  printf("请输x的值：");
  scanf("%d",&x);
  LinkList *p;
  if(!L)
    return ;
    p=L->next;
  while(p) {
    if(p->val==x) {
      sum++;
    }
    p=p->next;
  }
  printf("链表中X域的元素的个数为：%d
",sum);;
}

void output(){
  LinkList *p=(LinkList*)malloc(sizeof(LinkList));
  p=head;
  while(p->next!=NULL){
      p=p->next;
      cout<<p->val<<" ";
  }
  cout<<endl;
}
int main(){
    int n;
    cout<<"输入链表长度：";
    cin>>n;
    getlist(n);
    count(head);
    output();
    return 0;
}

用顺序表表示集合，实现集合的求差集运算

#include <iostream>
#include <bits/stdc++.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define size 100
using namespace std;

typedef struct{
  int date[size];
  int length;
}List;
bool k[100];

void init(List *l,int n){
  for(int i=0;i<n;i++){
    scanf("%d",&l->date[i]);
  }
  l->length=n;
}

void output(List *A,int n,List *B,int m){
  printf("输出在顺序A中而不在B中的值:");
  for(int i=0;i<m;i++){
    int x=B->date[i];
    k[x]=1;
  }
  for(int i=0;i<n;i++){
    int x=A->date[i];
    if(!k[x])
      printf("%d ",x);
  }
  printf("
");
}
int main(){
    int n,m;
    List A,B;
    printf("输入A表的长度：");
    scanf("%d",&n);
    init(&A,n);
    printf("输入B表的长度：");
    scanf("%d",&m);
    init(&B,m);
    output(&A,n,&B,m);
    return 0;
}

设计一个算法，利用栈的基本运算返回栈的栈底元素

#include <iostream>
#include <stack>
using namespace std;
stack<int> s;
void init(int n){
    int x;
    while(n--){
        scanf("%d",&x);
        s.push(x);
    }
}
void Return(){
  int x;
  printf("栈底元素为：");
  while(!s.empty()){
    x=s.top();
    s.pop();
  }
  printf("%d
",x);
}
int main(){
    int n;
    printf("输入栈的大小：");
    scanf("%d",&n);
    init(n);
    Return();
    return 0;
}

在hq的链队中，设计一个算法求该链队中结点个数。

#include <iostream>
using namespace std;
typedef struct Node{
    int date;
    struct Node *next;
}Node;

Node *head=(Node*)malloc(sizeof(Node));


void getNode(int n){
    Node *p=(Node*)malloc(sizeof(Node));
    p=head;
  for(int i=0;i<n;i++){
      Node *q=(Node*)malloc(sizeof(Node));
      cin>>q->date;
      p->next=q;
      q->next=NULL;
      p=q;
  }
}

int Count(Node*head){
    int count=0;
    Node*top=head;
    while(top->next!=NULL){
        count++;
        top=top->next;
    }
    return count;
}

int main(){
    int n;
    printf("输入链队长度：");
    scanf("%d",&n);
    getNode(n);
    int sum=Count(head);
    printf("链队长为：%d
",sum);
    return 0;
}

设计一个算法，从顺序表hq中删除重复的元素，并保证剩余元素相对次序不变

#include <iostream>
#define size 100

using namespace std;
typedef struct List{
    int date[size];
    int length;
}List;

int k[100];
void init(List *l,int n){
    int x;
    for(int i=0;i<n;i++){
        cin>>x;
        l->date[i]=x;
    }
    l->length=n;
}

void Delete(List *l){
    int j=0;
    for(int i=0;i<l->length;i++){
        int x=l->date[i];
        if(!k[x]){
            l->date[j++]=x;
            k[x]=1;
        }
    }
    l->length=j;
}

void output(List *l){
    cout<<"输出去重后的顺序表：";
    for(int i=0;i<l->length;i++){
        cout<<l->date[i]<<" ";
    }
    cout<<endl;
}

int main(){
    int n;
    cout<<"输入hq表的长度：";
    cin>>n;
    List hq;
    init(&hq,n);
    Delete(&hq);
    output(&hq);
    return 0;
}

设计一个算法，利用队列和栈的基本运算将指定队列中的内容进行逆转

#include <iostream>
#include <queue>
#include <stack>

using namespace std;
queue<int> q;
stack<int> s;
void init(int n){
    cout<<"输入队列：";
    while(n--){
        int x;
        cin>>x;
        q.push(x);
    }
}

void change(){
    while(!q.empty()){
    int x=q.front();
    s.push(x);
    q.pop();
  }
  while(!s.empty()){
    int x=s.top();
    q.push(x);
    s.pop();
  }
}

void output(){
    cout<<"输出倒置后的队列：";
    while(!q.empty()){
        int x=q.front();
        cout<<x<<" ";
        q.pop();
    }
    cout<<endl;
}
int main(){
    int n;
    cout<<"输入队列有多长：";
    cin>>n;
    init(n);
    change();
    output();
    return 0;
}