数据结构c语言教程（数据结构 c语言编程）

本文目录

• 数据结构 c语言编程
• 用c语言（数据结构）编程，要详细的
• C语言版数据结构程序设计
• C语言编程（数据结构）
• 《数据结构（C语言版）》之“串的模式匹配算法”
• 关于C语言数据结构，该如何学习和入门
• 数据结构（c语言版）
• 数据结构（C语言）用单链表存储一元多项式，并实现两个多项式的相加运算

数据结构 c语言编程

#include "stdlib.h"
#include "iostream.h"

#define ERROR 0
#define OK 1
typedef int elemtype;
typedef struct lnode{
elemtype data;
struct lnode* next;
}lnode,*linklist;
void init_linklist(linklist &p)//链表参数采用引用参数，因初始化链表是从没有链表到有链表，并且要保留这个空链表以便后面使用，所以必须采用引用参数。当然采用指针参数也是可以的。
{
p=(linklist)malloc(sizeof(lnode));
p-》next=NULL;
}
void crt_linklist(linklist &p,int len)//链表参数采用引用参数，与初始化同理
{
init_linklist(p);
lnode* t;
t=p;
lnode* s;
for(int i=1;i《=len;i++)
{
s=(linklist)malloc(sizeof(lnode));
s-》data=i*10;
s-》next=NULL;
t-》next=s;
t=s;
}
}
void output_linklist(linklist p)//链表参数采用赋值参数，因为输出不改变链表结构
{
lnode* q=p-》next;
int i=1;//初值设为1，因为是从第一个元素开始输出的
while(q)
{
cout《《q-》data《《","《《i《《" ";
q=q-》next;
i++;

}
}
int main()
{
linklist p;
int i=30;//最好用int，这里是定义长度的，不是定义一个数据元素；或者typedef int Length; Length i=30;更好，呵呵
crt_linklist(p,i);
output_linklist(p);
return 0;
}

用c语言（数据结构）编程，要详细的

#include《stdio.h》
#include《stdlib.h》
#include《string.h》
#define MAX 3 // 停车场最大容量
#define price 5 //每小时5元
typedef struct time {
int hour;
int min;
} Time;// 定义时间结构体
typedef struct node {
char num;
Time reach;
Time leave;
} CarNode;// 定义车辆信息结构体
typedef struct NODE {
CarNode * stack;
int top;
} SeqStackCar;
typedef struct car {
CarNode *data;
struct car *next;
} QueueNode;
typedef struct Node {
QueueNode *head;
QueueNode *rear;
} LinkQueueCar;
void InitStack(SeqStackCar *s) {
int i;
s-》top = 0;
for (i = 0; i 《= MAX; i++)
s-》stack = NULL;
}// 栈的初始化
int InitQueue(LinkQueueCar *Q) {
Q-》head = (QueueNode *) malloc(sizeof (QueueNode));
if (Q-》head != NULL) {
Q-》head-》next = NULL;
Q-》rear = Q-》head;
return (1);
} else return (-1);
}// 队列的初始化
void PRINT(CarNode *p, int room) { // 车辆收费
int A1, A2, B1, B2;
printf("\n车辆离开的时间:");
scanf("%d:%d", &(p-》leave.hour), &(p-》leave.min));
printf("\n离开车辆的车牌号为:");
puts(p-》num);
printf("\n其到达时间为: %d:%d", p-》reach.hour, p-》reach.min);
printf("\n离开时间为: %d:%d", p-》leave.hour, p-》leave.min);
A1 = p-》reach.hour;
A2 = p-》reach.min;
B1 = p-》leave.hour;
B2 = p-》leave.min;
printf("\n应交费用为: %2.1f元", ((B1 - A1)*60 + (B2 - A2)) * price);
free(p);
}
int Arrival(SeqStackCar *Enter, LinkQueueCar *W) {
CarNode *p;
QueueNode *t;
p = (CarNode *) malloc(sizeof (CarNode));
printf("\n请输入车牌号(例:豫B1234):");
scanf("%d",&p-》num);
if (Enter-》top 《 MAX) {
Enter-》top++;
printf("\n车辆在车场第%d位置.", Enter-》top);
printf("\n车辆到达时间:");
scanf("%d:%d", &(p-》reach.hour), &(p-》reach.min));
Enter-》stack = p;
return (1);
} else {
printf("\n该车须在便道等待!有车位时进入车场");
t = (QueueNode *) malloc(sizeof (QueueNode));
t-》data = p;
t-》next = NULL;
W-》rear-》next = t;
W-》rear = t;
return (1);
}
}// 车辆的到达登记
void Leave(SeqStackCar *Enter, SeqStackCar *Temp, LinkQueueCar *W) { //车辆的离开
int room;
CarNode *p, *t;
QueueNode *q;
if (Enter-》top 》 0) // 判断车场是否为空
{
while (1) {
printf("\n请输入车在车场的位置/1--%d/：", Enter-》top);
scanf("%d", &room);
if (room 》= 1 && room 《= Enter-》top) break;
else printf("\n 输入有误,请重输: ");
}
while (Enter-》top 》 room) // 把要删除的车辆的前面的车开出来，进临时栈。
{
Temp-》top++;
Temp-》stack;
Enter-》stack = NULL;
Enter-》top--;
}
p = Enter-》stack; // 把要删除的车辆节点赋给p。
Enter-》stack = NULL;
Enter-》top--;
while (Temp-》top 》= 1) // 再把临时栈里德车辆进停车场
{
Enter-》top++;
Enter-》stack;
Temp-》stack = NULL;
Temp-》top--;
}
PRINT(p, room); // 调用计费函数计费
if ((W-》head != W-》rear) && Enter-》top 《 MAX) //如果便道上有车，则再开进停车场。
{
q = W-》head-》next;
t = q-》data;
Enter-》top++;
printf("\n便道的%s号车进入车场第%d位置.", t-》num, Enter-》top);
printf("\n请输入%s号车进入车场的时间:", t-》num);
scanf("%d:%d", &(t-》reach.hour), &(t-》reach.min));
W-》head-》next = q-》next;
if (q == W-》rear) W-》rear = W-》head;
Enter-》stack = t;
free(q);
} else printf("\n便道里没有车.\n");
} else printf("\n车场里没有车.");
}
void List1(SeqStackCar *S){ int i;
if (S-》top 》 0) {
printf("\n车场:");
printf("\n 位置 到达时间 车牌号\n");
for (i = 1; i 《= S-》top; i++) {
printf(" %d ", i);
printf(" %d:%d ", S-》stack-》reach.min);
puts(S-》stack-》num);
}
} else printf("\n车场里没有车");
}//显示车场里的车辆情况
void List2(LinkQueueCar *W) {
QueueNode *p;
int i;
p = W-》head-》next;
if (W-》head != W-》rear) {
printf("\n等待车辆的号码为:");
for (i = 1; (p != NULL); i++) {
printf("\n第 %d 车辆.", i);
puts(p-》data-》num);
p = p-》next;
}
} else printf("\n便道里没有车.");
printf("\n");
}//显示便道上的车辆情况
void List(SeqStackCar S, LinkQueueCar W) {
int flag, tag;
flag = 1;
while (flag) {
printf(" 查看车辆列表显示: ");
printf("\n 1.车场列表\n 2.便道列表\n 3.返回主菜单\n");
printf("\n请选择 1~3:");
while (1) {
scanf("%d", &tag);
if (tag 》= 1 && tag 《= 3) break;
else printf("\n 输入有误,请重新选择 1~3:");
}
switch (tag) {
case 1:List1(&S);
break;
case 2:List2(&W);
break;
case 3:flag = 0;
system("cls");
break;
default: break;
}
}
}//显示,遍历
int main() {
SeqStackCar Enter, Temp;
LinkQueueCar Wait;
int ch;
InitStack(&Enter);
InitStack(&Temp);
InitQueue(&Wait);
while (1) {
printf("\n ############ 欢迎使用停车场系统.############\t\n\n");
printf("\n\t * 1. 车辆到达登记.\t\n");
printf("\n\t * 2. 车辆离开登记.\t\n");
printf("\n\t * 3. 车辆列表显示.\t\n");
printf("\n\t * 4. 退出系统.\t\n\n");
while (1) {
printf(" 请选择: ");
scanf("%d", &ch);
if (ch 》= 1 && ch 《= 4)break;
else printf("\n 输入有误，请重新选择： 1~4: ");
}
switch (ch) {
case 1:Arrival(&Enter, &Wait);
break;
case 2:Leave(&Enter, &Temp, &Wait);
break;
case 3:List(Enter, Wait);
break;
case 4:exit(0);
default: break;
}
}
}// 自定义函数
应该就是这样了

C语言版数据结构程序设计

/* 二叉树应用 */#include "stdio.h"
#include "stdlib.h"typedef char ElemType; /* 结点数据的类型 */
typedef struct BiTNode{
ElemType data;
struct BiTNode *lchild,*rchild;
}BiTNode; /* 树结点类型 *//*栈的定义及基本操作*/
#define MaxSize 100
typedef BiTNode* SElemType; /* 栈和队列的结点类型，用于存放树结点 */
typedef struct {
SElemType elem;
int top;
}SqStack; /* 栈 */void InitStack(SqStack *pS) /* 初始化栈,开始时栈为空 */
{
pS-》top=0; /* top指向栈顶的上一个元素 */
}int Push(SqStack *pS,SElemType e) /* 进栈 */
{
if (pS-》top==MaxSize-1) /* 栈满 */
return 0; pS-》elem=e;
pS-》top=pS-》top+1;
return 1;
}int Pop(SqStack *pS,SElemType *pe) /* 出栈 */
{
if (pS-》top==0) /* 栈空 */
return 0; pS-》top = pS-》top - 1;
*pe = pS-》elem;
return 1;
}/*队列（循环队列）的定义及基本操作*/typedef struct {
SElemType elem;
int front,rear;
}SqQueue; /* 队列 */void InitQueue(SqQueue* pQ) /* 初始化队列,开始时队列为空 */
{
pQ-》front=pQ-》rear=0;
}int EnQueue(SqQueue* pQ,SElemType e) /* 进队 */
{
if ((pQ-》rear+1)%MaxSize == pQ-》front) /* 队满 */
return 0;
pQ-》elem = e;
pQ-》rear = (pQ-》rear+1)%MaxSize;
return 1;
}int DeQueue(SqQueue* pQ,SElemType* pe) /* 出队 */
{
if (pQ-》rear == pQ-》front) /* 队空 */
return 0;
*pe = pQ-》elem;
pQ-》front = (pQ-》front+1)%MaxSize;
return 1;
}
/* 先根遍历 */
void preorder(BiTNode *bt)
{ if(bt!=NULL)
{ printf("%c ",bt-》data);
preorder(bt-》lchild);
preorder(bt-》rchild);
}
} /* 中根遍历 */
void inorder(BiTNode *bt)
{ if(bt!=NULL)
{ inorder(bt-》lchild);
printf("%c ",bt-》data);
inorder(bt-》rchild);
}
}
/* 后根遍历 */
void postorder(BiTNode *bt)
{ if(bt!=NULL)
{ postorder(bt-》lchild);
postorder(bt-》rchild);
printf("%c ",bt-》data);
}
}/* 非递归算法的中根遍历（后进先出，用了栈的思想） */
void inorder_fdg(BiTNode *bt)
{
BiTNode *p;
SqStack s;
InitStack(&s);
p=bt;
do
{ while(p!=NULL)
{ Push(&s,p);
p=p-》lchild;
}
if(s.top!=0)
{ Pop(&s,&p);
printf("%c ",p-》data);
p=p-》rchild;
}
}while(s.top!=0||p!=NULL);
}/* 用队列实现层次遍历 */
void lev_traverse(BiTNode* bt)
{
SqQueue q;
BiTNode *p;
p=bt;
InitQueue(&q);
EnQueue(&q,p);
while(!(q.rear==q.front)) { /* 当队列不空 */
DeQueue(&q,&p);
printf("%c ",p-》data); if(p-》lchild!=NULL)
EnQueue(&q,p-》lchild); if(p-》rchild!=NULL)
EnQueue(&q,p-》rchild);
}
}
/* 利用先根序列建立二叉树，空的子树也要输入，用空格表示,建立的树通过函数返回,避免使用指针的指针 */
BiTNode *crt_bt_pre()
{ char ch;
BiTNode *bt;
scanf("%c",&ch); if(ch==’ ’) bt=NULL;
else
{ bt=(BiTNode *)malloc(sizeof(BiTNode));
bt-》data=ch;
bt-》lchild=crt_bt_pre();
bt-》rchild=crt_bt_pre();
}
return(bt);
}/* 利用先根序列建立二叉树，空的子树也要输入，用空格表示,建立的树通过参数返回,注意和上述方法比较，想想还有什么办法？ */
void crt_bt_pre_2(BiTNode **bt)
{ char ch;
scanf("%c",&ch); if(ch==’ ’) (*bt)=NULL;
else
{ (*bt)=(BiTNode *)malloc(sizeof(BiTNode));
(*bt)-》data=ch;
crt_bt_pre_2(&(*bt)-》lchild);
crt_bt_pre_2(&(*bt)-》rchild);
}
}
/* 求叶子数 */
int leaf(BiTNode *bt)
{
if (bt==NULL) return 0;
else {
if (bt-》lchild==NULL&&bt-》rchild==NULL) return 1;
else
return leaf(bt-》lchild)+leaf(bt-》rchild);
}}/* 求树的高度 */
int high(BiTNode *bt)
{
if (bt==NULL) return 0;
else {
return max(high(bt-》lchild),high(bt-》rchild))+1;
}}
/* 二叉树的释放*/
void freetree(BiTNode *bt)
{ if(bt!=NULL)
{ freetree(bt-》lchild);
freetree(bt-》rchild);
free(bt);
bt=NULL;
}
}main()
{
BiTNode *T,*temp; /* 笨方法建立二叉树 */
/* temp=(BiTNode*)malloc(sizeof(BiTNode));
temp=(BiTNode*)malloc(sizeof(BiTNode));
temp-》data = ’+’;
temp=(BiTNode*)malloc(sizeof(BiTNode));
temp-》data = ’/’;
temp=(BiTNode*)malloc(sizeof(BiTNode));
temp-》data = ’a’;
temp-》rchild=NULL;
temp=(BiTNode*)malloc(sizeof(BiTNode));
temp-》data = ’*’;
temp=(BiTNode*)malloc(sizeof(BiTNode));
temp-》data = ’e’;
temp-》rchild=NULL;
temp=(BiTNode*)malloc(sizeof(BiTNode));
temp-》data = ’f’;
temp-》rchild=NULL;
temp=(BiTNode*)malloc(sizeof(BiTNode));
temp-》data = ’b’;
temp-》rchild=NULL;
temp=(BiTNode*)malloc(sizeof(BiTNode));
temp-》data = ’-’;
temp=(BiTNode*)malloc(sizeof(BiTNode));
temp-》data = ’c’;
temp-》rchild=NULL;
temp=(BiTNode*)malloc(sizeof(BiTNode));
temp-》data = ’d’;
temp-》rchild=NULL;
temp; */
/*输出树和各种遍历、叶子数、树的高度*/
/*printf("\ntree:\n");
printf(" -\n");
printf(" + /\n");
printf(" a * e f\n");
printf("0 0b - 0 00 0\n");
printf(" 0 0c d\n"); printf("\n\nPreOrder:\n");
preorder(T); printf("\nInOrder:\n");
inorder(T); printf("\nPostOrder:\n");
postorder(T); printf("\ninorder_fdg:\n");
inorder_fdg(T); printf("\nlev_traverse:\n");
lev_traverse(T);
printf("\nleaf num:%d",leaf(T));
printf("\nTree high:%d",high(T));
freetree(T); */ /* 按先序列建树，用空格表示空子树*/ printf("\n\nplease input inorder:such as ’abc de g f ’\n");
/*T = crt_bt_pre();*/
crt_bt_pre_2(&T); printf("\n\nPreOrder:\n");
preorder(T); printf("\nInOrder:\n");
inorder(T); printf("\nPostOrder:\n");
postorder(T); printf("\ninorder_fdg:\n");
inorder_fdg(T); printf("\nlev_traverse:\n");
lev_traverse(T);
printf("\nleaf num:%d",leaf(T));
printf("\nTree high:%d",high(T));
freetree(T);
getch();
}

C语言编程（数据结构）

int *getnum(int a)
{
    static int n;
    int i = a;
    for (i = 1; i 《= a; i++)
    {
        int k = i;
        while (i 》 0)
        {
            n++;
            i /= 10;
        }
        i = k;
    }
    return n;
}
int main()
{
    int *m = getnum(11);
    int i;
    for (i = 0; i 《10; i++)
    {
        printf("%d ", m);
    }
    getch();
    return 0;
}

《数据结构（C语言版）》之“串的模式匹配算法”

# include 《string.h》
# include 《stdio.h》
# include 《stdlib.h》
# define OK 1
# define ERROR 0
typedef int Status;
//串的定长顺序存储结构
# define MAX_STR_LEN 40
typedef char SString;//0号单元存放串的长度
Status StrAssign(SString T,char * chars)//生成一个其值等于chars的串T
{
int i;
if (strlen(chars) 》 MAX_STR_LEN)
{
return ERROR;
}
else
{
T = strlen(chars);
for (i=1; i《=T; ++i)
{
T = * (chars + i - 1);
}
return OK;
}
}
//返回串S的元素的个数
int StrLength(SString S)
{
return S;
}
//用Sub返回串S的自第pos个字符起长度为len的子串
Status SubString(SString Sub,SString S,int pos,int len)
{
int i;
if (pos《1 || pos》S-pos+1)
{
return ERROR;
}
for (i=1; i《=len; ++i)
{
Sub;
}
Sub = len;
return OK;
}
//输出字符串T
void StrPrint(SString T)
{
int i;
for (i=1; i《=T; ++i)
{
printf("%c ",T);
}
printf("\n");
}
//求模式串T的next函数值并存入数组next
void get_next(SString T,int next)
{
int i = 1,j = 0;
next = 0;
while (i 《 T)
{
if (j==0 || T)
{
++i;
++j;
next = j;
}
else
{
j = next;
}
}
}
//求模式串T的next函数修正值并存入数组nextval
void get_nextval(SString T,int nextval)
{
int i = 1,j = 0;
nextval = 0;
while (i 《 T)
{
if (j==0 || T)
{
++i;
++j;
if (T)
{
nextval = j;
}
else
{
nextval;
}
}
else
{
j = nextval;
}
}
}
//利用模式串T的next函数求T在主串S中第pos字符之后的位置的KMP算法
//1=《pos=《StrLength(S)
int Index_KMP(SString S,SString T,int pos,int next)
{
int i = pos,j = 1;
while (i《=S)
{
if (j==0 || S)
{
++i;
++j;
}
else
{
j = next;
}
}
if (j 》 T)
{
return i - T;
}
else
{
return 0;
}
}
int main(void)
{
int i,* p;
SString s1,s2;
StrAssign(s1,"aaabaaaab");
printf("主串为：");
StrPrint(s1);
StrAssign(s2,"aaaab");
printf("子串为：");
StrPrint(s2);
p = (int *)malloc((StrLength(s2) + 1) * sizeof(int));
get_next(s2,p);
printf("子串的next的数组为：");
for (i=1; i《=StrLength(s2); ++i)
{
printf("%d ",* (p+i));
}
printf("\n");
i = Index_KMP(s1,s2,1,p);
if (i)
{
printf("主串和子串在第%d个字符处首次匹配\n",i);
}
else
{
printf("主串和子串匹配不成功\n");
}
get_nextval(s2,p);
printf("子串的nextval数组为：");
for (i=1; i《=StrLength(s2); ++i)
{
printf("%d ",* (p+i));
}
printf("\n");
printf("主串和子串在第%d个字符处首次匹配\n",Index_KMP(s1,s2,1,p));
printf("求串s1的从第5个字符起长度为5的子串s2:\n");
SubString(s2,s1,5,5);
printf("串s2为:");
StrPrint(s2);
return 0;
}
/*
在vc++6.0中的输出结果：
------------------------
主串为：a a a b a a a a b
子串为：a a a a b
子串的next的数组为：0 1 2 3 4
主串和子串在第5个字符处首次匹配
子串的nextval数组为：0 0 0 0 4
主串和子串在第5个字符处首次匹配
求串s1的从第5个字符起长度为5的子串s2:
串s2为:a a a a b
Press any key to continue
------------------------------
*/

关于C语言数据结构，该如何学习和入门

说些我的见解：
1）首先明确数据结构研究的对象：研究的是如何存储、操作数据，楼主应该关心每种数据结构的数学模型，可以用在什么场合，各种性能怎么样：例如增加数据，查找数据，删除数据都要花多少时间与内存。
学完之后要知道每个实际情况该用什么数据结构。如果能自己设计出来更适合实际需求的数据结构，那就强了。
2）C语言只是表现形式，不是核心：像著名的《算法导论》描述数据结构用的都是伪代码。真正学好C语言，只要理解数据结构的数学模型，就可以轻松写出代码。所以像这本书C语言代码实现的部分，应该能翻译成数学模型来看。熟练掌握一门语言是和计算机沟通的基础。
3）本书使用了面向对象，即C++的一些思想，目的是以后可以直接用数据结构，而不必重写代码。Destory只是一些快捷方式，在具体环境中实现，这些结构是没必要记的，应该根据需求楼主可以自己写出来。其实很多语言都提供了这些数据结构的实现，C++里的叫STL。
总之：核心是数学模型，顺便熟悉一下C语言，写些比较大的程序时，可以把数据结构包装成书上那样一个大的结构，方便使用。最后，多写程序是很有好处的，可以锻炼上面所有的技能。

数据结构（c语言版）

测试数据1:
创建二叉树,输入先序扩展序列:ABD##E##C#F##
先序遍历输出节点:A B D E C F
中序遍历输出节点:D B E A C F
后序遍历输出节点:D E B F C A
二叉树示意图:
          A
       /      \
      B        C
    /    \    / \
   D      E  #   F
  / \    / \    / \
 #   #  #   #  #   #
测试数据2:
创建二叉树,输入先序扩展序列:ABC##DE#G##F###
先序遍历输出节点:A B C D E G F
中序遍历输出节点:C B E G D F A
后序遍历输出节点:C G E F D B A
二叉树示意图:
           A
         /   \
        B     #
    /      \
   C        D
  / \    /     \
 #  #   E       F
       / \     / \
      #   G   #   #
         / \
        #   #
#include《stdio.h》
#include《stdlib.h》
typedef struct Node   //二叉树的结构体
{
    char data;            //字符
    struct Node *lchild;  //左分支
    struct Node *rchild;  //右分支
}Bitree;
//创建二叉树: 用"先序遍历"(递归法)
void CreateBiTree(Bitree **bt)
{
    char ch;
    scanf("%c",&ch); //输入字符
    if(ch==’#’)      //’#’是空节点NULL
        *bt=NULL;
    else
    {
        *bt=(Bitree *)malloc(sizeof(Bitree));
        (*bt)-》data=ch;
        CreateBiTree(&((*bt)-》lchild));
        CreateBiTree(&((*bt)-》rchild));
    }
}
//用"先序遍历"输出节点(递归法)
void preOrder(Bitree *ptr)
{
    if(ptr!=NULL)
    {
        printf("%c ",ptr-》data);
        preOrder(ptr-》lchild);
        preOrder(ptr-》rchild);
    }
}
//用"中序遍历"输出节点(递归法)
void inOrder(Bitree *ptr)
{
    if(ptr!=NULL)
    {
        inOrder(ptr-》lchild);
        printf("%c ",ptr-》data);
        inOrder(ptr-》rchild);
    }
}
//用"后序遍历"输出节点(递归法)
void postOrder(Bitree *ptr)
{
    if(ptr!=NULL)
    {
        postOrder(ptr-》lchild);
        postOrder(ptr-》rchild);
        printf("%c ",ptr-》data);
    }
}
int main()
{
    Bitree *root;
    printf("创建二叉树,输入先序扩展序列:");
    CreateBiTree(&root);
    printf("先序遍历输出节点: ");
    preOrder(root);
    printf("\n中序遍历输出节点: ");
    inOrder(root);
    printf("\n后序遍历输出节点: ");
    postOrder(root);
    printf("\n");
    return 0;
}

数据结构（C语言）用单链表存储一元多项式，并实现两个多项式的相加运算

#include《stdio.h》

#include《stdlib.h》

#include《malloc.h》

typedef int ElemType;

/*单项链表的声明*/

typedef struct PolynNode{

int coef; // 系数

int expn; // 指数

struct PolynNode *next; }PolynNode,*PolynList;

/*正位序(插在表尾)输入n个元素的值,建立带表头结构的单链线性表*/

/*指数系数一对一对输入*/ void CreatePolyn(PolynList &L,int n)

{

int i;

下载

原文档已转码为如下格式，以便移动设备查看

数据结构(c语言)用单链表存储一元多项式,并实现两个多项式的相加运算【最新】

阅读：1037次 页数：36页 2016-03-21 举报



#include《stdio.h》

#include《stdlib.h》

#include《malloc.h》

typedef int ElemType;

/*单项链表的声明*/

typedef struct PolynNode{

int coef; // 系数

int expn; // 指数

struct PolynNode *next; }PolynNode,*PolynList;

/*正位序(插在表尾)输入n个元素的值,建立带表头结构的单链线性表*/

/*指数系数一对一对输入*/ void CreatePolyn(PolynList &L,int n)

{

int i;



PolynList p,q;

L=(PolynList)malloc(sizeof(PolynNode)); // 生成头结点

L-》next=NULL;

q=L;

printf("成对输入%d个数据\n",n);

for(i=1;i《=n;i++)

{

p=(PolynList)malloc(sizeof(PolynNode));

scanf("%d%d",&p-》coef,&p-》expn); //指数和系数成对输入

q-》next=p;

q=q-》next;

}

p-》next=NULL;

}

// 初始条件:单链表L已存在

// 操作结果: 依次对L的每个数据元素调用函数vi()。一旦vi()失败,则操作失败

void PolynTraverse(PolynList L,void(*vi)(ElemType, ElemType)) {

PolynList p=L-》next;

while(p)

{



vi(p-》coef, p-》expn);

if(p-》next)

{

printf(" + "); //“+”号的输出,最后一项后面没有“+”

}

p=p-》next;

}

printf("\n");

}

/*ListTraverse()调用的函数(类型要一致)*/ void visit(ElemType c, ElemType e) {

if(c != 0)

{

printf("%dX^%d",c,e); //格式化输出多项式每一项

}

}

/* 多项式相加,原理:归并 */ /* 参数:两个已经存在的多项式 */ /* 返回值:归并后新的多项式的头结点 */

PolynList MergeList(PolynList La, PolynList Lb) {

PolynList pa, pb, pc, Lc;

pa = La-》next;

pb = Lb-》next;

Lc = pc = La; // 用La的头结点作为Lc的头结点

while(pa&&pb)

{

if(pa-》expn 《 pb-》expn)

{

pc-》next = pa; //如果指数不相等,pc指针连上指数小的结

点,

pc = pa;

pa = pa-》next; //指向该结点的指针后移

}

else if (pa -》expn 》 pb-》expn )

{

pc-》next = pb; //pc指针连上指数小的结点,

pc = pb;

pb = pb-》next; //指向该结点的指针后移

}

else //(pa -》expn = pb-》expn )

{

pa-》coef = pa-》coef + pb-》coef; //指数相等时,系数相加

pc-》next = pa;

pc = pa;

pa = pa-》next; //两指针都往后移

pb = pb-》next;

}

}

pc-》next = pa ? pa:pb; // 插入剩余段

return Lc;

}

void main()

{

PolynList ha,hb,hc;

printf("非递减输入多项式ha, ");

CreatePolyn(ha,5); // 正位序输入n个元素的值

printf("非递减输入多项式hb, ");

CreatePolyn(hb,5); // 正位序输入n个元素的值