单链表

#include<iostream>
using namespace std;
 
//单链表结构体
typedef struct student
{
    int data;
    struct student *next;
}node;
 
//建立单链表
node *create()
{
    node *head,*p,*s;
    int x,cycle=1;
    head=(node*)malloc(sizeof(node)); //建立头节点
    p=head;
    while(cycle)
    {
        printf("
Please input the data:");
        scanf("%d",&x);
        if(x!=0)
        {
            s=(node*)malloc(sizeof(node));//每次新建一个节点
            s->data=x;
            printf("
%d",s->data);
            p->next=s;
            p=s;
        }
        else
        {
            cycle=0;
        }
    }
    head=head->next;
    p->next=NULL;
    printf("
   yyy   %d",head->data);
    return (head);
}
 
//单链表测长
int length(node *head)
{
    int n=0;
    node *p;
    p=head;
    while(p!=NULL)
    {
        p=p->next;
        n++;
    }
    return (n);
}
 
//单链表打印
void print(node *head)
{
    node *p;
    int n;
    n=length(head);
    printf("
Now,These %d records are :
",n);
    p=head;
    if(head!=NULL)
        p=p->next;
    while(p!=NULL)
    {
        printf("
   uuu  %d    ",p->data);
        p=p->next;
    }
}

//单链表删除节点
node *remove(node *head ,int num)
{
    node *p1,*p2;
    p1=head;
    while(num!=p1->data && p1->next!=NULL)//查找data为num的节点
    {
        p2=p1;
        p1=p1->next;
    }
    if(num==p1->data) //如果存在num节点，则删除
    {
        if(p1==head)
        {
            head=p1->next;
            free(p1);
        }
        else
        {
            p2->next=p1->next;
        }
    }
    else
    {
        printf("
%d could not been found",num);
    }
    return (head);
}

//单链表插入节点
node *insert(node *head,int num)
{
    node *p0,*p1,*p2;
    p1=head;
    p0=(node *)malloc(sizeof(node));
    p0->data=num;
    while(p0->data > p1->data && p1->next!=NULL)
    {
        p2==p1;
        p1=p1->next;
    }
    if(p0->data<=p1->data)
    {
        if(head==p1)
        {
            p0->next=p1;
            head=p0;
        }
        else
        {
            p2->next=p0;
            p0->next=p1;
        }
    }
    else
    {
        p1->next=p0;
        p0->next=NULL;
    }
    return (head);
}

//单链表排序
node *sort(node *head)
{
    node *p,*p2,*p3;
    int n;
    int temp;
    n=length(head);
    if(head==NULL ||head->next==NULL)//如果只有一个或者没有节点
        return head;
    p=head;
    for(int j=1;j<n;++j)
    {
        p=head;
        for(int i=0;i<n-j;++i)
        {
            if(p->data > p->next->data)
            {
                temp=p->data;
                p->data=p->next->data;
                p->next->data=temp;
            }
            p=p->next;
        }
    }
    return (head);
}

//单链表逆置
node *reverse(node *head)
{
    node *p1,*p2,*p3;
    if(head==NULL || head->next==NULL)
        return head;
    p1=head;
    p2=p1->next;
    while(p2)
    {
        p3=p2->next;
        p2->next=p1;
        p1=p2;
        p2=p3;
    }
    head->next=NULL;
    head=p1;
    return head;
}

//删除单链表的头元素
void RemoveHead(node *head)
{
    node *p;
    p=head;
    head=head->next;
    free(p);
}

//给出一个单链表，不知道节点N的值，怎么只遍历一次就可以求出中间节点
void searchmid(node *head,node *mid)
{
    node *p,*q;
    p=head;
    q=head;
    while(p->next->next!=NULL)
    {
        p=p->next->next;
        q=q->next;
        mid=q;
    }
}

给定一个单向链表，设计一个时间优化并且空间优化的算法，找出该链表的倒数第m个元素。实现您的算法，注意处理相关的出错情况。m定义为当m=0时，返回链表最后一个元素。

    解析：这是一个难题，我们需要的是倒数第m个元素，所以如果我们从某个元素开始，遍历了m个元素之后刚好到达链表末尾，那么这个元素就是要找的元素。也许从链表的尾部倒推回去不是最好的办法，那么我们可以从链表头开始计数。

    思路一：我们可以先一次遍历求出链表的总长度n，然后顺序变量求出第n-m个元素，那么这个就是我们要找的元素了。

    思路二：我们用两个指针，一个当前位置指针p和一个指向第m个元素的指针q，需要确保两个指针之间相差m个元素，然后以同样的速度移动它们，如果当q到达链表末尾时，那么p指针就是指向倒数第m个元素了。

    答案：

//思路一
node *searchLastElement1(node *head,int m)
{
    if(head==NULL)
        return NULL;
    node *p=head;
    int count=0;
    while(p!=NULL)
    {
        p=p->next;
        count++;
    }
 
    if(count<m)
        return NULL;
 
    p=head;
    for(int i=0;i<count-m;i++)
    {
        p=p->next;
    }
    return p;
}
 
//思路二
node *searchLastElement2(node *head,int m)
{
    if(head==NULL)
        return NULL;
    node *p,*q;
    p=head;
    for(int i=0;i<m;i++)
    {
        if(p->next!=NULL)
        {
            p=p->next;
        }
        else
        {
            return NULL;
        }
    }
 
    q=head;
    while(p->next!=NULL)
    {
        p=p->next;
        q->next;
    }
    return q;
}

 已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序。(保留所有结点，即便大小相同）

Node * Merge(Node *head1 , Node *head2)
{
    if ( head1 == NULL)
        return head2 ;
    if ( head2 == NULL)
        return head1 ;
    Node *head = NULL ;
    Node *p1 = NULL;
    Node *p2 = NULL;
    if ( head1->data < head2->data )
    {
        head = head1 ;
        p1 = head1->next;
        p2 = head2 ;
    }
    else
    {
        head = head2 ;
        p2 = head2->next ;
        p1 = head1 ;
    }
    Node *pcurrent = head ;
    while ( p1 != NULL && p2 != NULL)
    {
        if ( p1->data <= p2->data )
        {
            pcurrent->next = p1 ;
            pcurrent = p1 ;
            p1 = p1->next ;
        }
        else
        {
            pcurrent->next = p2 ;
            pcurrent = p2 ;
            p2 = p2->next ;
        }
    }
    if ( p1 != NULL )
        pcurrent->next = p1 ;
    if ( p2 != NULL )
        pcurrent->next = p2 ;
    return head ;
}

已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序，这次要求用递归方法进行。

Node * MergeRecursive(Node *head1 , Node *head2)
{
    if ( head1 == NULL )
        return head2 ;
    if ( head2 == NULL)
        return head1 ;
    Node *head = NULL ;
    if ( head1->data < head2->data )
    {
        head = head1 ;
        head->next = MergeRecursive(head1->next,head2);
    }
    else
    {
        head = head2 ;
        head->next = MergeRecursive(head1,head2->next);
    }
    return head ;
}

 如何判断一个单链表是有环的？（注意不能用标志位，最多只能用两个额外指针）

struct node { char val; node* next;}
   bool check(const node* head) {} //return false : 无环；true: 有环一种O（n）的办法就是（搞两个指针，一个每次递增一步，一个每次递增两步，如果有环的话两者必然重合，反之亦然）：
bool check(const node* head)
{
    if(head==NULL)  returnfalse;
    node *low=head, *fast=head->next;
    while(fast!=NULL && fast->next!=NULL)
    {
        low=low->next;
        fast=fast->next->next;
        if(low==fast) returntrue;
    }
    return false;
}

双链表

//待验证，待完善
#include "stdafx.h"
#include <stdio.h>
#include <iostream>
using namespace std;
typedef struct NODE
{
    int data;
    struct NODE *pre;
    struct NODE *next;
}node;

node *create()
{
    node *head, *tmp, *pnode;
    int x,cycle = 1;
    head = (node*)malloc(sizeof(node));
    tmp = head;
    while (cycle)
    {
        scanf("%d",&x);
        if (x != 0)
        {
            pnode = (node*)malloc(sizeof(node));
            pnode->data = x;
            tmp->next = pnode;
            pnode->pre = tmp;
            tmp = pnode;
        }
        else
            cycle = 0;
    }
    head = head->next;
    tmp->next = NULL;
    head->pre = NULL;
    printf("%d
",head->data);
    return head;
}

node *del(node*head, int num)
{
    node *tmp;
    tmp = head;
    while (num != tmp->data && tmp->next != NULL)
    {
        tmp = tmp->next;
    }
    if (num == tmp->data)
    {
        if (tmp == head)
        {
            head = tmp->next;
            head->pre = NULL;
            free(tmp);
        }
        else if (tmp->next == NULL)
        {
            tmp->pre->next = NULL;
        }
        else
        {
            tmp->pre->next = tmp->next;
            tmp->next->pre = tmp->pre;
        }
        return head;
    }
}

node* insert(node*head, int num)
{
    node *p0, *p1;
    p1 = head;
    p0 = (node*)malloc(sizeof(node));
    p0->data = num;
    while (p0->data > p1->data && p1->next != NULL)
    {
        p1 = p1->next;
    }
    if (p0->data <= p1->data)
    {
        if (head == p1)
        {
            p0->next = p1;
            p1->pre = p0;
            head = p0;
        }
        else if (p1->next != NULL)
        {
            p1->next = p0;
            p0->pre = p1;
            p0->next = NULL;
        }
        else
        {
            p1->pre->next = p0;
            p0->next = p1;
            p0->pre = p1->pre;
            p1->next = p0;
        }
    }
    return head;
}

int _tmain(int argc, _TCHAR* argv[])
{
    create();
    return 0;
}