西农数据结构第一次实习题目参考

T1

输入描述

请输入线性表La的长度:n a1 a2 a3 ..an(数值有序，为降序)

请输入要插入到线性表La中的数字x和插入的位置i:x，i

请输入要删除数字的位置:i

请输入要查找的数字:x

请输入线性表长度:m b1 b2..bm(数值有序，为升序)

输出描述

插入一个数字后的线性表a1 a2...an+1

删除一个数字后的线性表a1a2..an

查找一个输入的数字后如果找到，输出该数字的位置i,如果没有找到，输出"Not found"的信息。

逆置a1 a2...an后的线性表an an-1...a1

合并两个线性表后的线性表

示例

输入

5

14 11 10 9 5

8 4

4

10

4

1 3 6 9

输出

14 11 10 8 9 5

14 11 10 9 5

3

5 9 10 11 14

1 3 5 6 9 9 10 11 14

#include <iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    int n;
    cin >> n;
    vector<int>la;
    for (int i = 0; i < n; i++)
    {
        int num;
        cin >> num;
        la.push_back(num);
    }
    int x, i;
    cin >> x >> i;
    la.insert(la.begin() + i - 1, x);
    for (int num : la)
    {
        cout << num << " ";
    }
    cout << endl;
    int deletIndex;
    cin >> deletIndex;
    la.erase(la.begin() + deletIndex - 1);
    for (int num : la)
    {
        cout << num << " ";
    }
    cout << endl;
    int searchNum;
    cin >> searchNum;
    bool found = false;
    for (int index = 0; index < la.size(); index++)
    {
        if (la[index] == searchNum)
        {
            found = true;
            cout << index + 1 << endl;
            break;
        }

    }
    if (!found)
    {
        cout << "Not found" << endl;
    }
    reverse(la.begin(), la.end());
    for (int num : la)
    {
        cout << num << " ";
    }
    cout << endl;
    int m;
    cin >> m;
    vector<int>lb;
    for (int i = 0; i < m; i++)
    {
        int num;
        cin >> num;
        lb.push_back(num);
    }
    vector<int>mergedList = la;
    mergedList.insert(mergedList.end(), lb.begin(), lb.end());
    sort(mergedList.begin(), mergedList.end());
    for (int num : mergedList)
    {
        cout << num << " ";
    }
    cout << endl;
    return 0;
}

#include <iostream>
using namespace std;
class LinkNode{
public:
    int number;
    LinkNode* next;
    LinkNode* forward;
    LinkNode(){
        next=nullptr;
        forward=nullptr;
    }
    LinkNode(int number){
        this->number=number;
        next=nullptr;
        forward=nullptr;
    }
};
class List{
    int length=0;
    LinkNode* head=new LinkNode();
public:
    List(){//鏋勯€犲嚱鏁?
        length=0;
    }
    void add(int target){
        auto tmp=new LinkNode(target);
        auto current=head;
        while(current->next!=nullptr)current=current->next;
        current->next=tmp;
        tmp->forward=current;
        length+=1;
    }
    bool insert(int target,int index){
        auto current=head;
        for(int i=0;i<index-1;++i){
            current=current->next;
        }
        auto tmp=new LinkNode(target);
        tmp->next=current->next;
        current->next=tmp;
        tmp->forward=current;
        tmp->next->forward=tmp;
        length+=1;
        return true;
    }
    void search(int target){
        int flag=1;
        auto current=head->next;
        while(current!=nullptr){
            if(current->number==target){
                cout<<flag<<endl;break;
            }
            else{
                current=current->next;
                flag+=1;
            }
        }
        if(current==nullptr)cout<<"Not found"<<endl;
    }
    List* reverse(){
        auto newList=new List();
        auto current=head;
        while(current->next!=nullptr)current=current->next;
        while(current->forward!=nullptr){
            newList->add(current->number);
            current=current->forward;
        }
        return newList;
    }
    List* merge(List* another){
        auto newList=new List();
        auto currentThis=this->head->next;
        auto currentAnother=another->head->next;
        while((currentThis!=nullptr)&&(currentAnother!=nullptr)){
            if(currentThis->number<currentAnother->number){
                newList->add(currentThis->number);
                currentThis=currentThis->next;
            }else{
                newList->add(currentAnother->number);
                currentAnother=currentAnother->next;
            }
        }
        if(currentThis==nullptr){
            while(currentAnother!=nullptr){
                newList->add(currentAnother->number);
                currentAnother=currentAnother->next;
            }
        }else if(currentAnother==nullptr){
            while(currentThis!=nullptr){
                newList->add(currentThis->number);
                currentThis=currentThis->next;
            }
        }
        return newList;
    }
    void print(){
        auto current=head->next;
        while(current!=nullptr){
            cout<<current->number<<" ";
            current=current->next;
        }
        cout<<"\n";
    }
    void del(int index){
        auto current=head;
        while(--index>0)current=current->next;
        auto tmp=current->next;
        current->next=current->next->next;
        current->next->forward=current;
        delete tmp;
    }
    ~List(){
        auto current=head->next;
        while(current!=nullptr){
            auto tmp=current;
            current=current->next;
            delete tmp;
        }
    }
};
int main(){
    auto list=new List();
    int N;cin>>N;
    while(--N>=0){
        int tmp;cin>>tmp;
        list->add(tmp);
    }
    //cout<<"target"<<endl;
    int target,index;cin>>target>>index;
    list->insert(target,index);
    list->print();
    cin>>index;
    list->del(index);
    list->print();

    cin>>index;
    list->search(index);
    list->reverse()->print();
    auto newList=new List();
    cin>>N;
    for(int i=0;i<N;++i){
        int tmp;cin>>tmp;
        newList->add(tmp);
    }
    //list->reverse()->print();
    //newList->print();
    newList->merge(list->reverse())->print();
}

T2

输入描述

线性表长度n a1 a2 a3 ...an(数值有序，为降序)

要插入到线性表中的数字x和插入的位置i

要删除的数字的位置i

要查找的数字x

线性表长度m b1 b2...bm(数值有序，为升序)

输出描述

插入一个数字后的线性表a1 a2...an+1

删除一个数字后的线性表a1 a2...an

查找一个输入的数字后如果找到，输出该数字的位置i,如果没 有找到，输出"Not found"的信息。

逆置a1 a2...an后的线性表an an-1...a1

合并两个线性表后的线性表

输入

6

15 13 10 9 8 5

7 6

4

10

4

1 3 6 9

输出

15 13 10 9 8 7 5

15 13 10 8 7 5

3

5 7 8 10 13 15

1 3 5 6 7 8 9 10 13 15

#include <iostream>
using namespace std;
struct ListNode {
    int data;
    ListNode* next;
    ListNode(int val) :data(val), next(NULL) {}
};
ListNode* createList(int n) {
    ListNode* head = NULL;
    ListNode* tail = NULL;
    for (int i = 0; i < n; i++) {
        int num;
        cin >> num;
        ListNode* newNode = new ListNode(num);
        if (!head) {
            head = newNode;
            tail = newNode;
        }
        else {
            tail->next = newNode;
            tail = newNode;
        }
    }
    return head;
}
void printList(ListNode* head) {
    ListNode* curr = head;
    while (curr) {
        cout << curr->data << " ";
        curr = curr->next;
    }
    cout << endl;
}
ListNode* insertNode(ListNode* head, int x, int i) {
    ListNode* newNode = new ListNode(x);
    if (i == 1) {
        newNode->next = head;
        head = newNode;
        return head;
    }
    ListNode* curr = head;
    int count = 1;
    while (curr && count < i - 1) {
        curr = curr->next;
        count++;
    }
    if (curr) {
        newNode->next = curr->next;
        curr->next = newNode;
    }
    return head;
}
ListNode* deleteNode(ListNode* head, int i) {
    if (i == 1) {
        ListNode* temp = head;
        head = head->next;
        delete temp;
        return head;
    }
    ListNode* curr = head;
    int count = 1;
    while (curr && count < i - 1) {
        curr = curr->next;
        count++;
    }
    if (curr && curr->next) {
        ListNode* temp = curr->next;
        curr->next = curr->next->next;
        delete temp;
    }
    return head;
}
int searchNode(ListNode* head, int x) {
    ListNode* curr = head;
    int i = 1;
    while (curr) {
        if (curr->data == x) {
            return i;
        }
        curr = curr->next;
        i++;
    }
    return -1;
}
ListNode* reverseList(ListNode* head) {
    ListNode* prev = NULL;
    ListNode* curr = head;
    while (curr) {
        ListNode* nextTemp = curr->next;
        curr->next = prev;
        prev = curr;
        curr = nextTemp;
    }
    return prev;
}
ListNode* mergeLists(ListNode* list1, ListNode* list2) {
    ListNode* mergedHead = NULL;
    ListNode* mergedTail = NULL;
    while (list1 && list2) {
        if (list1->data <= list2->data) {
            if (!mergedHead) {
                mergedHead = list1;
                mergedTail = list1;
            }
            else {
                mergedTail->next = list1;
                mergedTail = list1;
            }
            list1 = list1->next;
        }
        else {
            if (!mergedHead) {
                mergedHead = list2;
                mergedTail = list2;
            }
            else {
                mergedTail->next = list2;
                mergedTail = list2;
            }
            list2 = list2->next;
        }
    }
    if (list1) {
        mergedTail->next = list1;
    }
    if (list2) {
        mergedTail->next = list2;
    }
    return mergedHead;
}
int main() {
    int n;
    cin >> n;
    ListNode* list1 = createList(n);
    int x, i;
    cin >> x >> i;
    list1 = insertNode(list1, x, i);
    printList(list1);
    cin >> i;
    list1 = deleteNode(list1, i);
    printList(list1);
    int target;
    cin >> target;
    int foundIndex = searchNode(list1, target);
    if (foundIndex != -1) {
        cout << foundIndex << endl;
    }
    else {
        cout << "Not found" << endl;
    }
    list1 = reverseList(list1);
    printList(list1);
    int m;
    cin >> m;
    ListNode* list2 = createList(m);
    ListNode* mergedList = mergeLists(list1, list2);
    printList(mergedList);
    return 0;
}

T3

用链式存储结构实现对一个班级学生信息管理。设计程序求出每个人的平均成绩并按平均成绩由高到底排序后输出学生记录。

输入描述

人数n 人员记录1(格式为: 学号 姓名 成绩1 成绩2 成绩3)

人员记录2 ……

输出描述

人员记录x 1

人员记录y 2

…

人员记录z n

输入

3

1 孙俪莉 76 78 89

2 章子怡 72 56 67

3 刘德华 56 84 90

输出

1 孙俪莉 76.00 78.00 89.00 81.00 1

3刘德华 56.00 84.00 90.00 76.67 2

2 章子怡 72.00 56.00 67.00 65.00 3

#include <iostream>
#include<iomanip>
using namespace std;
struct Student {
    int id;
    string name;
    double score1;
    double score2;
    double score3;
    double averageScore;
    Student* next;
};
double calculateAverage(double score1, double score2, double score3) {
    return (score1 + score2 + score3) / 3.0;
}
Student* createStudentNode(int id, string name, double score1, double score2, double score3) {
    Student* newStudent = new Student;
    newStudent->id = id;
    newStudent->name = name;
    newStudent->score1 = score1;
    newStudent->score2 = score2;
    newStudent->score3 = score3;
    newStudent->averageScore = calculateAverage(score1, score2, score3);
    newStudent->next = NULL;
    return newStudent;
}
Student* insertStudent(Student* head, Student* newStudent) {
    if (!head || newStudent->averageScore > head->averageScore) {
        newStudent->next = head;
        return newStudent;
    }
    Student* curr = head;
    while (curr->next && curr->next->averageScore >= newStudent->averageScore) {
        curr = curr->next;
    }
    newStudent->next = curr->next;
    curr->next = newStudent;
    return head;
}
void printStudent(Student* student, int rank) {
    cout << student->id << " " << student->name << " " << fixed << setprecision(2) << student->score1 << " " << setprecision(2) << student->score2 << " " << setprecision(2) << student->score3 << " " << setprecision(2) << student->averageScore << " " << rank << endl;
}
void printList(Student* head) {
    Student* curr = head;
    int rank = 1;
    while (curr) {
        printStudent(curr, rank);
        curr = curr->next;
        rank++;
    }
}
void freeList(Student* head) {
    Student* curr = head;
    Student* temp;
    while (curr) {
        temp = curr;
        curr = curr->next;
        delete temp;
    }
}
int main() {
    int n;
    cin >> n;
    Student* head = NULL;
    for (int i = 0; i < n; i++) {
        int id;
        string name;
        double score1, score2, score3;
        cin >> id >> name >> score1 >> score2 >> score3;
        Student* newStudent = createStudentNode(id, name, score1, score2, score3);
        head = insertStudent(head, newStudent);
    }
    printList(head);
    freeList(head);
    return 0;
}

T4

编号为1，2，3，……，n的n个人按顺时针方向围坐一圈。任选一个正整数作为报数上限m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。

输入描述

人数n

报数上限m

人员记录1(格式为:姓名 学号 性别 年龄 班级 健康状况)

人员记录2

…

人员记录n

输出描述

第1次报数出列的人员记录

第2次报数出列的人员记录

…

第n次报数出列的人员记录

输入

5 3

安弥邵 10000001女 28 计43 一般

宰觅 10000002 男 23 计79 健康

顾健 10000003 男 27 计29 一般

宓顽芳 10000004 女 20 计17 健康

能纸垄 10000005 男 18 计11 健康

输出

顾健 10000003 男 27 计29 一般

安弥邵 10000001女28 计43 一般

能纸垄 10000005 男 18 计11 健康

宰觅 10000002 男 23 计79 健康

宓顽芳 10000004 女20 计17 健康

#include <iostream>
#include <string>
using namespace std;
struct Person {
    string name;   
    string id;        
    string gender;  
    int age;         
    string classId;  
    string health;   
    Person* next;    
};
Person* createCircle(int n) {
    Person* head = nullptr;
    Person* prev = nullptr;
    for (int i = 0; i < n; i++) {
        Person* newPerson = new Person();
        cin >> newPerson->name >> newPerson->id >> newPerson->gender >> newPerson->age >> newPerson->classId >> newPerson->health;
        newPerson->next = nullptr;
        if (!head) {
            head = newPerson;
        }
        else {
            prev->next = newPerson;
        }
        prev = newPerson;
    }
    prev->next = head; 
    return head;
}
void printPerson(Person* person) {
    cout << person->name << " " << person->id << " " << person->gender << " " << person->age << " " << person->classId << " " << person->health << endl;
}
void josephus(Person* head, int n, int m) {
    Person* current = head;
    Person* prev = nullptr;
    while (n > 0) {
        for (int i = 1; i < m; i++) {
            prev = current;
            current = current->next;
        }
        printPerson(current);
        if (current == head) {
            head = head->next;
        }
        prev->next = current->next;
        Person* temp = current;
        current = current->next;
        delete temp;
        n--;
    }
}
int main() {
    int n, m;
    cin >> n >> m;
    Person* head = createCircle(n);
    josephus(head, n, m);
    return 0;
}