Void dop1 ( stack*&s )
{
stack * stnew;
stnew = new ( stack) ;
cout<<”\nВведите данные data = “;
cin>>stnew ->data;
stnew->next=s;
s = stnew ;
}
//-----------------------------------------------------------------------------
//Функция удаления элемента. Возвращает данное удаляемого эл. :
int ud ( stack *&s ) //ссылка указатель на вершину
{
stack * fr = s// удаляемый элемент – является вершиной стека
// указатель на него – это указатель на вершину
int k =0;
if (s) { k= fr ->data ; //информацию помещаем в переменную k
s = fr ->next; // указателю на вершину присваиваем адрес
// следующего элемента
delete fr;// освобождаем память
}
return k; // функция возвращает информацию
}
//-----------------------------------------------------------------------------------
//Функция чтения из вершины стека.
//Т.к. значение указателя на вершину стека не изменяется в функции //чтения, формальным параметром может быть сам указатель на //вершину
Int cht ( stack *s )
{ if (s) return (s -> data ); }
//-----------------------------------------------------------------
//Рекурсивная функция выводит все содержимое стека
Int cht1 ( stack *s )
{ if (s == null)
{cout<<”\nПрочли все элементы стека”; return;}
cout<<”\n data = “ <<s->data;
cht1(s->next);
}
//---------------------------------------------------------------------------
Void main ( )
{
stack*beg1;
for ( int i=1 ; i< =10 ; i++)
dop ( beg , i );
beg1=beg;
for ( int i=0 ; i< 10 ; i++)
{
cout<<cht(beg1); beg1=beg1->next;
}
//cht1(beg);
cout<<’\n’<<ud(beg);
cht1(beg);
}
Очередь
Очередь – это связанная структура данных, в которой добавлять элементы можно только в конец (хвост) очереди, а удалять и читать можно только элементы с начала (вершина) очереди.
первый элемент последний
очереди
элемент
data
next
data
next
data
next
…
0
data
next
новый
элемент
//------------------------------------------------------------------------------------------------
// Функция добавления элемента в конец очереди
#include <iostream>
using namespace std;
struct qu { int data ; qu* next ; }; //узел
void dop ( qu *&s, int dat) // ссылка на указатель на начало
// очереди
{ qu * p = s, //тек. указатель устанавливаем на начало очереди
*q = 0, // всп. yказатель на null
*nst = new ( qu) ; // выделили память для нового элемента
nst ->data = dat;
nst->next=nullptr; // это последний элемент очереди
while ( p) // пока указатель не достигнет нулевого значения
{ q=p ; p= p ->next ; }; //продвигаемся по очереди к концу
if (q) q ->next= nst ; // последний ненулевой элемент должен
// указывать на новый элемент
else s = nst; // новый элемент первый в очереди
}
//------------------------------------------------------------------------------
// Функция удаления элемента из очереди, возвращает удаляемую //информацию. Удаление производится из вершины очереди
int ud ( qu*&s)
{ int k=0;
qu* fr =s // указатель на начало очереди
if(s)
{ k = s -> data ; s = s -> next ; delete fr;}
return k; }
//----------------------------------------------------------------------------------
// Функция чтения элемента из начала очереди
int cht ( qu*s )
{ if(s) return s ->data ; }
//-------------------------------------------------------------------------
// Функция чтения элементов очереди рекурсивная
int cht1 ( qu*s )
{ if(s==null) {cout<<”\nэлементов больше нет”; return;}
cout<<”\n data = “<< s->data;
cht1(s->next);
}
////-------------------------------------------------------------------------
// Функция чтения элементов очереди итерационная
int cht2 ( qu*s )
{qu* list=s;
if(list==null) cout<<”\nэлементов нет”;
else while(list)
{cout<<”\n data = “<< list->data;
list=list->next;}
}
qu * s1; // объявлен указатель на очередь глобальный
//------------------------------------------------------------------------------