链表相关的算法题大汇总 （1）— 数据结构之链表奇思妙想

声明：转自http://hi.baidu.com/lanxuezaipiao/item/afc616caf8393a155050585b

基本函数（具体代码实现见后面）

1，构造节点

 //定义节点类型

struct Node

{

    int value;

    Node*next;

};

 

2，分配节点

//之所以要分配节点原因是需要在分配函数中进行初始化，并且也利于判断是否分配成功。

Node* applyNode();

 

3，在头部增加节点

//增加节点在头部（无头结点）,返回值的原因是由于传入并非指针的引用。

Node* addNodeH(Node* Head,Node* InsertNode);

 

4，在尾部增加节点

//增加节点在尾部（无头结点）,返回值的原因是由于传入并非指针的引用。

Node* addNodeT(Node* Head,Node* InsertNode);

 

5，以升序方式增加节点
Node* addNodeSort(Node* Head,Node* InsertNode);

 

6，构造链表

//没有额外的表头结点。

//选择参数choose分别对应以何种方式构造链表，1为头部增加节点；2为尾部增加节点；3为升序增加节点。

Node* createList(int n,int choose);

 

7，打印链表
void printList(Node*Head);

 

8，释放链表
void freeList(Node*& Head);

 

9，链表节点数
int numOfNodes(Node* Head);

 

10，定位函数

//传入参数i表示第几个节点（从1开始），返回该节点指针

Node* locateNodeI(Node*Head,int i);

 

11，查找函数

//查找值为value的链表

int SearchList(Node*Head,int value);

 

12，删除节点

//删除位置i的节点

bool deleteNodeI(Node*&Head,int i);

 

13，排序函数

//冒泡排序链表，具体的做法是“狸猫换太子”，即只交换节点中的值，对链表结构不做改动。

void sortList(Node*& Head);

 

基本函数代码：

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------

2，分配节点

//分配节点

//将分配内存和初始化该节点放在一个函数中

Node* applyNode()

{

 Node* newNode;

 if((newNode=(Node*)malloc(sizeof(Node)))==NULL)

 {

  cout<<"分配内存失败！"<<endl;

  ::exit(0);

 }

 //建立该节点信息：

 cout<<"请输入本节点值："<<endl;

 cin>>newNode->value;

 newNode->next=NULL;

 return newNode;

}

3，在头部增加节点

//在表头增加节点

//在头指针所指向的链表中增加一个节点,插入头部

//这里必须要返回Node*来进行更新，因为传入的Head是Node*类型，而非Node*&

Node* addNodeH(Node* Head,Node* InsertNode)

{

 if(Head==NULL)

 {

  Head=InsertNode;

 }

 else

 {

  InsertNode->next=Head;

  Head=InsertNode;

 }

 return Head;

}

4，在尾部增加节点

//在表尾增加节点

//在头指针所指向的链表中增加一个节点,插入尾部

//这里必须要返回Node*来进行更新，因为传入的Head是Node*类型，而非Node*&

Node* addNodeT(Node* Head,Node* InsertNode)

{

 if(Head==NULL)

 {

  Head=InsertNode;

 }

 else

 {

  Node* p=Head;

  while(p->next!=NULL)

  {

   p=p->next;

  }

  p->next=InsertNode;

 }

 return Head;

}

5，以升序方式增加节点

//以升序增加节点

//这里必须要返回Node*来进行更新，因为传入的Head是Node*类型，而非Node*&

Node* addNodeSort(Node* Head,Node* InsertNode)

{

 if(Head==NULL)

 {

  Head=InsertNode;

 }

 else

 {

  Node* p=Head;

  //注意，这里把(p->value)<(InsertNode->value)放在p->next!=NULL前面是有原因的，这是避免为了考虑在Head->[4]加入[1]的情况

  while((p->value)<(InsertNode->value)&&p->next!=NULL)

  {

   p=p->next;

  }

  if((p->value)>=(InsertNode->value))//因为（(p->value)>=(InsertNode->value)）而退出！表示在p前增加节点（狸猫换太子）

  {

   //先在p后增加节点

   InsertNode->next=p->next;

   p->next=InsertNode;

   //再交换p和InsertNode的值

   swap(p->value,InsertNode->value);

  }

  else//因为（p->next==NULL）而退出！表示在尾增加节点

  {

   p->next=InsertNode;

  }

 }

 return Head;

}

6，构造链表

//建立n个节点的链表 choose=1,在表头加入，choose=2在表尾加入,choose=3按value值升序加入

Node* createList(int n,int choose)

{

 Node *Head=NULL,*p=NULL;

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

 {

  p=applyNode();

  if(choose==1)

  {

   Head=addNodeH(Head,p);

  }

  else if(choose==2)

  {

   Head=addNodeT(Head,p);

  }

  else if(choose==3)

  {

   Head=addNodeSort(Head,p);

  }

 }

 return Head;

}

7，打印链表

//遍历链表并输出

void printList(Node*Head)

{

 Node*p=Head;

 while(p!=NULL)

 {

  cout<<p->value<<"->";

  p=p->next;

 }

 cout<<"NULL"<<endl;

}

8，释放链表

//释放链表

void freeList(Node*& Head)

{

 Node* tmp=Head;

 while(tmp!=NULL)

 {

  Head=Head->next;

  free(tmp);

  tmp=Head;

 }

 Head=NULL; 

}

9，链表节点数

//数节点个数

int numOfNodes(Node* Head)

{

 int count=0;

 while(Head!=NULL)

 {

  count++;

  Head=Head->next;

 }

 return count;

}

10，定位函数

//定位第i个节点，i从1开始

Node* locateNodeI(Node*Head,int i)

{

 //cout<<"定位"<<i<<"位置"<<endl;

 Node* pos=NULL;

 int count=numOfNodes(Head);

 if(i<=0||i>count)

 {

  cout<<"定位越界！"<<endl;

 }

 else 

 {

  pos=Head;

  for(int j=1;j<i;j++)

  {

   pos=pos->next;

  }

 }

 return pos;

}

11，查找函数

//查找值value并返回第一个出现该值的位置，如果需要引用其指针，可以再locate该位置

int SearchList(Node*Head,int value)

{

 Node* p=Head;

 int pos=0;

 bool find=false;

 while(p!=NULL)

 {

  pos++;

  if(p->value==value)

  {

   find=true;

   break;

  }

  p=p->next;

 }

 if(find)

  return pos;

 else 

  return -1;

}

12，删除节点

//删除某位置i的节点

bool deleteNodeI(Node*&Head,int i)

{

 Node* p=locateNodeI(Head,i);

 if(p==NULL)

 {

  return false;

 }

 else

 {

  if(p==Head)//说明p是头节点。

  {

   Head=p->next;

   free(p);

  }

  else

  {

   Node* prep=locateNodeI(Head,i-1);//定位前一个,必定存在 

   prep->next=p->next;

   free(p);

  }

  return true;

 }

}

13，排序函数

//链表排序

//排序的方法是不破坏结构，有“狸猫换太子”的意思，只进行value的交换，不破坏链表结构

void sortList(Node*& Head)

{

 int count=numOfNodes(Head);

 if(count==0||count==1)

 {

  return ;

 }

 //冒泡排序

 bool exchange;

 for(int i=2;i<=count;i++)

 {   

  exchange=false;

  for(int j=count;j>=i;j--)

  {

   Node* p1=locateNodeI(Head,j);

   Node* p2=locateNodeI(Head,j-1);

   if(p1->value<p2->value)

   {

    exchange=true;

    swap(p1->value,p2->value);

   }

  }

  if(!exchange)

   break;

 }

}