数据结构顺序表和单链表

1.描述

设计整数顺序表的基本运算程序，并用相关数据进行测试

输入

顺序输入顺序表A的元素个数及各个元素

输出

第一行：创建顺序表A后，输出所有元素
第二行：删除第一个元素，输出删除后的所有元素
第三行：输出删除元素后顺序表的长度
第四行：在第二元素处插入一个新的元素100
第五行：输出第一个元素100所在位置

样例输入

6
1 2 3 4 0 9

样例输出

1 2 3 4 0 9
2 3 4 0 9
5
2 100 3 4 0 9
2

#include <iostream>
using namespace std;
const int Temp=10000;
template<class T>
class Seqlist
{
public:
    Seqlist(){}//定义无参构造函数
    Seqlist(int n,T a[]);//定义有参构造函数，创建链表
    void Delete();//删除第一个数
    void Insert();//插入
    void Locate();//查找插入元素的位置
    void ShowSeqlist();
private:
    int length;
    T data[Temp];
};
template<class T>
Seqlist<T>::Seqlist(int n,T a[])
{
    if(n>Temp)
    throw"参数非法";
    for(int i=0;i<n;i++)
    {
        data[i]=a[i];
    }
    length=n;
}
template<class T>
void Seqlist<T>::ShowSeqlist()
{
      for(int j=0;j<length;j++)
    {
        cout<<data[j]<<" ";
    }
     cout<<endl;
}
template<class T>
void Seqlist<T>::Delete()
{
    int x,i;
    x=data[0];
    if(length==0)throw"溢出";

    for(int i=1;i<length;i++)
    {
        data[i-1]=data[i];
    }
    for(int j=0;j<length-1;j++)
    {
        cout<<data[j]<<" ";
    }
    cout<<endl;
    cout<<length-1<<endl;
}
template<class T>
void Seqlist<T>::Insert()
{
    int i;
    if(length==Temp)throw"非法";
    for(i=length;i>=2;i--)
    {
        data[i]=data[i-1];
    }
    data[1]=100;
    for(int j=0;j<length;j++)
    {
        cout<<data[j]<<" ";
    }
    cout<<endl;
}
template<class T>
void Seqlist<T>::Locate()
{
    for(int i=0;i<length;i++)
    {
        if(data[i]==100)
        {
            cout<<i+1<<endl;
            break;
        }
    }
}
int main()
{
   int arr[Temp],i,nn;
   cin>>nn;
   for(i=0;i<nn;i++)
   {
       cin>>arr[i];
   }
   Seqlist<int>s1(nn,arr);
   s1.ShowSeqlist();
   s1.Delete();
   s1.Insert();
   s1.Locate();
   return 0;
}

2.描述

定义单链表类，创建带头结点的单链表（节点类型为整型数据），要求包含以下成员函数：

头插法创建单链表(利用构造函数实现)

尾插法创建单链表(重载构造函数实现)

链表的遍历

按值删除一个节点

按位置删除一个节点

判断该链表是否递增有序

链表的析构

 

输入

输入一组数据，以尾插法的形式创建单链表（０表示输入结束）（构造第一个链表）
输入一组数据，以头插法的形式创建单链表（０表示输入结束）（构造第二个链表）
输入要删除元素的值（在尾插法创建的链表中进行该操作）
输入要删除元素的位置（在尾插法创建的链表中进行该操作）

输出

输出尾插法创建链表的结果
输出头插法插法创建链表的结果
输出按值删除之后链表中剩余的元素（在尾插法创建的链表中进行该操作.若删除的元素不存在，输出Error）
输出按位置删除之后链表中剩余的元素（在尾插法创建的链表中进行该操作.若删除的元素不存在，输出Error
输出链表是否递增有序(在尾插法创建的链表中进行该操作.递增有序,输出Yes.否则输出No。)

样例输入

1 2 3 4 5 0　
1 2 3 4 5 0
2
0

样例输出

1 2 3 4 5
5 4 3 2 1
1 3 4 5
Error
Yes

#include <iostream>
using namespace std;
template<typename T>
struct Node
{
    T data;//数据域
    Node<T>* next;//指针域
};
template<typename T>
class LinkList
{
private:
    Node<T>* first;
public:
    LinkList();//创建单链表
    ~LinkList();//析构
    LinkList(T a[],int m);//头插
    LinkList(T b[],int m,int n);//尾插
    T DeleteZhi(int x);//按值删除
    T ShanWei(int i);//按位置删除
    void Print();//遍历
    int PanDuan();//判断
};
template<typename T>
LinkList<T>::~LinkList()
{
    Node<T>*p=first;
    while(first)
    {
        first=first->next;
        delete p;
        p=first;
    }
}
template<typename T>
LinkList<T>::LinkList()
{
    first = new Node<T>;
    first->next = NULL;
}
template<typename T>
LinkList<T>::LinkList(T a[],int m)
{
    first = new Node<T>;
    first->next =NULL;

   for(int i=0;i<m;i++)
    {
        Node<T>* s = NULL;
        s = new Node<T>;
        s->data = a[i];
        s->next = first->next;
        first->next = s;
    }
}
template<typename T>
LinkList<T>::LinkList(T b[],int m,int n)
{
    first= new Node<T>;
    Node<T>* r = first;//头指针变成尾指针
    Node<T>* s = NULL;//新建节点
    for(int i=0;i<m;i++)
    {
        s = new Node<T>;
        s->data = b[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;
}

template<typename T>
T LinkList<T>::ShanWei(int i)
{
    int m;
    Node<T>* p =first, * q = NULL;
    int count = 0;
    while (p != NULL && count < i-1)
    {
        p = p->next;
        count++;
    }
    if (p == NULL||p->next==NULL||i==0)
    {
        cout << "Error" << endl;

    }
    else {

        q = p->next;
        m=q->data;
        p->next = q->next;
        delete q;
        Print();
    }
return 0;
}
template<typename T>
T LinkList<T>::DeleteZhi(int x)
{
    Node<T>* p=first->next, * q=first ;

    int count=0;
    while (p->next!= NULL&&x!=p->data)
    {
        p=p->next;
        count++;
    }
        if (p ==NULL||p->next==NULL)
        {
            cout<<"Error"<<endl;
        }
        else{
            int j=0;
            p=first;
            while(p!=NULL&&j<count)
            {
                p=p->next;
                j++;
            }
            q=p->next;
            p->next=q->next;
            delete q;
          Print();
        }
        return 0;
}
template<typename T>
void LinkList<T>::Print()
{
    Node<T>* p = first->next;
    while (p != NULL)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}
template<typename T>
int LinkList<T>::PanDuan()
{
    Node<T>*p=first->next,*q=NULL;
    while(p)
    {
         q=p->next;
        if(q->data > p->data)
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
}
int main()
{
    int b[100],c[100],x,y,i=0,j=0,wei,shu;
   while( cin>>x&&x)
   {
       b[i]=x;
       i++;
   }
    while( cin>>y&&y)
   {

       c[j]=y;
       j++;
   }
   cin>>shu;
   cin>>wei;
    LinkList<int>L2(b,i,0);
    L2.Print();
    LinkList<int>L1(c,j);
    L1.Print();
    L2.DeleteZhi(shu);
    L2.ShanWei(wei);
    if(L2.PanDuan()==1)
    {
        cout<<"Yes"<<endl;
    }
    else
    {
        cout<<"No"<<endl;
    }
    return 0;
}