数组与链表

数组与链表

数组

数组是一种线性结构，将相同类型的元素放置于一篇连续的内存空间中

优点

1. 空间效率高：数组为数据分配了连续的内存块，无须额外的结构开销。
2. 随机存取特性
3. 缓存局部性

缺点

1. 删除，插入时间复杂度高
2. 长度不可变
3. 空间浪费：可能分配的空间太大了用不完

//数组和对应的简单功能的实现
#include<iostream>
using namespace std;

//插入元素
void insert(int* arr,int index,int size,int num)
{
    for(int i=size-1;i>index;i--)
    {
        arr[i] = arr[i-1];
    }
    arr[index] = num;
    return;
}
//显示数组中的元素
void show(int* arr, int size)
{
    for(int i=0;i<size;i++)
    {
        cout<<arr[i]<<" ";
    }
}
//删除数组中的元素
void remove(int* arr, int* size,int index)
{
    for(int i=index;i<*(size)-1;i++)
    {
        arr[i] = arr[i+1];
    }
    *(size) = *(size)-1;
}

int search(int* arr, int num,int len)
{
    for(int i=0;i<len;i++)
    {
        if(arr[i] == num)
        {
            return i;
        }
    }
    return -1;
}

int* extend(int* arr,int size,int e_size)
{
    int* e_arr = new int[size+e_size]{0};
    for(int i=0;i<size;i++)
    {
        e_arr[i] = arr[i];
    }
    return e_arr;
}
int main()
{
    int N =10;

    int* arr = new int[N]{1,2,3,4,5,6,7,8,9,10};
    insert(arr,2,N,11);
    remove(arr,&N,2);
    show(arr,N);
    cout<<"search:"<<search(arr,5,N)<<endl;
    int e_size = N*2;
    int* e_arr = extend(arr,N,e_size);
    show(e_arr,N+e_size);
    delete[] arr;
    delete[] e_arr;

    return 0;

}

链表

是一种线性数据结构，每个元素都是一个节点对象，通过引用记录下一个节点的位置，在内存中是不连续的

#include<iostream>
using namespace std;

struct Node
{
    int val;
    Node* next;
    Node(int x):val(x),next(nullptr){cout<<"A Node is generated"<<x<<endl;}
};
void show(Node* start)
{
    while(start!=nullptr)
    {
        cout<<start->val<<" ";
        start = start->next;
    }
}
void insert(Node* n,Node* start)
{
    n->next = start->next;
    start->next = n;
}

void del(Node* head)
{
    Node* index = nullptr;
    while(head)
    {
        index = head->next;
        delete head;
        head = index;
    }
}
int main()
{
    Node* head = new Node(0);
    Node* n1 = new Node(2);
    Node* n2 = new Node(6);
    Node* n3 = new Node(9);
    Node* n4 = new Node(11);
    Node* nx = new Node(1000);
    head->next = n1;
    n1->next = n2;
    n2->next = n3;
    n3->next = n4;
    insert(nx,head);

    show(head);
    del(head);

    return 0;
}

相关算法题

1. JZ3（剑指offer3）

//解法1
    int duplicate(vector<int>& numbers) {
        // write code here
        sort(numbers.begin(),numbers.end());
        for(int i=0;i<numbers.size();i++)
        {
            if(numbers[i] == numbers[i+1])return numbers[i];
        }
        return -1;
    }

//解法2(使用集合来判断第一个出现的重复元素)
    int duplicate(vector<int>& numbers)
    {
        set<int> s;
        for(int i=0;i<numbers.size();i++)
        {
            if(s.count(numbers[i])>0)
            {
                return numbers[i];
            }
            else{
                s.insert(numbers[i]);
            }
        }
        return -1;
    }
//解法3

2. JZ4（剑指offer4）

//直接暴力破解
    bool Find(int target, vector<vector<int> >& array) {
        // write code here
        for(int i=0;i<array.size();i++)
        {
            for(int j =0;j<array[0].size();j++)
            {
                if(target == array[i][j])return true;
            }
        }
        return false;
    }