Linked list issue with insert

step one should be to make the list into an object instead of just keeping a bunch of pointers around in main(). you want an object called List that knows about it's own first (and maybe last) elements. it should also have methods like List.append() and List.insert().

your current code is nigh unreadable.

Use a std::list, unless this is homework, in which case it needs tagging as such.

In my experience, I have learned to start small and test, then build up. I'll guide you through these steps.

BTW, a linked list is a container of nodes. So we'll start with the node class first.

Minimally, a node must have a pointer to another node:

#include <iostream>
#include <cstdlib> // for EXIT_SUCCESS
#include <string>

using std::cout;
using std::endl;
using std::cerr;
using std::cin;
using std::string;

struct Node
{
  // Add a default constructor to set pointer to null.
  Node()
  : p_next(NULL)
  { ; }

  Node * p_next;
};

// And the testing framework
int main(void)
{
  Node *  p_list_start(NULL);

  // Allocate first node.
  p_list_start = new Node;

  // Test the allocation.
  // ALWAYS test dynamic allocation for success.
  if (!p_list_start)
  {
    cerr << "Error allocating memory for first node." << endl;
    return EXIT_FAILURE;
  }

  // Validate the constructor
  ASSERT(p_list_start->p_next == 0);

  // Announce to user that test is successful.
  cout << "Test successful." << endl;

  // Delete the allocated object.
  delete p_list_start;

  // Pause if necessary.
  cin.ignore(100000, '\n'); // Ignore input chars until limit of 100,000 or '\n'

  return EXIT_SUCCESS;
}

Compile, and run this simple test. Fix errors until it runs correctly.

Next, modify the tester to link two nodes:

int main(void) { Node * p_list_start(NULL); Node * p_node(NULL); // <-- This is a new statement for the 2nd node. //...

  // Validate the constructor
  ASSERT(p_list_start->p_next == 0);

  // Allocate a second node.
  p_node = new Node;
  if (!p_node)
  {
      cerr << "Error allocating memory for 2nd node." << endl;

      // Remember to delete the previously allocated objects here.
      delete p_list start;

      return EXIT_FAILURE;
  }

  // Link the first node to the second.
  p_list_start->Link_To(p_node);

  // Test the link
  ASSERT(p_list_start.p_next == &p_node);

  //...

  // Delete the allocated object(s)
  delete p_list_start;
  delete p_node;

  //...

}

Compile with the modifications.
It failed to compile, undefined method: Node::Link_To
Not to worry, this is expected. Show us the compiler is working. :-)

Add the Link_To method to the Node structure:

struct Node
{
  // ...
  void Link_To(const Node& n)
  {
     p_next = &n;
     return;
  }
  //...
};

Compile and run. Test should pass.

At this point the linking process has been validated. Onto adding content to the node.

Since the Node object has been tested, we don't want to touch it. So let's inherit from it to create a node with content:

struct Name_Node
: public Node  // Inherit from the tested object.
{      
    std::string  name;
    std::string  phone;
};

If you haven't learned inheritance yet, you can append to the existing node:

struct Node
{
  //...
  std::string  name;
  std::string  phone;
}

At this point you can add functions for setting and displaying content. Add the testing statements. Run and validate.

The next step would be to create two content nodes and link them together. As you build up, keep the testing code. Also, if stuff works you may want to put the functionality into separate functions.

For more information on this process, check out Test Driven Development.