链表操作

//链表定义
struct Node_New
{
int num;
Node_New* next;
};

//创建链表
Node_New* Create()
{
Node_New *head, *newNode, *endNode;

int nNodeCount = 0;
head = NULL; //还没有任何节点，表头为空

newNode = new Node_New; //创建一个新节点
endNode = newNode;      //表尾指向新节点

cin >> newNode->num;

while (newNode->num != 0)
{
  nNodeCount += 1;

  if (nNodeCount == 1)
  {
   head = newNode;  //表头指向第一个新节点
  }
  else
  {
   endNode->next = newNode;
  }

  endNode = newNode;   //表尾指向新节点

  newNode = new Node_New;
  cin >> newNode->num;
}

delete newNode;
endNode->next = NULL;
return head;

}

//删除链表中的一个节点

Node_New* DeleteOneNode(Node_New* head, int num)
{
Node_New *SpecialNode, *PreNode;
if (head == NULL)
{
  return head;
}

SpecialNode = head;
while (SpecialNode->num != num && SpecialNode->next != NULL)
{
  PreNode = SpecialNode;
  SpecialNode = SpecialNode->next;
}

if (SpecialNode->num == num)
{
  if (head == SpecialNode)
  {
   head = SpecialNode->next;
  }
  else
  {
   PreNode->next = SpecialNode->next;
  }

  delete SpecialNode;
}
else
{
  cout << "没有发现该节点";
}
return head;
}

//返回链表长度
int ListLength(Node_New* L)
{
Node_New* p = L;
int count = 0;
while(p->next)
{
  count++;
  p = p->next;
}
return count;
}

//返回给定值在链表中的索引
int Search(Node_New* L, int value)
{
Node_New* pNode = L;
int index = 0;
while(pNode)
{
  if (pNode->num == value)
  {
   return index;
  }
  pNode = pNode->next;
  index++;
}
return 0;
}

//打印链表
void Print(Node_New* head)
{
Node_New* pNode = head;
while(pNode)
{
  cout << pNode->num<<endl;
  pNode = pNode->next;
}
}

//链表逆序（循环法）
Node_New* ReverseList(Node_New* head)
{
Node_New *p1, *p2, *p3;
p1 = head;
p2 = p1->next;

while (p2 != NULL)
{
  p3 = p2->next;
  p2->next = p1;

  p1 = p2;
  p2 = p3;
}
head->next = NULL;
head = p1;
return head;

}

//链表逆序（递归法）
Node_New* ReverseList2(Node_New* head)
{
if (!head)
{
  return NULL;
}

Node_New* temp = ReverseList2(head->next);

if (!temp)
{
  return head;
}

head->next->next = head;
head->next = NULL;

return temp;
}

//两个链表head1和head2各自有序， 将它们合并成一个链表，依然有序 （循环法）
Node_New* Merge(Node_New* head1, Node_New* head2)
{
Node_New* head;

if (head1 == NULL) return head2;

if (head2 == NULL)  return head1;

if (head1->num <= head2->num)
{
  head = head1;
  head1 = head1->next;
}
else
{
  head = head2;
  head2 = head2->next;
}

Node_New* temp = head;
while (head1 != NULL && head2 != NULL)
{
  if (head1->num <= head2->num)
  {
   temp->next = head1;
   head1 = head1->next;
   temp = temp->next;
  }
  else
  {
   temp->next = head2;
   head2 = head2->next;
   temp = temp->next;
  }
}

if (head1 = NULL) temp->next = head2;
if (head2 = NULL) temp->next = head1;
return head;
}

//两个链表head1和head2各自有序， 将它们合并成一个链表，依然有序 （递归法）
Node_New* Merge2(Node_New* head1, Node_New* head2)
{
if (head1 == NULL) return head2;

if (head2 == NULL)  return head1;

Node_New* head = NULL;

if (head1->num <= head2->num)
{
  head = head1;
  head->next = Merge2(head1->next, head2);
}
else
{
  head = head2;
  head->next = Merge2(head1, head2->next);
}

return head;
}

Node_New* InsertNode(Node_New* head, Node_New* p)
{
Node_New* newNode = p;
Node_New* p1 = head;
Node_New* p2;
if (head == NULL)
{
  head = p;
  p->next = NULL;
}
else
{
  while (newNode->num > p1->num && p1->next != NULL)
  {
   p2 = p1;
   p1 = p1->next;
  }

  if (newNode->num < p1->num)
  {
   p2->next = newNode;
   newNode->next = p1;
  }
  else
  {
   p1->next = newNode;
   newNode->next = NULL;
  }
}

return head;
}