数据结构与算法之美练习

数组和链表

数组

1. 实现一个支持动态扩容的数组
2. 实现一个大小固定的有序数组，支持动态增删改操作
3. 实现两个有序数组合并为一个有序数组

#include<stdlib.h>
#include<vector>
#include<iostream>
using namespace std;
//动态数组相关操作
template<typename T>
class Array
{
public:
    Array(int nSize = 3)
    {
        m_array = new T[nSize];
        m_size = nSize;
        m_cursize = 0;
    }
    ~Array()
    {
        delete[] m_array;
        m_array = nullptr;
    }
    T& operator[](const int nIndex)
    {
        if(nIndex > m_size)
            return INT_MAX;
        return m_array[nIndex];
    }
    int get_size()
    {
        return m_size;
    }

    void resize();
    void append(T value); //增
    void remove(int nIndex); //删
    void revise(int nIndex,T value); //改
    T get_element(int nIndex); //查
    //快排操作
    int getSortIndex(int nStart,int nEnd);
    void qsort(int nStart,int nEnd);
    
private:
    T* m_array;
    int m_size;
    int m_cursize;
};

template<typename T>
Array<T> concat(Array<T>& a,Array<T>& b)
{
    a.qsort();
    b.qsort();
    int nASize = a.get_size();
    int nBSize = b.get_size();
    int nTotalSize =  nASize + nBSize;
    Array<T> result;
    int i = 0,j=0;
    while(i < nASize && j < nBSize)
    {
        T tmpA = a.get_element(i);
        T tmpB = b.get_element(j); 
        if(tmpA < tmpB)
        {
            result.append(tmpA);
            i++;
        }
        else
        {
            result.append(tmpB);
            j++;
        }               
    }
    while (i < nASize)
        result.append(a.get_element(i++));
    while (j < nBSize)
        result.append(b.get_element(j++);
   	return result;
}

template<typename T>
void Array<T>::qsort(int nStart,int nEnd)
{
    if(nStart < nEnd)
    {
        int nIndex = getSortIndex(nStart,nEnd);
        qsort(nStart,nIndex-1);
        qsort(nStart+1,nEnd);
    }
}

template<typename T>
int Array<T>::getSortIndex(int nStart,int nEnd)
{
    int nVal = m_array[nStart];
    while(nStart < nEnd)
    {
        while (nStart < nEnd && m_array[nEnd] >= nVal)
            nEnd--;
        m_array[nStart] = m_array[nEnd];
        while (nStart < nEnd && m_array[nStart] <= nVal)
            nStart++;
        m_array[nEnd] = m_array[nStart];
    }
    m_array[nStart] = nVal;
    return nStart;
} 

template<typename T>
void Array<T>::revise(int nIndex,T value)
{
    if(nIndex >= m_cursize)
    {
        cout<<"overflower!!!"<<endl;
        return;
    }
    m_array[nIndex] = value;
}

template<typename T>
void Array<T>::resize()
{
    if(m_size > m_cursize)
    {
        T* newValue;
        int nNewSize = math.ceil(m_size + m_size>>2);
        newValue = new T[nNewSize];
        for(int i = 0;i<m_size;i++)
            newValue[i] = m_array[i];
        delete[] m_array;
        m_array = newValue;
        m_size = nNewSize;
    }
}

template<typename T>
void Array<T>::append(T value)
{
    if(m_cursize >= m_size)
        resize();
    m_array[m_cursize++] = value;
}

以上代码如果有问题，麻烦大佬们指出 ---- 龟速前进的憨憨程序员