链表与栈(C)

本文记录链表和栈的基本代码操作。

链表的基本操作：

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

typedef char datatype;  //按照需求定义数据类型
typedef struct node     //定义结点，结点是一个结构体
{
    datatype data;
    struct node *next;
} linklist;   //结点的类型名称是 linklist

linklist *createlist()
{
    char ch;
    linklist *head, *s, *r;
//开辟头节点空间，并且把地址付给head
    head = (linklist*)malloc(sizeof(linklist));    
r = head;  //r是指当前的结点
    printf("请输入字符产生链表，以#结束\n");
    ch = getchar();
    while (ch != '#')
    {
        //开辟一个新的结点
s = (linklist*)malloc(sizeof(linklist));
        s->data = ch;
        r->next = s; //实现了结点相连
        r = s;  //更新当前结点
        ch = getchar();
    }
    r->next = NULL;
    return head;  //返回头结点
}

linklist *get(linklist *head, int i)
{
    int j;
    linklist *p;
    p = head; j = 0;
    while ((p->next != NULL) && (j<i))
    {
        p = p->next;
        j++;
    }
    if (i == j) return p;
    else return NULL;
}

linklist *insert(linklist *head, int i, char x)
{
    linklist *p, *s;
    int j;
   //产生一个新结点
    s = (linklist*)malloc(sizeof(linklist));    
s->data = x;
    if (i == 0)
    {
        s->next = head;
        head = s;
    }
    else
    {
        p = head; j = 1;
        while (p != NULL&&j<i)
        {
            j++;
            p = p->next; //移动结点位置，找到应该插入数据的位置
        }
    //接下来插入结点
        if (p != NULL)
        {
            s->next = p->next;
            p->next = s;  //实现结点插入
        }
        else
            printf("结点未找到\n");
    }
    return head;
}

linklist *dele(linklist *head, char i)
{
    linklist *p, *q;
    q = head;
    p = head->next;
    while (p != NULL&&p->data != i)
    {
        q = p; p = p->next;
    }
    if (p != NULL)
    {
        q->next = p->next; //指针的改变
        free(p);  //释放p所占用的结点内存
    }
    else
        printf("结点未找到！\n");
    return head;
}

void main()
{
     linklist *head, *r;  //定义两个指针型变量，变量是所定义
//的结点结构
    int num, num1;   
    char char1, char2;
    head = createlist(); //用函数createlist来实现链表的创建
    printf("链表信息为：");
    r = head->next;
    while (r)
    {
        printf("%c", r->data);
        r = r->next;  //移动到下一个结点
    }
    printf("\n");
    printf("请输入要查询的序号：\n");
    scanf("%d", &num);
    r = get(head, num); //用函数get来实现链表中元素的查询
    if (r == NULL)printf("没有查到\n");
    printf("查找结果为：%c\n", r->data);
    printf("请输入要插入的位置：\n");
    scanf("%d", &num1);
    printf("请输入要插入的字符：\n");
    getchar();
    scanf("%c", &char1);
    r = insert(head, num1, char1); //用函数insert来实现链表
//中元素的插入
   //插入后将链表元素打印出来    
r = head->next;
    while (r)
    {
        printf("%c", r->data);
        r = r->next;
    }
    printf("\n");
    printf("请输入要删除的字符\n");
    getchar();
    scanf("%c", &char2);
    r = dele(head, char2);
    r = head->next;
    while (r)
    {
        printf("%c", r->data);
        r = r->next;
    }
}

栈处理十六进制转换：

#include <stdio.h>
#include <stdlib.h>
#define maxsize 1024
typedef int datatype;
typedef struct
{
    datatype elements[maxsize];
    int Top;
}Stack;
void setNull(Stack *s)
{  s->Top=-1;}
int isfull(Stack *s)
{
 if(s->Top>=maxsize-1)return(1);
 else return(0);
}
int isempty (Stack *s)
{if(s->Top>=0)return(0);
    else return(1);}

void push(Stack *s,datatype E)
{
    if(s->Top>=maxsize-1)
    {
        printf("Stack Overflow");}
        else
        {
            s->Top++;
            s->elements[s->Top]=E;
        }
}
datatype *pop(Stack *s)
{
    datatype *temp;
    if(isempty(s))
    {
        printf("Stack Underflow");
        return(NULL);
    }else
    {
        s->Top--;
        temp=(datatype *)malloc(sizeof(datatype));
        *temp=s->elements[s->Top+1];
        return(temp);
    }
}
void conversion(int n)
{
 Stack s;
 setNull(&s);
 int r,m;
 r=n;
 while(r)
 {
     m=r%16;
     if(isfull(&s))printf("Over flow\n");
     else push(&s,m);
     r=r/16;
 }
 printf("转换后的十六进制为\n");
 while(!isempty(&s))
    printf("%x",*(pop(&s)));
 printf("\n");
}
void main()
{
    int num;
    printf("请输入需要转换为十六进制的十进制数据\n");
    scanf("%d",&num);
    conversion(num);
}