我会在这个平台上持续更新大学期间遇到的一些比较难的作业和一些算法题。

最新推荐文章于 2024-09-13 16:27:15 发布

black_barrel

最新推荐文章于 2024-09-13 16:27:15 发布

阅读量65

点赞数 1

分类专栏：头歌实训文章标签：算法链表数据结构

本文链接：https://blog.csdn.net/black_barrel/article/details/131236686

版权

头歌实训专栏收录该内容

1 篇文章 0 订阅

订阅专栏

第一关，这是一道关于链表和数组的题目，题目有一些缺陷，会在写的过程中造成一些影响。

ArrayList，因为主函数中会手动释放内存，所以这里的析构函数就不会去释放内存了（我也不知道这出题人是咋想的）。下方的LinkedList的析构函数同样如此。

#include "ArrayList.h"

/****************start from here**********************/

//默认构造函数，构造一个逻辑为空的顺序表
ArrayList::ArrayList() {
    data = new int;
    capacity = 0;
    size = 0;
}
//拷贝构造函数，构造一个逻辑上与参数内容相同的顺序表
ArrayList::ArrayList(const ArrayList& rhs) {
    data = new int;
    capacity = rhs.capacity;
    size = rhs.size;
    for (int i = 0; i < rhs.size; i++) {
        data[i] = rhs.data[i];
    }
}
//原生数组构造函数，构造一个内容与给定数组相同的顺序表
ArrayList::ArrayList(int const a[], int n) {
    data = new int;
    capacity = n + 10;
    size = n;
    for (int i = 0; i < n; i++) {
        data[i] = a[i];
    }
}
//填充构造函数，构造一个内容为n个value的顺序表
ArrayList::ArrayList(int n, int value) {
    data = new int;
    capacity = n + 10;
    size = n;
    for (int i = 0; i < n; i++) {
        data[i] = value;
    }
}
//析构函数，一定要自行实现，否则有内存泄漏
ArrayList :: ~ArrayList() {
    if (data != nullptr) {
        //delete data;
    }
}
//子类当中须覆盖并实现父类中的纯虚函数
void ArrayList::insert(int pos, int value) {
    size++;
    capacity++;
    int* Data = new int[capacity];
    for (int i = 0; i < size; i++) {
        if (i == pos) {
            Data[i] = value;
        }
        else {
            Data[i] = data[i];
        }
    }
    for (int i = 0; i < size; i++) {
         data[i] = Data[i];
    }
    delete Data;
}

void ArrayList::remove(int pos) {
    for (int i = pos; i + 1 < size; i++) {
        data[i] = data[i + 1];
    }
    size--;
}
int ArrayList::at(int pos)const {
    return data[pos];
}
void ArrayList::modify(int pos, int newValue) {
    for (int i = 0; i < size; i++) {
        if (i == pos) {
            data[i] = newValue;
        }
    }
}

LinkedList

#include "LinkedList.h"
using namespace std;
/****************start from here**********************/


void LinkedList::disp(ostream& os)const {
    Node* pointer = head->next;
    int i = 0;
    while (i++ < size)
    {
        cout << pointer->data << " ";
        pointer = pointer->next;
    }
    cout << endl;
}
//


LinkedList::LinkedList()
{
    size = 0;
    head = new Node;
    head->next = NULL;
}

//拷贝构造函数，构造一个逻辑上与参数内容相同的链表
LinkedList::LinkedList(const LinkedList& rhs)
{
    head = new Node;
    head->next = NULL;

    size = rhs.size;
    Node* pointer1 = head;           //让指针一号指到当前链表的头
    Node* pointer2 = rhs.head->next;//让指针二号指到  引用链表的头中的next指针所指到的下一个节点

    while (pointer2)
    {
        pointer1->next = new Node;//先给他开空间，开了空间再指向他，准备给他安东西
        pointer1 = pointer1->next;

        pointer1->data = pointer2->data;
        pointer1->next = NULL;//不要让结点里的next指针为空
        pointer2 = pointer2->next;//让指针二号移位到下一个结点去

    }
}
//    //原生数组构造函数，构造一个内容与给定数组相同的链表
LinkedList::LinkedList(int const a[], int n)
{
    head = new Node;
    head->next = NULL;

    size = n;
    Node* pointer = head;
    for (int i = 0; i < n; i++)
    {
        pointer->next = new Node;
        pointer = pointer->next;
        pointer->data = a[i];
        pointer->next = NULL;//不要让结点里的next指针为空
    }
}
//    //填充构造函数，构造一个内容为n个value的链表
LinkedList::LinkedList(int n, int value)
{
    size = n;
    head = new Node;
    head->next = NULL;

    Node* toolman = head;

    for (int i = 0; i < n; i++)
    {
        toolman->next = new Node;
        toolman = toolman->next;

        toolman->data = value;
        toolman->next = NULL;
    }

}
LinkedList::~LinkedList()
{
    /*Node* toolman1 = head;
    Node* toolman2 = head;*/

    /*while (toolman1->next)
    {
        toolman2 = toolman1->next;
        delete toolman1;
        toolman1 = toolman2;
    }
    head = NULL;
    delete toolman1;
    toolman1 = NULL;
    toolman2 = NULL;*/
}


void LinkedList::insert(int pos, int value) {
    Node* pointer1 = head;//首先要知道pos代表第几个节点

    int i = 0;
    while (i++ < pos) {
        pointer1 = pointer1->next;
    }//结束后pointer1指向的是pos位置的结点
    Node* newnode = new Node;
    newnode->data = value;
    //newnode->next = new Node;
    newnode->next = pointer1->next;
    pointer1->next = newnode;
    size++;
}

void LinkedList::remove(int pos) {
    Node* pointer = head;
    int i = 0;
    while (i < pos - 1)
    {
        pointer = pointer->next;
        i++;
    }
    pointer->next = pointer->next->next;
    size--;
}

int LinkedList::at(int pos)const {
    Node* pointer = head;
    int i = -1;
    while (i < pos)
    {
        pointer = pointer->next;
        i++;
    }
    return pointer->data;
}


void LinkedList::modify(int pos, int newValue) {
    Node* pointer = head;
    int i = -1;
    while (i < pos)
    {
        pointer = pointer->next;
        i++;
    }
    pointer->data = newValue;
}

第二关，是在第一关的基础上完成的。这一关在List.h文件中的“/*你的工作在这里：此处设计disp函数*/”将这段代码补上即可

List

 /*你的工作在这里：此处设计disp函数*/  
    virtual void disp(ostream &os) const{
        for(int i=0,n=getSize();i<n;++i){
            os<<at(i)<<" ";//注意，这里at函数并没有实现
                           //但不妨碍这么写
        }
       // os<<endl;
    }

第三关,抽象类的完成，这一关只需要写一个虚析构函数和增、删、查、改函数就行了，显示函数（disp）在这里不能在IList中写出来（不能写成纯虚函数的显示，可以写成虚函数的形式，因为List中实现了显示函数，所以这里就不写了），因为后面的ArrayList类中并未实现显示函数，而子类必须将继承的纯虚函数实现。（这因为是出题人偷懒导致的，我真的是受够了！！！）。

IList.h

#ifndef _ILIST_H_
#define _ILIST_H_

/****************start from here**********************/
#include<iostream>
using namespace std;

class IList {
public:
    virtual ~IList(){};
    virtual void insert(int pos, int value) = 0;
    virtual void remove(int pos) = 0;
    virtual int at(int pos) const = 0;
    virtual void modify(int pos, int newValue) = 0;
    //virtual void diap(ostream &os) const = 0;
};


#endif