Функция, которая вставляет новый элемент до каждого вхождения заданного элемента

Question

Функция, которая вставляет новый элемент до каждого вхождения заданного элемента

На с++ Написать программу, содержащую функцию, которая вставляет новый элемент перед каждым вхождением заданного элемента. Если элементы не найдены, то выдать на экран соответствующее сообщение.
Программа есть, но здесь вставляется уже ПОСЛЕ элемента, а не ДО.

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <sstream>
#include <clocale>
#include <cmath>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct Node* NodePtr ;

struct Node
{
int value;
NodePtr next;
}
void Insert(NodePtr L, NodePtr E, NodePtr E1)
{

NodePtr curr;
NodePtr elem;
int v,v1;
v=E->value;
v1=E1->value;
curr=L;
while (curr)
{

if (curr->value==v)
{
elem =new Node();
elem->value=v1;
elem->next=curr->next;
curr->next=elem;
}
curr=curr->next;
}
}
int main(int argc, char** argv)
{
setlocale(LC_CTYPE, "rus");
srand (time(NULL));
NodePtr head = NULL;
NodePtr* ptr = &head;
for (int n=1;n<=20;++n)
{
*ptr = new Node;
(*ptr)->value = rand() % 4 + 1;
ptr = &(*ptr)->next;
}
*ptr = NULL;

std::cout << "Начальный список\n";
NodePtr p = head;
while (p)
{
std::cout << p->value << ' ';
p = p->next;
}
std::cout << "\n";

NodePtr ptr1 = new Node;
int num;
std::cout << "\nВведите элемент E: ";std::cin>>num;
ptr1->value = num;
NodePtr ptr2 = new Node;
std::cout << "\nВведите элемент F: ";std::cin>>num;
ptr2->value = num;
p = head;
Insert(p, ptr1, ptr2);

p = head;
std::cout <<"\n";
while (p)
{
std::cout << p->value << ' ';
p = p->next;
}
std::cout << "\n";
while (head)
{
NodePtr victim = head;
head = head->next;
delete victim;
}

system("PAUSE");
return 0;
}

Павел Терентьев

200

23.12.2022

Похожие вопросы

Answer 1 · 2022-10-23 00:43:12

 #include  

using namespace std; 

template 

struct Node { 

    T value; 

    Node* next; 

    Node() : value(T()), next(nullptr) {} 

}; 

template 

class List { 

public: 

    using size_type = size_t; 

    ~List() { 

        if (tail != nullptr) { 

            while (!empty()) { 

                pop(); 

            } 

        } 

    } 

    bool empty()const noexcept { 

        return tail == nullptr; 

    } 

    void push(const T& val) { 

        Node* ptr = new Node; 

        ptr->value = val; 

        if (empty()) { 

            head = tail = ptr; 

        } else { 

            tail->next = ptr; 

            tail = ptr; 

        } 

        ++length; 

    } 

    void pop() { 

        if (!empty()) { 

            if (tail == head) { 

                delete tail; 

                tail = head = nullptr; 

            } else { 

                Node* tmp = head; 

                while (tmp->next != tail) {  

                    tmp = tmp->next; 

                } 

                delete tail; 

                tail = nullptr; 

                tail = tmp; 

            } 

            --length; 

        } 

    } 

    Node* insert(Node* position, const T& source) { 

        Node* ptr = new Node; 

        ptr->value = source; 

        if (position == head) { 

            ptr->next = head; 

            head = ptr; 

        } else { 

            Node* tmp = head; 

            while (tmp->next != position) { 

                tmp = tmp->next; 

            } 

            tmp->next = ptr; 

            ptr->next = position; 

        } 

        ++length; 

        return ptr; 

    } 

    void anywhere(const T& target, const T& source) { 

        Node* tmp = head; 

        while (tmp != tail->next) { 

            if (tmp->value == target) { 

                tmp = insert(tmp, source); 

                tmp = tmp->next; 

            } 

            tmp = tmp->next; 

        } 

    } 

    void show()const { 

        Node* tmp = head; 

        while (tmp != tail->next) { 

            cout value next; 

        } 

        puts(""); 

    } 

    T& front() { 

        return head->value; 

    } 

    T& back() { 

        return tail->value; 

    } 

    size_type size()const { 

        return length; 

    } 

private: 

    Node* head; 

    Node* tail; 

    size_type length; 

}; 

int main() { 

    List list; 

    list.push(25); 

    list.push(36); 

    list.push(25); 

    list.push(54); 

    list.push(25); 

    list.show(); 

    cout

Григорий Гаража

90 887

Лучший ответ

23.10.2022

Answer 2 · 2022-10-23 06:27:33

 #include   

#include  //зачем придумывать велосипед с вашими *node_ptr? 

 

bool insertings_before(std::list& LIST, int val_if, int val_then) 

{ 

	bool ret{false}; //была ли вставка 

	for (auto it = LIST.rbegin(); it != LIST.rend(); it++) //идем с конца листа реверсивным итератором 

	{ 

		if (*it == val_if) //если встречаем нужный элемент 

		{ 

			auto ins_it = it.base(); //создаем обычный итератор 

			std::advance(ins_it, -1); //уменьшаем его на один чтобы вставка была слева 

			LIST.insert(ins_it, val_then); //вставляем 

			ret = true; //запоминаем факт вставки 

			it++; //корректируем основной итератор, ктоторый сместился из за вставки 

		} 

	} 

	return ret; //возвращаем была ли вставка 

} 

 

int main() 

{ 

	std::list LIST{ 10,4,33,5,10,3,11,101,45,10,33,21,0,56,67,10,9 }; //ваш лист 

	int x = 10; // значение перед которым нужно вставлять новый элемент 

	if (insertings_before(LIST, x, 777)) // вставляем в ЛИСТе перед элементами х значение 777 

		for (auto& i : LIST) std::cout

Денис Бунеев

51 416

23.10.2022

Answer 3 · 2022-10-22 20:29:26

 #include  

#include  

#include  

#include  

 

#define NIL NULL 

 

#define ELEM_COUNT                        20 

 

#define get_number(fmt, txt, var)   \ 

    printf(txt); scanf(fmt, &var) 

 

typedef struct __cons_t 

{ 

    int value; 

    struct __cons_t *next; 

 

} *cons_t; 

 

static cons_t cons(int value, cons_t next) 

{ 

    cons_t _new = malloc(sizeof(struct __cons_t)); 

     

    _new->value = value; 

    _new->next = next; 

 

    return _new; 

} 

 

static void cons_free(cons_t _cons) 

{ 

    cons_t next = _cons->next; 

 

    free(_cons); 

 

    if (next != NIL) cons_free(next); 

} 

 

static void cons_print(const cons_t _cons) 

{ 

    printf("%d ", _cons->value); 

 

    if (_cons->next == NIL) 

    { 

        printf("nil"); 

        return; 

    } 

 

    cons_print(_cons->next);} 

 

inline void cons_println(const cons_t _cons) 

{ 

    cons_print(_cons); 

    printf("\n"); 

} 

 

int main(void) 

{ 

    srand(time(NULL)); 

 

    cons_t list = cons(0, NIL); 

     

    for (int i = 0; i < ELEM_COUNT; i++) 

        list = cons(rand() % 4 + 1, list); 

 

    puts("Current list:"); 

    cons_println(list); 

 

    int e, f; 

 

    get_number("%d", "Enter E: ", e); 

    get_number("%d", "Enter F: ", f); 

 

    list = cons(e, cons(f, list)); 

 

    cons_println(list); 

    cons_free(list); 

    return 0; 

}

Владимир Проценко

1 893

22.10.2022

Владимир Проценко Думаю, что я тебя правильно понял

Владимир Проценко Исправь:

 cons_t _new = (cons_t) malloc(sizeof(struct __cons_t));

Владимир Проценко

 // Создает новую cons ячейку

static cons_t cons(int value, cons_t next);



// Освобождает память всех ячеек cons списка

static void cons_free(cons_t _cons);



// Выводит на экран cons список(list)

static void cons_print(const cons_t _cons);



// Выводит на экран cons список(list) с переносом на новую строку

inline void cons_println(const cons_t _cons);

Подробнее про cons:
https://ru.wikipedia.org/wiki/Cons