//我发现,插入操作时,总是先把New与已有节点连接 

#include<iostream>
#include<cstdlib>
using namespace std;
#define LEN sizeof(struct Node)
#define N 6

#include<iostream>
#include<cstdlib>
#define LEN sizeof(struct Node)
using namespace std;

#include<iostream>
#include<cstdlib>
#define LEN sizeof(struct Node)
using namespace std;

typedef struct Node *PtrToNode;
typedef PtrToNode Position;

struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode Position;

typedef struct Node *PtrToNode;
typedef PtrToNode Position;

struct Node
{
int Element;
struct Node *Next;
};

struct Node         //节点 
{
int Element ;
struct Node *Next;
};

struct Node
{
int Element;
struct Node *Last;
struct Node *Next;
};

Position Create(void);  //创建一个循环链表 
void Taverse(Position Head); //遍历
void Inser(Position Head); //插入一个元素 
void Delete(Position Head); //删除一个元素 
int GetListLenth(Position Head);
//获得单向循环链表元素个数,用于判断用户输入的序号 

int IsEmpty(Position Top);  //检验空栈 
void GetStackTop(Position Top); //获取栈顶元素 
Position Create(void);  //创建一个栈 
void Traverse(Position Top); //遍历 
void Push(Position Top);  //出栈 
void Pop(Position Top);   //入栈 

Position Create(void);           //创建双向循环链表 
void Traverse(Position Head);    //正序遍历/n反序遍历 
void Insert(Position Head);      //插入一个元素 
void Delete(Position Head);      //删除一个元素 
int GetListLenth(Position Head); //用于插入 

int main()  //测试 
{
Position Head;
Head=Create();
Taverse(Head);
Inser(Head);
Delete(Head);
delete Head;
return 0;
}

int main()  //测试 
{
Position Top=Create();
Traverse(Top);
Push(Top);
return 0;
}

int main()  //测试 
{
Position Head;
Head=Create();
Traverse(Head);
澳门新葡萄京官网注册,Insert(Head);
Delete(Head);
return 0;
}

Position Create(void) //创建一个单向循环链表 
{
int i,a[N]={10,20,25,59,18,11}; 

int IsEmpty(Position Top) 
{
return Top->Next==NULL;  
}

Position Create(void)  //创建 
{
int a[6]={11,41,18,49,35,66},i;
Position Head=NULL;
    Position New=NULL,Tail=NULL;
    Head=(struct Node *)malloc(LEN);
    if(Head==NULL)
        cout <<“空间不足!” <<endl ;
    Head->Next=Head;
    Head->Last=Head;
    Head->Element=0;
    Tail=Head;
    for(i=0;i<6;i++)
    {
    New=(struct Node *)malloc(LEN);
    if(New==NULL)
       cout <<“空间不足!” <<endl ;
    New->Element=a[i];     //赋值 
    New->Last=Tail;        //先把New与已有的节点连接 
    New->Next=Head;
    Tail->Next=New;        //把原来的尾节点与New连接 
    Head->Last=New;        //把Head的Last与New连接 
    Tail=New;              //现在,New是新的Tail,在末尾插入完毕 
   
}
return Head;
}

Position Head,Tail=NULL,New=NULL;
Head=(struct Node *)malloc(LEN);
if(Head==NULL)
   cout <<“空间不足创建失败!” <<endl ;
Tail=Head;
Head->Element=0;
Head->Next=Head;  //循环链表,当只有一个元素时,它总是指向自己 
for(i=0;i<N;i++)
{
New=(struct Node *)malloc(LEN);
if(New==NULL)
   cout <<“空间不足!” <<endl ;
New->Element=a[i];
New->Next=Head;  //最新的New是末尾,所以指向头 
Tail->Next=New;  //所以现在Tail不是末尾,而Tail的Next New才是末尾 
Tail=New;        //让New成为新的末尾 
}
return Head; 
}

Position Create(void)
{
int i,a[8]={15,16,21,9,54,66,24,59}; //创建一个8个元素的栈 
Position Top=NULL;
Top=(struct Node *)malloc(LEN);
Top->Next=NULL;
Top->Element=0;
for(i=0;i<8;i++)
{

void Traverse(Position Head)
 //遍历,这里的Head_L用来遍历,而不一直是头指针 
{
Position Head_L=Head->Next;  //从这开始,正序遍历总是指向Next 
while(Head_L!=Head)
{
cout <<Head_L->Element <<‘ ‘ ;
Head_L=Head_L->Next;
}
cout <<“正序遍历完毕” <<endl ;
Head_L=Head->Last;          //从这开始,反序遍历总是指向Last 
while(Head_L!=Head)
{
cout <<Head_L->Element <<‘ ‘ ;
Head_L=Head_L->Last;
}
cout <<“反序遍历完毕” <<endl ; 
}

void Taverse(Position Head)
{
Position Head_L=Head->Next;
while(Head_L!=Head)
{
cout <<Head_L->Element <<‘ ‘;
Head_L=Head_L->Next; 
}
cout <<“n遍历完毕!n” ;
}

Position New=(struct Node *)malloc(LEN);
   if(New==NULL)
       cout <<“空间不足” <<endl ;
   New->Element=a[i];  //赋值 
   New->Next=Top;      //New与原先的栈顶连接 
   Top=New;            //New成为新的栈顶 
}
return Top;  
}

void Insert(Position Head)   //插入
{
int X,SubLabel;
Position New=NULL;
Position Head_L=Head->Next;
cout <<“请输入你要插入的元素值:” ;
cin >>X ;
cout <<“请输入你要插到的序号:” ;
cin >>SubLabel ;

void Inser(Position Head)  //插入一个元素 
{
int X,SubLabel;
cout <<“请输入要插入的元素:”;
cin >>X ;
cout <<“请输入要插到的序号:”;
cin >>SubLabel ;
if(SubLabel>0&&SubLabel<=GetListLenth(Head))
{
Position Head_L=Head->Next;
Position New=(struct Node *)malloc(LEN);  //开辟内存 
if(New==NULL)
   cout <<“内存不足!插入失败n” ; 
while(SubLabel-2)    //寻找要插入的位置的前一个元素的地址 
{
SubLabel–;
Head_L=Head_L->Next;
}
New->Element=X;  //赋值 
New->Next=Head_L->Next;
 //把New的下一个元素与要插入的位置对应的元素连接起来 
Head_L->Next=New;      
 //把New与要插入的位置的前一个元素连接起来,这样就实现了插入 
cout <<“插入后:” ;  
Taverse(Head);
}
else cout <<“输入的下标有误!n” ; 
}

void Traverse(Position Top)
{
if(IsEmpty(Top))
   cout <<“空栈!” <<endl ;
else 
{
GetStackTop(Top);
   while(Top->Next!=NULL)  //栈底连接的是NULL 
       {
       cout << Top->Element <<‘ ‘;
       Top=Top->Next;
       }
   cout <<“遍历完毕” <<endl ;
}
}

if(SubLabel>0&&SubLabel<=GetListLenth(Head))
{
while(SubLabel-1)   //找到链表要插入的位置 
       {
        Head_L=Head_L->Next;
        SubLabel–;
       }
   New=(struct Node *)malloc(LEN);
   if(New==NULL)
       cout <<“空间不足!” <<endl ;
   New->Element=X;    //赋值 
   New->Last=Head_L->Last;  //先把New与已有节点连接 
   New->Next=Head_L;
   Head_L->Last->Next=New;
 //趁着还有着Head_L的上一个节点位置,及早把它与New连接 
   Head_L->Last=New;        //最后把New与Head_L连接 
   Traverse(Head);  
}
else cout <<“输入的序号有误!” <<endl ;
}

void Delete(Position Head) //删除一个元素 
{
int SubLabel;
cout <<“请输入你要删除的序号:” ;
cin >>SubLabel ;
if(SubLabel>0&&SubLabel<=GetListLenth(Head))
{
Position Head_L=Head->Next;
Position Deletion=NULL;
while(SubLabel-2)  //寻找要插入的位置的前一个元素的地址 
{
SubLabel–;
Head_L=Head_L->Next;
}
Deletion=Head_L->Next;  //让要删除的元素与序号前一个元素连接起来 
Head_L->Next=Deletion->Next;
//让序号前一个元素与deletion的下一个元素连接起来,这样就实现了删除 
delete Deletion;  //delete释放空间 
cout <<“删除后:” ;
Taverse(Head);
}
else cout <<“输入的序号有误!n” ;
}

void GetStackTop(Position Top)
{
if(IsEmpty(Top))
   cout <<“空栈!” <<endl ;
else
cout <<“栈顶元素是:” <<Top->Element <<endl ;
}

void Delete(Position Head)
{
int SubLabel;
Position Head_L=Head->Next;
cout <<“请输入要删除元素对应的序号:” ;
cin >>SubLabel ;

int GetListLenth(Position Head)  //获取循环链表的元素个数 
{

void Push(Position Top)
{
int X;
Position New=NULL;
cout <<“请输入要入栈的元素:” ; 
cin >>X ;
New=(struct Node *)malloc(LEN);
if(New==NULL)
   cout <<“空间不足!” <<endl ;
New->Element=X;     //跟创建的时候的插入是一样的 
New->Next=Top;
Top=New;
cout <<“入栈后:” ;
Traverse(Top);
}

if(SubLabel>0&&SubLabel<=GetListLenth(Head))
{
while(SubLabel-1) //找到要删除的位置 
{
Head_L=Head_L->Next;
SubLabel–;
}
Head_L->Last->Next=Head_L->Next;
//把要删除的位置Head_L的前一个位置与Head_L的下一个位置连接起来 
Head_L->Next->Last=Head_L->Last; //建议画个图,很清晰 
delete Head_L;  //释放 
Traverse(Head);
}
else cout <<“输入的序号有误!” <<endl ;
}

int Lenth=0;
Position Head_L=Head->Next;
while(Head_L!=Head)
{
Lenth++;
Head_L=Head_L->Next;
}
return Lenth;
}

void Pop(Position Top) //出栈 
{
int X;
Position Deletion=NULL;
if(IsEmpty(Top))
   cout <<“空栈!” <<endl ;
else
{
cout <<“出栈后: ” ;
Top=Top->Next;   //栈顶的下面一个元素变成栈顶 
Traverse(Top);
}
}

int GetListLenth(Position Head)
 //获得元素个数,这与单链表,循环链表的想法是一样的 
{
int Lenth=0;
Position Head_L=Head->Next;
while(Head_L!=Head)
{
Lenth++;
Head_L=Head_L->Next;
}
return Lenth;
}