链表简单实现---栈

#include <stdio.h>
#include <string.h>
#include "stack_list.h"
//栈应用 , 检查字符串中括号是否匹配

void test1()内部功能Pnode createNode(DataType data)
{
    Pnode p1 = createNode(1);
    Pnode p2 = createNode(2);
    Pnode p3 = createNode(3);
    Pnode p4 = createNode(4);

    p1->next = p2;

    p2->prev = p1;
    p2->next = p3;

    p3->prev = p2;
    p3->next = p4;

    p4->prev = p3;

    douListPrint(p1);
}
void test2()内部功能insertNextNode
{
    Pnode p1 = createNode(1);
    Pnode p2 = createNode(2);
    Pnode p3 = createNode(3);
    Pnode p4 = createNode(4);
    insertNextNode(p1, p3);
    insertNextNode(p1, p2);
    insertNextNode(p3, p4);



    douListPrint(p1);

}
void test3()内部功能insertNextNode
{
    Pnode p1 = createNode(1);
    Pnode p2 = createNode(2);
    Pnode p3 = createNode(3);
    Pnode p4 = createNode(4);
    insertPrevNode(p4, p2);
    douListPrint(p2);
    insertPrevNode(p4, p3);
    douListPrint(p2);
    insertPrevNode(p2, p1);
    douListPrint(p1);

}
void test4()
{
    Pnode p1 = createNode(1);
    Pnode p2 = createNode(2);
    Pnode p3 = createNode(3);
    Pnode p4 = createNode(4);

    p1->next = p2;

    p2->prev = p1;
    p2->next = p3;

    p3->prev = p2;
    p3->next = p4;

    p4->prev = p3;
    douListPrint(p1);
    deleteNextNode(p1);
    douListPrint(p1);
    deleteNextNode(p4);
    douListPrint(p1);
    deleteNextNode(p3);
    douListPrint(p1);

}
void test5()// deletePrevNode(
{
    Pnode p1 = createNode(1);
    Pnode p2 = createNode(2);
    Pnode p3 = createNode(3);
    Pnode p4 = createNode(4);

    p1->next = p2;

    p2->prev = p1;
    p2->next = p3;

    p3->prev = p2;
    p3->next = p4;

    p4->prev = p3;
    douListPrint(p1);
    deletePrevNode(p4);
    douListPrint(p1);
    deletePrevNode(p2);
    douListPrint(p2);

}
int main()
{
    //test1();
    //test2();
    //test3();
    //test4();
    test5();
    Stack *s = createStack(10);

    int i = 0;
    for(i = 0;i<10;i++)
    {

        push(s,i);

    }
    int data = 0;

    for(i = 0;i<10;i++)
    {
        pop(s,&data);
        printf("data = %d\n",data);
    }
    destroyStack(s);
    getchar();


}

include

include

include “stack_list.h”

int maxSize(Stack *pStack)
{
if (NULL == pStack)
{
return -1;
}
return pStack->maxSize;
}
int setMaxSize(Stack *pStack, int maxSize)
{
if (NULL == pStack)
{
return -1;
}
pStack->maxSize = maxSize;
return 0;
}
int count(Stack *pStack)
{
if (NULL == pStack)
{
return -1;
}
return pStack->count;
}
int push(Stack *pStack, int data)
{
if (NULL == pStack)
{
return -1;
}
/*if (pStack->count == pStack->maxSize)
{
return 2;
}*/
douListInsertDataFromHead(&(pStack->head), data);
pStack->count++;
return 0;
}
int pop(Stack *pStack, int *pdata)
{
if (NULL == pStack||NULL==pdata||pStack->count==0)
{
return -1;
}
pStack->count–;
Pnode head = pStack->head;
*pdata =head->data;
//douListDeleteDataFromHead(&head);—-绝对不可以在临时变量取地址，这是错误的
douListDeleteDataFromHead(&(pStack->head));
return 0;

}

Stack *createStack(unsigned int maxSize)
{
if (0==maxSize)
{
return NULL;
}
pStack p = (pStack)malloc(sizeof(Stack));
if (NULL == p)
{
return NULL;
}
p->head = NULL;
p->count = 0;
p->maxSize = maxSize;
return p;

}
int destroyStack(Stack *pStack)
{
if (NULL == pStack)
{
return -1;
}
Pnode head = pStack->head;
if(NULL != head)
{
douListDestroy(&head);
}
free(pStack);
return 0;
}

ifndef _STACK_LIST_H

define _STACK_LIST_H

include “doulist.h”

typedef struct stack{
Pnode head;
int count;
int maxSize;
}Stack,*pStack;

int maxSize(Stack *pStack);
int setMaxSize(Stack *pStack, int maxSize);
int count(Stack *pStack);

int push(Stack *pStack, int data);
int pop(Stack *pStack, int *pdata);
Stack *createStack(unsigned int maxSize);
int destroyStack(Stack *pStack);

endif

ifndef DOULIST_H

define DOULIST_H

typedef int DataType;
typedef struct node{
DataType data;
struct node *next;
struct node *prev;
}Node,*Pnode;

//01 内部小功能
Pnode createNode(DataType data);

int insertNextNode(Pnode p1,Pnode p2);
int insertPrevNode(Pnode p1,Pnode p2);

int deleteNextNode(Pnode p);
int deletePrevNode(Pnode p);
int deleteNode(Pnode p);

//02 増
//int douListInsertDataFromTail
int douListInsertDataBySort(Pnode *phead,DataType data);
int douListInsertDataFromHead(Pnode *phead,DataType data);
//03 删
int douListDeleteDataFromHead(Pnode *phead);
int douListDeleteData(Pnode *phead,DataType data);
int douListDestroy(Pnode *phead);
//04 改
int douListChangeData(Pnode head,DataType oldData,DataType newData);
//05 查
Pnode douListFindNode(Pnode head,DataType data);
int douListPrint(Pnode head);

endif

include

include

include”doulist.h”

//01 内部小功能
Pnode createNode(DataType data)
{
Pnode p = (Pnode)malloc(sizeof(Node));
if (NULL == p)
{
return NULL;
}
p->data = data;
p->next = NULL;
p->prev = NULL;
return p;
}
int insertNextNode(Pnode p1, Pnode p2)
{
if (NULL == p1 || NULL == p2)
{
return -1;
}
if (NULL == p1->next)//末梢节点
{
p1->next = p2;
p2->prev = p1;
}
else//中间节点
{
Pnode p3 = p1->next;
p1->next = p2;
p2->prev = p1;

    p2->next = p3;
    p3->prev = p2;
}

}
int insertPrevNode(Pnode p1, Pnode p2)
{
if (NULL == p1 || NULL == p2)
{
return -1;
}
if (NULL == p1->prev)//头节点前插
{
p1->prev = p2;
p2->next = p1;

}
else//中间节点
{
    Pnode p3 = p1->prev;
    p1->prev = p2;
    p2->next = p1;

    p2->prev = p3;
    p3->next = p2;
}
return 0;

}
int deleteNextNode(Pnode p)
{
if (NULL == p)
{
return -1;
}
if (NULL == p->next)
{
return 0;
}
else
{
Pnode p2 = p->next;
if (NULL == p2->next)
{
p->next = NULL;
free(p2);
return 0;
}
else
{
p->next = p2->next;
p2->next->prev = p;
free(p2);
return 0;
}
}
}
int deletePrevNode(Pnode p)
{
if (NULL == p)
{
return -1;
}
if (NULL == p->prev)
{
return 0;
}
else
{
Pnode p2 = p->prev;
if (NULL == p2->prev)
{
p->prev = NULL;
free(p2);
return 0;
}
else
{
p->prev = p2->prev;
p2->prev->next = p;
free(p2);
return 0;
}

}

}
int deleteNode(Pnode p)
{
if (NULL == p)
{
return 0;
}
else
{
if (NULL == p->prev)
{
if (NULL == p->next)
{
free(p);
}
else
{
p->next->prev = NULL;
free(p);
}
}
else
{
if (NULL == p->next)
{
p->prev->next = NULL;
free(p);
}
else
{
p->prev->next = p->next;
p->next->prev = p->prev;
free(p);
}
}
}
}

//02 増
//int douListInsertDataFromTail
int douListInsertDataBySort(Pnode *phead, DataType data)
{
if (NULL == phead)
{
return -1;
}
Pnode head = *phead;
Pnode pNew = createNode(data);
if (NULL == *phead)
{
*phead = pNew;
return 0;
}
else
{
Pnode p = head;
while (NULL != p->next)
{
if (data < p->data)
{
break;
}
p = p->next;
}
if (NULL != p)//头,中插
{
insertPrevNode(p, pNew);
*phead = pNew;
}
else//尾插
{
insertNextNode(p, pNew);
}
return 0;

}

}
int douListInsertDataFromHead(Pnode *phead, DataType data)
{
if (NULL == phead)
{
return -1;
}
Pnode pNew = createNode(data);
Pnode head = *phead;
if (NULL == head)
{
*phead = pNew;
}
else
{
insertPrevNode(head, pNew);
*phead = pNew;
}
return 0;

}

//03 删

int douListDeleteDataFromHead(Pnode *phead)
{
if (NULL == phead)
{
return -1;
}
Pnode head = *phead;
if (NULL == *phead)
{
return 0;
}
if (NULL == head->next)
{
free(head);
*phead = NULL;
}
else
{
*phead = head->next;
head->next->prev = NULL;
free(head);
head = NULL;
}
return 0;

}

int douListDeleteData(Pnode *phead, DataType data)
{
if (NULL == phead)
{
return -1;
}
Pnode head = *phead;
Pnode p = head;
if (data == head->data)
{
*phead = head->next;
head->next->prev = NULL;
free(head);
}
else
{
while (NULL != p)
{
if (data == p->data)
{
deleteNode(p);
break;
}
p = p->next;
}
}
}
int douListDestroy(Pnode *phead)
{
if (NULL == phead)
{
return -1;
}
Pnode head = *phead;
while (NULL!=head)
{
Pnode p = head;
head = head->next;
free(p);
}
return 0;
}
//04 改
int douListChangeData(Pnode head, DataType oldData, DataType newData)
{
if (NULL == head)
{
return -1;
}
Pnode p = head;
while (NULL != p)
{
if (p->data == oldData)
{
p->data = newData;
}
p->prev->next;
}
return 0;
}
//05 查
Pnode douListFindNode(Pnode head, DataType data)
{
if (NULL == head)
{
return NULL;
}
Pnode p = head;
while (NULL != p)
{
if (p->data == data)
{
return p;
}
p->prev->next;
}
return NULL;

}
int douListPrint(Pnode head)
{
if (NULL == head)
{
return 0;
}
Pnode p = head;
printf(“正序：”);
while (NULL != p)
{
printf(“%d “, p->data);
if (NULL == p->next)
{
break;
}
p = p->next;
}
printf(“\n”);
printf(“逆序：”);
while (NULL != p)
{
printf(“%d “, p->data);
p = p->prev;
}
printf(“\n———————\n”);
}
“`