单链表输出倒数第k个结点值（栈实现）

思路1：定义两个指针变量p和q，初始时均指向头节点的下一个节点（链表的第一个节点），p指针沿链表移动；
　　当p指针移动到第k个节点时，q指针开始与p指针同步移动，
　　当p指针移动到最后一个节点时，q指针所指节点就是倒数第k个节点。

思路2：利用栈实现，遍历链表依次入栈，然后出k次栈就找到那个节点了。

　　

1.定义栈结构
typedef struct{
    int length;
    int value[];

}Stack;

void push(Stack &s,int v){
　　 if(s.length <= 50){
    　　s.value[s.length] = v;
    　　s.length++;
    　　printf("push: v=%d  length=%d \n",v,s.length);
　　}else{
　　　　printf("exception: out of memory!");
　　　　return;
　　}
}
void pop(Stack &s,int &v){
　　if(s.length > 0){
    　　v = s.value[--s.length];
    　　printf("pop: v=%d  length=%d\n",v,s.length);
　　}else{
　　　　printf("exception: out of memory!");
　　　　return;
　　}
}
void init_Stack(Stack *s){
    s->length = ;
}

2.定义单链表结构
typedef struct LNode{

    int data;
    struct LNode *next;
}LNode,*LinkList;

void init(LinkList &L){
    int i;
    int d;
    LinkList p,r;
    L = (LinkList)malloc(sizeof(LNode));
    L->data = -;
    L->next = NULL;
    r = L;
    scanf("%d",&d);
    while(d != ){
        p = (LinkList)malloc(sizeof(LNode));
        p->data = d;

        //p->next = L->next;//头插法
        //L->next = p;
        r->next = p; //尾插法
        r = p;
        scanf("%d",&d);
    }
    r->next = NULL;//尾插法不要忘掉这个结束
}

void print(LinkList L){
    printf("\n");
    L = L->next;
    while(L!=NULL){
        printf(" %d ",L->data);
        L = L->next;
    }
    printf("\n");

}

3.实现方法
int find_munK(LinkList L, int k){
    LinkList p ;
    int i;
    int result;

    Stack s;
    init_Stack(&s);

    p = L->next;
    while(p){
        push(s,p->data);
        p = p->next;
    }

    for(i=;i<=k;i++){
        pop(s,result);

    }
    return result;
}

4.测试
int main(){
    LinkList L1;
    init(L1);
    print(L1);

    printf("-->%d\n",find_munK(L1, )); //输出倒数第3个
    return ;
}

tip：

在上面的方法中：

参数有的是普通类型：

int find_munK(LinkList L, int k)
这里的L是指针类型（因为LinkLinst是指针类型的），
k是普通类型的，进去再出来k不会被修改

有的是地址类型：

 void init(LinkList &L) //这里接收的是一个地址
 L是地址类型的，在方法内修改L后，出来L也被修改了

 LinkList L1;//这里的LinkList是指针类型的
 init(L1);
 LinkNode L2;//这里的LinkNode是普通类型的
 inti(*L2);

 总的来说，就是传入一个地址

有的是指针类型：

void init_Stack(Stack *s)
s是指针类型的，在方法内修改后，出来s也被修改了

Stack s;  //Stack就是普通类型的，和int无差，需要取地址传入指针类型的形参
init_Stack(&s);

void fun(int a,int &b,int &c,int *d,int *e){
    a = ;
    b = ;
    c = ;
    *d = ;
    *e = ;

}
int main(){

 int a = ;
 int b = ;
 int * c ;
 int d = ;
 int * e;
 c = &d;
 e = &b;
 printf("a=%d b=%d c=%d d=%d e=%d \n ",a,b,*c,d,*e);
 fun(a,b,*c,&d,e);
 printf("a=%d b=%d c=%d d=%d e=%d \n ",a,b,*c,d,*e);
 }