❶ 【100分】数据结构——使用c语言（线性表）
//c++的头文件,我是用c++编写的，有一些该成了C但是有些输入输出没有改
//希望楼主不要建议哦，费了很久的时间写的啊！
#include<iostream>//c++的头文件
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<math.h>
#define error 0
#define OVERFLOW 1
#define OK 1
using namespace std;//c++的一个指令
typedef struct
{
int *elem; //存储空间基址
int length; //当前长度
int listsize;//当前分配的存储容量
// (以sizeof(ElemType)为单位)
//int *next;
}sqlist;
void initList(sqlist &La)
{//构造一个空线性表L
La.elem=(int *) malloc(100 *sizeof(int));//分配空间
if (!La.elem) exit(-2);//未分配则 跳出；
La.length=0;
La.listsize= 100 ;
}
int Listinsert_sq(sqlist &L,int i,int e) // listinsert_sq;插入一个元素
{int *newbase;int *p,*q;
if (i<1 || i>L.length+1) return error;
if (L.length>=L.listsize)//空间不足追加
{newbase=(int*) realloc(L.elem,(L.listsize+10) *sizeof(int));
if (!newbase)
exit(-2);
L.elem=newbase; L.listsize+=10 ;
return 0;
}
q=&(L.elem[i-1]);//指针指向确定插入的位子
for(p=&(L.elem[L.length-1]);p>=q;--p)
*(p+1)=*p;//指针后移
*q=e; //实现元素的插入
++L.length;
return 0;
}
int ListDelete_sq(sqlist &L,int i)//删除i位子的元素
{int *p,*q;
if((i<1)||(i>L.length)) return 0;
p=&(L.elem[i-1]);
//e=*p;
cout<<"被删除的值是："<<*p<<endl;
for(q=&(L.elem[L.length-1]);p<q;p++)
*p =*(p+1);//指针前移，覆盖前面的存储的数据
--L.length;
return 1;
}
int Getelem(sqlist &L)//输入表的数据
{ int n;
cout<<"输入数列的个数："<<endl;
cin>>n;
printf("按大小顺序输入n个数：");//cout<<"按大小顺序输入n个数：";
if(n<0||n>L.listsize ) return 0;
for(int i=0;i<n;i++)//循环输入元素
{ cin>>L.elem [i];
L.length ++;//表长度
}
cout<<"这数列的长度："<<L.length <<endl;
return 1;
}
int Poplist(sqlist &L)//输出函数
{
for(int j=0;j<L.length ;j++)
cout<<L.elem[j]<<" ";
printf("\n");//cout<<endl;
return 0;
}
void ListMerge(sqlist La,sqlist Lb, sqlist &Lc)//合并函数，
{ int *pa,*pb,*pa_list ,*pb_list,*pc;
pa=La.elem;pb=Lb.elem;//用pa和pb指向表头
Lc.length=La.length+Lb.length;
Lc.listsize=Lc.length;
Lc.elem=(int *)malloc(Lc.listsize*sizeof(int ));//合理分配Lc的空间
if(!Lc.elem) exit(-2);
pa_list=&(La.elem[La.length-1]);pb_list=&(Lb.elem[Lb.length-1]);//用pa-list和pb_list指向表未
pc=Lc.elem;
while(pa<=pa_list&&pb<=pb_list)//合并算法
{ if(*pa>=*pb){ *pc++=*pb++;*pc++=*pa++;}
//if(*pa=*pb){ *pc++=*pa++;*pc++=*pb++; }
else {*pc++=*pa++;*pc++=*pb++;}
}
while(pa<=pa_list) *pc++=*pa++;//插入剩余的元素；
while(pb<=pb_list) *pc++=*pb++;
}
int main()
{ sqlist La,Lb,Lc;int i,e;
initList(La);
Getelem(La);
initList(Lb);
Getelem(Lb);
ListMerge(La,Lb,Lc);
Poplist(Lc);
printf("input munber 要删除的位子i \n:");
scanf("%d",&i);// cin>>i;
ListDelete_sq(La,i);
Poplist(La);//我这里是用表La做例子。也可用Lb。。。
printf("输出要插入的位子和元素：\n");
scanf("%d%d",&i,&e);//cin>>i>>e;
Listinsert_sq(Lb,i,e);
Poplist(Lb);//我这里是用表Lb做例子。也可用La。。。
return 0;
}
终于全搞定了，还有些不足，希望对楼主有用！
❷ 数据结构中，怎么用C语言构造线性表！
#define
OK
1
#define
ERROR
-1
#define
MAX_SIZE
100
typedef
int
Status
;
typedef
int
ElemType
;
typedef
struct
sqlist
{
ElemType
Elem_array[MAX_SIZE]
;
int
length
;
}
SqList
;
以上为线性表建立的相关定义
Status
Init_SqList(
SqList
*L
)
{
L->elem_array=(
ElemType
*
)malloc(MAX_SIZE*sizeof(
ElemType
)
)
;
if
(
!L
->
elem_array
)
return
ERROR
;
else
{
L->length=
0
;
return
OK
;
}
}
以上为线性表初始化函数
有以上两部分可构造一个线性表
❸ 在C语言中，如何构造一个空的顺序线性表,然后怎么用
#include
#define
MAXSIZE
100
struct
List
{
int
L[MAXSIZE];
int
top;
};
int
Init()//top指针初始化为0
{
int
top;
top=0;
return
top;
}
void
Input(struct
List
*t,int
p,int
n)//输入n个数据
{
if(n==0||n>=MAXSIZE)printf("空队列\n");
else
for(p=0;p
L[p]);
}
void
Output(struct
List
*s,int
i,int
m)//输出m(=n)个数据哈
{
if(m==0||m>=MAXSIZE)printf("无法输出\n");
else
for(i=0;i
L[i]);
}
void
main()
{
struct
List
r;
int
n,m;
scanf("%d",&n);
m=Init();
Input(&r,m,n);
Output(&r,0,n);
}
❹ 用C语言创建一个空线性表，并完成插入删除等基本操作，可就是不知道怎么改了，求大神帮忙改到能运行！
亲,你用的是顺序表的结构体和初始化，其它用的却是链表的操作，建议多看看数据结构的书。
❺ C语言数据结构：Status InitList(LinkList &L)是构造一个空的线性表的正确
改成linklist *L试试
❻ 求构建一个线性表的完整程序 数据结构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;
}
❼ C语言这种结构体如何构造一个空的线性表L
函数main()里的语句LinkListL;系统自动给变量L分配了内存,
L对应的是第2个结构体,也就是LinkList.
调用初始化函数InitList(),给变量L里的成员head,tail,len进行赋值,
L.head指向的就是空链表,此时,L.head=NULL,同时,L.len=0,表示没有结点.
所以执行函数InitList()之后,也就制造了空链表.
执行函数InsertNode()之后,链表就加入了新结点,结点对应的是第1个结构体,也就是LNode
L.head指向链表的头结点,L.tail指向链表的末尾结点,L.len表示结点的数量.
测试结果:
初始化之后,链表长度是0
插入数据之后,链表长度是3
链表里的数据是:102030
//代码用了"引用"(&),所以要用C++编译器进行测试
#include<stdio.h>
#include<stdlib.h>
typedefintElemType;
typedefintStatus;
typedefstructLNode
{
ElemTypedata;
structLNode*next;
}*Link,*Position;
typedefstruct
{
Linkhead,tail;
intlen;
}LinkList;
StatusInitList(LinkList&L);
StatusInsertNode(LinkList&L,ElemTypee);
StatusListTraverse(LinkListL);
intListLength(LinkListL);
//链表初始化
StatusInitList(LinkList&L)//&是"引用"符号
{
L.head=NULL;
L.tail=NULL;
L.len=0;
return1;
}
//插入结点
StatusInsertNode(LinkList&L,ElemTypee)//&是"引用"符号
{
LNode*newNode;
newNode=(LNode*)malloc(sizeof(LNode));
if(newNode==NULL)
{
printf(" 分配内存错误. ");
exit(1);
}
newNode->data=e;
newNode->next=NULL;
//用"尾插法"添加新结点
if(L.head==NULL)
{
L.head=newNode;
L.tail=newNode;
L.len=1;
}
else
{
L.tail->next=newNode;
L.tail=newNode;
L.len=L.len+1;
}
return1;
}
//链表遍历
StatusListTraverse(LinkListL)
{
Linkp;
p=L.head;
if(p==NULL)
{
printf(" 链表为空. ");
return0;
}
while(p!=NULL)
{
printf("%d",p->data);
p=p->next;
}
printf(" ");
return1;
}
//链表长度
intListLength(LinkListL)
{
returnL.len;
}
intmain()
{
LinkListL;
InitList(L);
printf("初始化之后,链表长度是%d ",ListLength(L));
InsertNode(L,10);
InsertNode(L,20);
InsertNode(L,30);
printf("插入数据之后,链表长度是%d ",ListLength(L));
printf("链表里的数据是:");
ListTraverse(L);
return0;
}
❽ 在C语言中，如何构造一个空的顺序线性表,然后怎么用
#include<stdio.h>
#define MAXSIZE 100
struct List
{
int L[MAXSIZE];
int top;
};
int Init()//top指针初始化为0
{
int top;
top=0;
return top;
}
void Input(struct List *t,int p,int n)//输入n个数据
{
if(n==0||n>=MAXSIZE)printf("空队列\n");
else
for(p=0;p<n;p++)
scanf("%d",&t->L[p]);
}
void Output(struct List *s,int i,int m)//输出m(=n)个数据哈
{
if(m==0||m>=MAXSIZE)printf("无法输出\n");
else
for(i=0;i<m;i++)
printf("%d ",s->L[i]);
}
void main()
{
struct List r;
int n,m;
scanf("%d",&n);
m=Init();
Input(&r,m,n);
Output(&r,0,n);
}
❾ c语言中创建线性表问题
因为你的p没有初始化，printf 里面d与，后面的&。。不匹配
#include<stdio.h>
#include <stdlib.h>
#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量
#define LISTINCREMENT 10 //线性表存储空间的分配量
typedef int ElemType[LIST_INIT_SIZE];
typedef struct {
ElemType *elem;
int length;
int listsize;
}SqList;
typedef int Status;
int InitList_Sq(SqList L)
{
//构造一个空的线性表L。
L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem){return 0;}
L.length=0;
printf("%d\n",L.length);
L.listsize=LIST_INIT_SIZE;
return 1;
}
int main()
{
int t=0;
SqList p={};
InitList_Sq(p);
printf("%d\n",p.length);
return 0;
❿ C语言建立一个空线性表，输出结果本应该为“a=19 b=0 c=0”，可是实际运行结果为“a=19 b=17753914 c=-2
你使用c语言写的，因而不存在引用的问题。因而在函数InitList_Sq函数中，你的形参有问题，应该改为指针。
函数声明应该int InitList_Sq(SqList *L)
在调用函数的时候，应该改为InitList_Sq(&firstL);
这么改了之后，InitList_Sq函数的实现部分，不再是L.element而是L->element，依次类推。