『壹』 线性表问题，求解
问题很多，数据结构抽象都不对。给个样板你参考吧。
#include <stdio.h>
#include <malloc.h>
typedef struct node{
int data;
struct node *next;
}node_t;
node_t *creat_list(int n)
{
node_t *head;
node_t *p;
node_t *q;
int i = 1;
if(n == 0)
{
return NULL;
}
head = (node_t *)(malloc(sizeof(node_t)));
scanf("%d", &head->data);
p = head;
while (i < n)
{
i++;
q = (node_t *)(malloc(sizeof(node_t)));
scanf("%d", &q->data);
p->next = q;
p = q;
}
q->next = NULL;
return head;
}
void print_node(node_t *h)
{
while(h != NULL)
{
printf("%d->", h->data);
h= h->next;
}
printf("NULL\n");
}
int list_len(node_t *head)
{
int len = 0;
while (head != NULL)
{
len++;
head = head->next;
}
return len;
}
node_t *insert_node(node_t *head, int n)
{
node_t *p;
node_t *q = head;
node_t *r;
int i = 1;
p = (node_t *)(malloc(sizeof(struct node)));
scanf("%d", &p->data);
while (i < n - 1)
{
q = q->next;
i++;
}
if (n == 1)
{
p->next = head;
head = p;
}
else if (list_len(head) > n)
{
r = q->next;
p->next = r;
q->next = p;
}
else
{
q->next = p;
p->next = NULL;
}
return head;
}
node_t *find_node(node_t *head, int n)
{
while (n > 1)
{
head = head->next;
n--;
}
return head;
}
node_t *del_node(node_t *head, int n)
{
node_t *p = head;
node_t *q;
int i = 1;
while (i < n - 1)
{
p = p->next;
i++;
}
if (n == 1) // delete first node
{
head = head->next;
free(p);
}
else if(n == list_len(head))
{
q = p->next;
p->next = NULL;
free(q);
}
else
{
q = p->next;
p->next = q->next;
free(q);
}
return head;
}
node_t *change_list(node_t *head, int n)
{
int i = 1;
while (i < n)
{
i++;
head = head->next;
}
scanf("%d", &head->data);
return head;
}
node_t *reverse_list(node_t *head)
{
node_t *p = head;
node_t *q = head->next;
node_t *r;
head->next = NULL;
while (q != NULL)
{
r = q->next;
q->next = p;
p = q;
q = r;
}
return p;
}
int main()
{
node_t *list;
printf("Create a list please input 5 nodes\n");
list = creat_list(5);
print_node(list);
printf("\nThe list's lenth:%d\n", list_len(list));
printf("\nThe 2th node:%d\n", find_node(list, 2)->data);
printf("\nInsert a node,please inout a node\n");
list = insert_node(list, 2);
print_node(list);
printf("\nDelete the 3th node\n");
list = del_node(list, 3);
print_node(list);
printf("\nChange the 2th node\n");
change_list(list, 2);
print_node(list);
printf("\nReverse list\n");
list = reverse_list(list);
print_node(list);
return 0;
}
『贰』 线性表及其应用（多项式相加、相乘）----根据程序画出流程图及对每句程序加注释(c语言）
#include "stdio.h"
typedef struct node
{ int c,e; //节点的数据域，c是多项式的系数，e是多项式的指数
struct node *next; //节点的指针域
}PN; //自定义节点结构体，类型PN
PN *createPoly() //这个函数用来建立链表，返回值是一个节点指针
{ int n, e, c;
PN *head, *p; //定义头结点指针head，和节点指针p
printf("请输入多项式项数:");
scanf("%d", &n); //得到n的值，既项数
head=p=new PN ; // * malloc(sizeof(PN));//让head,p都指向头结点（头结点不用来存放数据）
p->next=NULL; //到这里为止，一个空链表建立完成
while( n-- ) //循环n次
{
p->next=new PN;// * malloc(sizeof(PN));//动态分配新的节点，并接在链表末尾（尾插法）
p=p->next;
// printf("c e:"); //给新的节点，添加数据
scanf("%d%d" , &p->c, &p->e);
}
p->next=NULL; //将表尾的指针域置为空
return head; //返回头结点地址
}
void printPoly( PN *head) //这个函数用来输入链表信息
{ PN *p=head->next; //节点指针p用来遍历链表,p先指向表头
while(p) //当p=NULL时（已经到表尾），结束循环
{ printf(" (%d,%d) ", p->c, p->e); //显示当前节点的数据
p=p->next; //将p指向移到下一个节点
}
printf("\n"); //输出一个回车
}
void freePoly( PN *head) //这个函数用来销毁链表
{ PN *p; //用来释放节点（动态内存块）
while( head ) //当head=NULL时（已经到表尾），结束循环
{ p=head; //让p指向head所指的节点
head=head->next; //将head指向移到下一个节点
delete(p); //释放p所指的节点（动态内存块）
}
}
PN *polyAdd(PN *ha, PN *hb) //这个函数用来将两个多项式相加
{ int c, e; //c是多项式的系数，e是多项式的指数
PN *pa=ha->next, *pb=hb->next, //pa,pb用来遍历通过参数传进来的两个链表（参数是两个链表的头结点指针），暂且称它们为链表a,b
*hc, *pc; //hc是两个链表对应节点相加后的新链表的头结点，pc用来遍历新链表,此链表称它为c
hc=pc=new PN;
while( pa || pb ) //当两个链表都遍历完毕，则循环停止
{
if( pa && (pb==NULL || pa->e < pb->e)) //取指数较小的一项链入链表或者链表b已经遍历完毕时，执行该if中的内容
{ c=pa->c;
e=pa->e;
pa=pa->next;
}
else if( pb && (pa==NULL || pa->e > pb->e)) //取指数较小的一项链入链表或者链表a已经遍历完毕时，执行该if中的内容
{ c=pb->c;
e=pb->e;
pb=pb->next;
}
else //指数相等的时候，执行
{ c=pa->c+pb->c;
e=pa->e;
pa=pa->next;
pb=pb->next;
}
if( c ) //将两个链表相加后的每个项 都放入新链表中
{
pc->next=new PN;
pc=pc->next;
pc->c=c;
pc->e=e;
}
}
pc->next=NULL;
return hc; //将新链表的头结点指针返回
}
PN *mulxmul(PN *ha, PN *hb) //这个函数将a表中每个项都掉用一次onexmul函数，最终实现多项式a与b的相乘
{ PN *t, *hc, *pa=ha->next;
PN *onexmul( PN *pa , PN *hb); //函数声明，因为接下来就要用到它
PN *polyAdd(PN *ha, PN *hb); //函数声明，因为接下来就要用到它
t=new PN; t->next=NULL; //存放最终结果的链表，t是表头,此表暂称为t表
while( pa ) //遍历a链表
{ hc=onexmul( pa, hb ); //将a表中pa所指的项与b表中所有的项相乘（即多项式a中的某一项与多项式b相乘）
t=polyAdd( t, hc ); //将每次相乘的结果相加
freePoly( hc ); //将调用onexmul函数产生的中间链表销毁，因为该链表的项，已经放到t链表中
pa=pa->next;
}
return t; //将t表的头结点指针返回
}
PN *onexmul ( PN *pa, PN *hb ) //这个函数用来将a表中pa所指的项与b表中所有的项相乘（即多项式a中的某一项与多项式b相乘）
{ PN *hc, *pc, *pb=hb->next; //hc是新链表的头结点，pc用来遍历新链表
hc=pc=new PN; //让hc,pc都指向头结点
while( pb ) //遍历b链表
{ pc->next=new PN; //建立新链表的节点
pc=pc->next;
pc->c=pa->c * pb->c; //给新节点赋值，系数等于系数相乘
pc->e=pa->e + pb->e; //指数等于指数相加
pb=pb->next;
}
pc->next=NULL;
return hc; //将新链表的头结点指针返回
}
int main()
{ PN *ha, *hb, *hc;
freopen("poly.in" , "r" , stdin); //只读模式打开poly.in
freopen("poly.txt", "w", stdout); //只写模式打开poly.txt
ha=createPoly(); //建立新链表，ha为头结点指针(多项式a)
printPoly(ha); //输出ha为头结点指针的链表信息
hb=createPoly(); //建立新链表，hb为头结点指针(多项式b)
printPoly(hb); //输出hb为头结点指针的链表信息
hc=polyAdd(ha, hb); //多项式a与多项式b相加，结果放在hc为头结点指针的链表中
printPoly(hc); //输出相加后的链表信息
freePoly(hc); //销毁该链表
hc=mulxmul(ha,hb); //多项式a与多项式b相乘，结果放在hc为头结点指针的链表中
printPoly(hc); //输出相乘后的链表信息
freePoly(ha); //销毁该链表
freePoly(hb); //销毁该链表
freePoly(hc); //销毁该链表
return 0;
}
OK,花了不少时间帮你写了下注释，应该比较完整了吧，原理和数学模型完全一样的，应该能看懂，流程图，相信看懂了程序，画起来不难，自己尝试下吧。
『叁』 c语言数据结构顺序表，要求程序输出如图内容
#include<stdio.h>
#include <iostream>
#include <conio.h>
#include <stdlib.h>
using namespace std;
#define OK 1
#define FAULT 0
typedef int Status;
#define ListInitSize 100
#define ListIncrement 10
typedef struct //存储结构类型定义
{
int* data;
int length;
int MaxSize;
}hahaList;
Status InitList_haha(hahaList &L) //线性表初始化
{
L.data=(int*)malloc(ListInitSize*sizeof(int));
if(!L.data) return 0;
L.length =0;
L.MaxSize = ListInitSize;
return OK;
}
void Search(hahaList L,int x) //查找
{
int i,a;
for(i=0;i<L.length ;i++)
if(x== L.data[i])
printf("元素%d是第%d个元素\n",x,i+1);
}
void print(hahaList L) //输出
{
int i;
printf("线性表la=");
for (i=0;i<L.length ;i++)
printf("%3d",L.data[i]);
printf("\n线性表的长度为%d",L.length);
for (i=0;i<L.length ;i++)
printf("\n第一个元素是：%d",L.data[i]);
}
Status Insert(hahaList &L,int i,int e) //插入
{
int j;int* newbase;
if(i<1||i>L.length +1)return 0;
if(L.length >=L.MaxSize )
{
newbase=(int*)realloc(L.data ,(L.MaxSize+ListIncrement)*sizeof(int));
if(!newbase) return 0;
L.data =newbase;
L.MaxSize +=ListIncrement;
}
for(j=L.length-1;j>=i-1;j--)
L.data [j+1]=L.data [j];
L.data [i-1]=e;
++L.length ;
return OK;
}
Status Delete(hahaList &L,int i,int e) //删除
{
int j;
if(i<1||i>L.length +1)return 0;
e=L.data [i-1];
for(j=i;j<=L.length-1;j++)
L.data [j-1]=L.data [j];
--L.length ;
printf("删除元素%d后线性表为:",i);
for (i=0;i<L.length ;i++)
printf("%3d",L.data[i]);
printf("\n线性表La的长度=%d",L.length);
return OK;
}
int main ()
{
int i,x;
int num,e;
hahaList L ;
InitList_haha(L) ;
for(i=0;i<6;i++)
{
Insert(L, i+1, i+1);
}
print(L);
printf("\n请输入要查询的元素");
scanf("%d",&x);
Search(L,x);
printf("请输入要删除的元素");
scanf("%d",&i);
Delete(L,i,e);
cout<<endl;
return 0;
}
『肆』 数据结构顺序存贮线性表的程序，我想知道每个步骤的意思
建议您可以学习一下单步调试，具体网络教程即可。在单步调试中，你可以得到计算机具体执行程序的每一步操作的结果信息。
第四行有了一个全局变量n，和一个全局变量数组table，这两个变量在主函数和函数中都可以调用更改。
在main（）函数中，choice表示选择的操作的编号。接着7行输出cout...，接着是“cin>>choice”读入一次数据赋值给choice，根据choice的值调用那个函数。
creat_table()函数，每次读取一个手动键入的数字，然后存进table数组的最后一位（下标为n的地方），然后增加n的数值为n+1。
out_table（）函数：n代表的是整个table数组的长度，数组内存的元素从下标0到下标n-1，长度就是n了！所以跑一次循环整体输出。
append_data(): cin>>table[n++] 实际上等价于 cin>>table[n]（读取一个数字存到下标为n的地方）然后n++，n再自增一。
inset_data()： 需要先读入loc的值，也就是插入的元素的下标；然后整体将下标n-1到loc的元素依次后移一位，再来读入一个新的数据 直接覆盖了下标为loc上的数据。这样达到插入数据的目的！（这里还有一个小bug，n再插入一个元素后需要n++一次，毕竟插入新的元素后总长度加一了哈！）
我之前写过一点C语言学习经验，可以看看网页链接网页链接
希望以上内容可以对你有所帮助，忘采纳；如有疑问，接着追问~~
『伍』 数据结构 线性表程序 要求先插入后删除
#include<stdio.h>
#include<stdlib.h>
#define LIST_INIT_SIZE 100 //线性表存储空间初始分配量
#define LISTINCREMENT 10 //线性表存储空间分配增量
typedef struct
{
int *elem; //存储空间基址
int length; //当前长度
int listsize; //当前分配存储容量
}SqList;
void InitList(SqList *L) //初始化
{
L->elem = (int *)malloc(LIST_INIT_SIZE * sizeof(int));
if(!L->elem) exit(1);
L->length = 0;
L->listsize = LIST_INIT_SIZE;
}
int GetElem(SqList *L,int i) //取得i位置的元素
{
if(i<1 || i>L->length) exit(1);
return (L->elem[i-1]);
}
void ListInsert(SqList *L,int i,int e) //插入
{
//顺序线性表L中第i个位置之前插入新元素e
int *newbase,*q,*p;
if(i<1 || i>L->length+1) exit(1);
if(L->length>=L->listsize) //存储空间满，增加分配
{
newbase = (int *)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(int));
if(!newbase) exit(1); //分配失败
L->elem = newbase; //指向新地址
L->listsize += LISTINCREMENT;
}
q = &(L->elem[i-1]); //插入位置
for(p=&(L->elem[L->length-1]);p>=q;--p)
*(p+1) = *p;
*q = e; //插入
++L->length;
}
void ListDelete(SqList *L,int i) //删除
{
int *q,*p;
if((i<1) || (i>L->length)) exit(1);
p = &(L->elem[i-1]);
q = L->elem + L->length -1; //表尾元素位置
for(++p;p<=q;++p) //向左移动
*(p-1) = *p;
--L->length;
}
void MergeList(SqList La,SqList Lb,SqList *Lc) //合并两表
{
int *pa,*pb,*pc,*pa_last,*pb_last;
pa = La.elem;
pb = Lb.elem;
Lc->listsize = Lc->length = La.length + Lb.length;
pc = Lc->elem = (int*)malloc(Lc->listsize*sizeof(int));
if(!Lc->elem) exit(1); //分配失败
pa_last = La.elem + La.length-1;
pb_last = Lb.elem + Lb.length-1; //取得最后一个元素的位置
while(pa<=pa_last && pb<=pb_last) //归并
{
if(*pa<=*pb) *pc++ = *pa++;
else *pc++ = *pb++;
}
while(pa<=pa_last) *pc++ = *pa++; //插入剩余元素
while(pb<=pb_last) *pc++ = *pb++;
}
void display(SqList *L) //显示
{
int i;
printf("the list is :");
for(i=0;i<L->length;i++)
{
printf("%d\n",L->elem[i]);
}
}
int main()
{
SqList sl,sl2,sl3;
InitList(&sl);
InitList(&sl2);//初始化两表
printf("%d\n",sl.length);
ListInsert(&sl,1,1);
ListInsert(&sl,2,2);//插入表1
ListInsert(&sl2,1,3);
ListInsert(&sl2,2,4);
display(&sl);
display(&sl2);
printf("merge a and b:\n");
MergeList(sl,sl2,&sl3);
display(&sl3);
return 0;
}
『陆』 求构建一个线性表的完整程序 数据结构C语言版
#include "stdafx.h"
#define maxSize 100
typedef int elemType;
#include <stdio.h>
#include <stdlib.h>
typedef int elemType;
struct SeqList {
elemType *list;
int size;
int LmaxSize;
};
/* 初始化线性表L，即进行动态存储空间分配并置L为一个空表 */
void initList(struct SeqList *L, int ms)
{
/* 检查ms是否有效，若无效的则退出运行 */
if(ms <= 0){
printf("MaxSize非法！");
exit(1); /* 执行此函数中止程序运行，此函数在stdlib.h中有定义 */
}
L->LmaxSize = ms; /* 设置线性表空间大小为ms */
L->size = 0;
L->list = (int *)malloc(ms * sizeof(elemType));
if(!L->list){
printf("空间分配失败！");
exit(1);
}
return;
}
/* 空间扩展为原来的2倍，并由p指针所指向，原内容被自动拷贝到p所指向的存储空间 */
void againMalloc(struct SeqList *L)
{
elemType *p = (int *)realloc(L->list, 2 * L->LmaxSize * sizeof(elemType));
if(!p){ /* 分配失败则退出运行 */
printf("存储空间分配失败！ ");
exit(1);
}
L->list = p; /* 使list指向新线性表空间 */
L->LmaxSize = 2 * L->LmaxSize; /* 把线性表空间大小修改为新的长度 */
}
/* 清除线性表L中的所有元素，释放存储空间，使之成为一个空表 */
void clearList(struct SeqList *L)
{
if(L->list != NULL){
free(L->list);
L->list = NULL;
L->size = L->LmaxSize = 0;
}
return;
}
/* 返回线性表L当前的长度，若L为空则返回0 */
int sizeList(struct SeqList *L)
{
return L->size;
}
/* 判断线性表L是否为空，若为空则返回1, 否则返回0 */
int emptyList(struct SeqList *L)
{
if(L->size ==0){
return 1;
}
else{
return 0 ;
}
}
/* 返回线性表L中第pos个元素的值，若pos超出范围，则停止程序运行 */
elemType getElem(struct SeqList *L, int pos)
{
if(pos < 1 || pos > L->size){ /* 若pos越界则退出运行 */
printf("元素序号越界！");
exit(1);
}
return L->list[pos - 1]; /* 返回线性表中序号为pos值的元素值 */
}
/* 顺序扫描（即遍历）输出线性表L中的每个元素 */
void traverseList(struct SeqList *L)
{
int i;
for(i = 0; i < L->size; i++){
printf("%d ", L ->list[i]);
printf(" ");
}
return;
}
/* 从线性表L中查找值与x相等的元素，若查找成功则返回其位置，否则返回-1 */
int search(struct SeqList *L, elemType x)
{
int i;
for(i = 0; i < L->size; i++){
if(L->list[i] == x){
return i;
}
}
return -1;
}
/* 把线性表L中第pos个元素的值修改为x的值，若修改成功返回1，否则返回0 */
int updatePosList(struct SeqList *L, int pos, elemType x)
{
if(pos < 1 || pos > L->size){ /* 若pos越界则修改失败 */
return 0;
}
L->list[pos - 1] = x;
return 1;
}
/* 向线性表L的表头插入元素x */
void inserFirstList(struct SeqList *L, elemType x)
{
int i;
if(L->size== L->LmaxSize){ /* 重新分配更大的存储空间 */
againMalloc(L);
}
for(i = L->size - 1; i >= 0; i--)/*元素后移*/
L->list[i + 1] = L ->list[i];
L->list[0] = x;
L->size ++;
}
/* 向线性表L的表尾插入元素x */
void insertLastList(struct SeqList *L, elemType x)
{
if(L->size == L ->LmaxSize){ /* 重新分配更大的存储空间 */
againMalloc(L);
}
L->list[L->size] = x; /* 把x插入到表尾 */
L->size++; /* 线性表的长度增加1 */
return;
}
/* 向线性表L中第pos个元素位置插入元素x，若插入成功返回1，否则返回0 */
int insertPosList(struct SeqList *L, int pos, elemType x)
{
int i;
if(pos < 1 || pos > L->size + 1){ /* 若pos越界则插入失败 */
return 0;
}
if(L->size == L->LmaxSize){ /* 重新分配更大的存储空间 */
againMalloc(L);
}
for(i = L->size - 1; i >= pos - 1; i--){
L->list[i + 1] = L->list[i];
}
L->list[pos - 1] = x;
L->size++;
return 1;
}
/* 向有序线性表L中插入元素x,使得插入后仍然有序*/
void insertOrderList(struct SeqList *L, elemType x)
{
int i, j;
/* 若数组空间用完则重新分配更大的存储空间 */
if(L->size == L->LmaxSize){
againMalloc(L);
}
/* 顺序查找出x的插入位置 */
for(i = 0; i < L->size; i++){
if(x < L->list[i]){
break;
}
}
/* 从表尾到下标i元素依次后移一个位置， 把i的位置空出来 */
for(j = L->size - 1; j >= i; j--)
L->list[j+1] = L->list[j];
/* 把x值赋给下标为i的元素 */
L->list[i] = x;
/* 线性表长度增加1 */
L->size++;
return;
}
/* 从线性表L中删除表头元素并返回它，若删除失败则停止程序运行 */
elemType deleteFirstList(struct SeqList *L)
{
elemType temp;
int i;
if(L ->size == 0){
printf("线性表为空，不能进行删除操作！ ");
exit(1);
}
temp = L->list[0];
for(i = 1; i < L->size; i++) /* 元素前移 */
L->list[i-1] = L->list[i];
L->size--;
return temp;
}
/* 从线性表L中删除表尾元素并返回它，若删除失败则停止程序运行 */
elemType deleteLastList(struct SeqList *L)
{
if(L ->size == 0){
printf("线性表为空，不能进行删除操作！ ");
exit(1);
}
L->size--;
return L ->list[L->size]; /* 返回原来表尾元素的值 */
}
/* 从线性表L中删除第pos个元素并返回它，若删除失败则停止程序运行 */
elemType deletePosList(struct SeqList *L, int pos)
{
elemType temp;
int i;
if(pos < 1 || pos > L->size){ /* pos越界则删除失败 */
printf("pos值越界，不能进行删除操作！ ");
exit(1);
}
temp = L->list[pos-1];
for(i = pos; i < L->size; i++)
L->list[i-1] = L->list[i];
L->size--;
return temp;
}
/* 从线性表L中删除值为x的第一个元素，若成功返回1，失败返回0 */
int deleteValueList(struct SeqList *L, elemType x)
{
int i, j;
/* 从线性表中顺序查找出值为x的第一个元素 */
for(i = 0; i < L->size; i++){
if(L->list[i] == x){
break;
}
}
/* 若查找失败，表明不存在值为x的元素，返回0 */
if(i == L->size){
return 0;
}
/* 删除值为x的元素L->list[i] */
for(j = i + 1; j < L->size; j++){
L->list[j-1] = L->list[j];
}
L->size--;
return 1;
}
int main(int argc, char* argv[])
{
struct SeqList * ListPerson;
int Listsize=10;
int i;
int num;
ListPerson=(SeqList*)malloc(sizeof(SeqList)); //这句话很重要
initList(ListPerson,Listsize);
for (i=0;i<10;i++)
{
inserFirstList(ListPerson, i);
}
for (i=0;i<5;i++)
{
inserFirstList(ListPerson, i);
}
num=sizeList(ListPerson);
for (i=0;i<num;i++)
{
printf(" %d ", ListPerson->list[i]);
}
printf("\n");
insertPosList(ListPerson, 5, 100);
num=sizeList(ListPerson);
for (i=0;i<num;i++)
{
printf(" %d ", ListPerson->list[i]);
}
return 0;
}