链表操作

//链表定义
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;
}