链表

//单项链表反向
node *nodereverse(node *head)
{
    //如果一个函数的输入参数有指针，一定要记住判断指针时候为空
    //1>:在使用一个指针之前一定要判断它是否为空;
    //2>:使用完后要释放由指针指向的存储单元
    //3>:释放完存储单元后要将指针赋值为NULL;
     if(head->next==NULL || head==NULL)
          return head;

     node* temp1=head;
     node* temp2=NULL;
     node* temp3=head->next;
     temp1->next = NULL; //tem1为头，所以temp1->next赋值null.
     //要注意这里面的顺序,先将temp3保存在temp2中，
     //然后再将temp3移动到下一个元素，然后才能改动temp2
     //
     while(temp3->next!=NULL)
     {
        temp2 = temp3;
        temp3 = temp3->next;
        temp2->next = temp1;//不能再temp3= temp3->next;之前执行
        temp1 = temp2;

     }
     temp3->next = temp1;//一定是temp1,因为当只有两个结点时，如果temp3->next=temp2是错的
     return temp3;
}

#include<stdio.h>
#include <stdlib.h>

//创建一个单向链表,实现插入和删除一个结点功能
typedef struct Node
{
	int data;
	struct Node *next;
}linkList;

linkList* initLink(int *a,int n)
{

	linkList *h,*newp,*t;

	h=t=(linkList*)malloc(sizeof(linkList));//开辟内存空间,初始化头结点

	h->data = a[0];//此头结点的数据域有值
	h->next=NULL;
	int i;

    	for(i=1;i<n;i++)
    	{
		newp=(linkList*)malloc(sizeof(linkList));
		newp->data = a[i];
		newp->next = NULL;

		t->next=newp;
		t=newp;
	}

	return h;
}

void printLink(linkList* head)
{
	linkList* p;
	for(p=head;p!=NULL;p=p->next)
	{
		printf("%d\n",p->data);
	}

}


void deleteNode(linkList *head,int pos)
{
    int j=1;
    linkList *p=head;

    while(p && (j<(pos-1)))
    {
        p=p->next;
        j++;
    }
    if(!p || j>(pos-1))
    {
        printf("出错");
        exit(-1);
    }

    p->next=p->next->next;

}

void InsertNode(linkList *head,int pos,int data)
{

    int j=1;
    linkList *p=head;
    linkList *newp;

    while(p && (j<(pos-1)))
    {
        p=p->next;
        j++;
    }
    if(!p || j>(pos-1))
    {
        printf("出错");
        exit(-1);
    }

    newp=(linkList *)malloc(sizeof(linkList));
    newp->data=data;

    //先后顺序不能乱
    newp->next=p->next;
    p->next=newp;


}

int main(void)
{

	int a[6]={1,2,3,4,5,6};
	linkList * head;

	head=initLink(a,6);
	InsertNode(head,4,9);
	deleteNode(head,4);

	printLink(head);

	return 0;

}

 #include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//创建一个双向链表
typedef struct DoubleLinkNode
{
   int data;
   struct DoubleLinkNode *prev;
   struct DoubleLinkNode *next;
}Node;

 /* 创建一个带头节点的双向链表
 实现插入和删除结点功能
 */
Node*Create_Double_link(int n)
{
    Node*head;
    Node*pnew;
    Node*t;

    head=(Node*)malloc(sizeof(Node));
    //head->data=100;//带头，不赋值

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


    t=head;
    for(int i=0;i<n;i++)
    {
     pnew=(Node*)malloc(sizeof(Node));
     pnew->data=i+1;
     pnew->next=NULL;

     t->next=pnew;
     pnew->prev=t;

     //t=t->next;//效果和下面一样
     t=pnew;
    }



    return head;
}
/* 输出每一个节点的数据 */
void print(Node*head)
{
  Node*temp;

  temp=head;
  while(temp->next!=NULL)
  {
     printf("%d\n",temp->next->data);
     temp=temp->next;
  }

}


void deleteNode(Node *head,int pos)
{
    int j=1;
    Node *p=head;
    Node *s;

    while(p && (j<(pos-1)))
    {
        p=p->next;
        j++;
    }
    if(!p || j>(pos-1))
    {
        printf("出错");
        exit(-1);
    }

    s=p->next->next;
    s->prev=p;
    p->next=s;



}

void insertNode(Node *head,int pos)
{
    int j=1;
    Node *p=head;
    Node *pt=NULL;

    Node *newp=(Node *)malloc(sizeof(Node));
    newp->data=2;


    while(p && (j<(pos-1)))
    {
        p=p->next;
        j++;
    }
    if(!p || j>(pos-1))
    {
        printf("出错");
        exit(-1);
    }

    pt=p->next;

    newp->next=pt;
    pt->prev=newp;

    p->next=newp;
    newp->prev=p;



}

 /* 主函数 */
int main(int argc,char**argv)
{
   Node* head;
   head=Create_Double_link(5);
   insertNode(head,3);
   deleteNode(head,3);

   print(head);
   return 0;
}