順序表的建立和列印c語言

A. c語言建立順序表

#include"iostream.h"
#include"malloc.h"
#include"stdio.h"
#define MAX_LIST_SIZE 100
typedef int elemtype;
typedef struct Node
{
elemtype *data;
int length;
int listsize;
}SqList;

void InitList(SqList &L)
{
L=(SqList *)malloc(MAX_LIST_SIZE*sizeof(SqList));
L->length=0;
L->listsize=MAX_LIST_SIZE;
}
void Insert(SqList &L,int i,elemtype x)
{
int k;
for(k=L->length;k>=i;k--)
*L->data[k+1]=*L->data[k];
*L->data[k]=x;
}
void Print(SqList L)
{
for(int i=0;i<L->length;i++)
cout<<*L->data[i]<<" ";
}

void main()
{
elemtype e;
int n;
SqList *L;
InitList(L);
cout<<"輸入你要插入的元素:"<<endl;
cin>>e;
cout<<"輸入你要插入的位置:"<<endl;
cin>>n;
Insert(L,n,e);
Print(L);
}
這里就簡要的寫了下第一小問，時間問題，沒有調試，你自己看看
其實網上這方面的資料很多的，你可以網路一下

B. 用C語言建立一個順序表，輸入n個數並輸出。程序編譯沒錯，但運行不了，求指教。程序如下：

樓主你好
修改如下:
#include<stdio.h>
#include<malloc.h>
#define MaxSize 40 //順序表存儲空間的初始分配量 --> (1)可以將MaxSize調大點兒
typedef struct
{
int *p;
int data[MaxSize];
int length;
int listsize;
}SeqList;
void InitList(SeqList &x) //定義順序表的初始化函數
//--> (2)這里應該是SeqList &x 需要址傳遞 值傳遞是不會改變實參值的
{
x.p=(int*)malloc(MaxSize*sizeof(int));
if(!x.p) printf("存儲分配失敗！");
x.length=0;
x.listsize=MaxSize;
}
int main()
{
SeqList L;
InitList(L);
int i,n,k;
printf("請輸入順序表的長度n：");
scanf("%d",&n);
if(n<=0)
{
printf("數據錯誤！\n");
return 0;
}
if(n>MaxSize)
{
L.p=(int*)realloc(L.p,n*sizeof(int));
if(!L.p)printf("存儲空間擴展失敗！\n");
L.listsize=n;
}
printf("請輸入數據：");
for(i=0;i<=n-1;i++)
{
scanf("%d",&k);
L.data[i]=k;
L.length++;
}
printf("線性表為：");
for(i=0;i<=n-1;i++)
printf("%d ",L.data[i]);
printf("\n");
return 1;
}

請看注釋(1)(2)

希望能幫助你哈^_^

C. C語言：1.建立含n個數據元素的順序表並輸出該表中各元素的值及順序表的長度。 緊急求 速度

1、

#include<iostream>
#include<cstdio>
#include<cstdlib>
usingnamespacestd;
typedefstructLnode{
	int*data;
	intlength;
	intmaxsize;
	structLnode*next;
}List;
voidcreatList(List&L,intn)
{
	intcount=0;
	L.data=(int*)malloc(sizeof(int)*n);
	if(!L.data)
		cout<<"申請空間失敗";
	cout<<"inputthenumbers";
	for(inti=0;i<n;i++)
	{
		cin>>L.data[i];
		count++;
	}
	L.length=count;
	L.maxsize=n;
}
voidInsert(List&L,inti,intdata)
{
	intj;
	if(i>=L.maxsize)
		cout<<"插入位置不對";
	if(L.length+1>=L.maxsize)
	{
		L.data=(int*)realloc(L.data,L.maxsize+sizeof(int)*L.maxsize);
		L.maxsize+=L.maxsize;
	}
	for(j=L.length-1;j>=i-1;j--)
	{
		L.data[j+1]=L.data[j];
	}
	L.data[j+1]=data;
	L.length+=1;
}
voidprint(ListL)
{
	cout<<"outputtheList:";
	for(inti=0;i<L.length;i++)
	{
		cout<<L.data[i]<<"";
	}
	cout<<endl;
}
voidmain()
{
	intm,number,locate;
	ListL;
	cout<<"pleaseinputthelengthofList:";
	cin>>m;
	creatList(L,m);
	print(L);
	cout<<":";
	cin>>locate>>number;
	Insert(L,locate,number);
	print(L);
	system("pause");
	
}

D. c語言實現順序表

--順序表.h
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define TRUE 1
#define FLASE 0
typedef int Elemtype;
typedef int Status;

/*介面定義
Status InitList_Sq(SqList &L,int size,int inc);
void CreateList_Sq(SqList &L);
void print_Sq(SqList &L);
int Search_Sq(SqList L, Elemtype e);
Status DestroyList_Sq(SqList &L);
Status ClearList_Sq(SqList &L);
Status ListEmpty_Sq(SqList L);
int ListLength_Sq(SqList L);
Status GetElem_Sq(SqList L, int i, Elemtype &e);
Status PutElem_Sq(SqList &L, int i, Elemtype e);
Status Append_Sq(SqList &L, Elemtype e);
Status DeleteLast_Sq(SqList &L, Elemtype &e);
*/
--------------------
#include "順序表.h"

//定義順序表類型
typedef struct {
Elemtype *elem;
int length;
int listsize;
int increment;
}SqList;

//初始化順序表
Status InitList_Sq(SqList &L,int size,int inc) {

L.elem = (Elemtype *)malloc(size * sizeof(Elemtype));
L.length = 0;
L.listsize = size;
L.increment = inc;
return TRUE;
}

//創建順序表
Status CreateList_Sq(SqList &L) {
int i;
printf("請輸入你要創建的順序表元素個數：\n");
scanf_s("%d", &L.length);
if (L.length >= L.listsize) {
L.elem = (Elemtype *)realloc(L.elem, (L.listsize + L.increment) * sizeof(Elemtype));
}
if (!L.elem) {
return FLASE;
}
printf("請輸入你要創建的順序表：\n");
for (i = 0; i<L.length; i++) {
scanf_s("%d", &L.elem[i]);
}
}

//遍歷順序表
void print_Sq(SqList &L) {
int i;
for (i = 0; i<L.length; i++) {
printf("%4d", L.elem[i]);
}
}

//查找元素的位置
int Search_Sq(SqList L, Elemtype e) {
int i = 0;
while (L.elem[i] != e&&i<L.length) {
i++;
}
if (i>L.length)
return -1;
else
return i + 1;//因為C語言是從下標為0開始的，當i=0時表示第一個元素
}

//銷毀順序表
Status DestroyList_Sq(SqList &L) {
if (L.elem == NULL)
return -1;
else
free(L.elem);
printf("\n銷毀成功\n");
return TRUE;
}

//清空順序表
Status ClearList_Sq(SqList &L) {
if (L.elem == NULL)
exit(0);
int i;
Elemtype *p_elem = L.elem;
for (i = 0; i<L.length; i++) {
*L.elem = NULL;
L.elem++;
}
L.elem = p_elem;
}

//判斷順序表是否為空
Status ListEmpty_Sq(SqList L) {
int i;
Elemtype* p_elem = L.elem;
for (i = 0; i<L.length; i++) {
if (*L.elem != 0) {
L.elem = p_elem;
return FLASE;
}
L.elem++;
}
return TRUE;
}

//求順序表的長度
int ListLength_Sq(SqList L) {
return L.length;
}

//用e返回順序表L中第i個元素的值
Status GetElem_Sq(SqList L, int i, Elemtype &e) {
int j;
Elemtype* p_elem = L.elem;
if (i<1 || i>L.length)
return FLASE;
for (j = 1; j <= i; j++)
L.elem++;
e = *L.elem;
L.elem = p_elem;
return TRUE;
}

//將順序表L中第i個元素賦值為e
Status PutElem_Sq(SqList &L, int i, Elemtype e) {
L.elem[i - 1] = e;
return TRUE;
}

//在順序表L表尾添加元素e
Status Append_Sq(SqList &L, Elemtype e) {

L.elem[L.length] = e;
L.length++;
L.listsize += L.increment;
return TRUE;
}

//刪除順序表L表尾元素
Status DeleteLast_Sq(SqList &L, Elemtype &e) {
e = L.elem[L.length - 1];
L.length--;
return TRUE;
}

********************************************主函數.c*************************************************

#include <stdio.h>
#include <stdlib.h>
#include "順序表.h"
#include "源代碼.h"

//--------------------主函數入口--------------------

int main(){
SqList L;
int size, inc;
int e;
int a;
int length;
int i;
int temp;
int j=10;
int ee;
printf("\n--------------------順序表初始化------------------\n");
printf("請輸入順序表的長度size以及擴容量：\n");
scanf_s("%d %d", &size, &inc);
InitList_Sq(L, size, inc);
CreateList_Sq(L);

printf("\n--------------------判斷是否為空------------------\n");

if(ListEmpty_Sq(L)){
printf("該順序表為空\n");
}
else
printf("該順序表不為空\n");

printf("\n--------------------遍歷順序表--------------------\n");

printf("此時順序表為：\n");
print_Sq(L);

printf("\n--------------------查找元素----------------------\n");

printf("\n請輸入要查找的元素：\n");
scanf_s("%d",&e);
a = Search_Sq(L, e);
printf("%d為第%d位：\n",e,a);

printf("\n--------------------輸出長度----------------------\n");

length = ListLength_Sq(L);
printf("順序表的長度為%d\n",length);

printf("\n----------將順序表L中第i個元素賦值為temp----------\n");

printf("請輸入第i個元素的i值和temp值：\n");
scanf_s("%d %d",&i,&temp);
PutElem_Sq(L, i, temp);
printf("\n此時順序表為：\n");
print_Sq(L);

printf("\n---------------在順序表表尾添加元素---------------\n");

Append_Sq(L, j);
printf("\n此時順序表為：\n");
print_Sq(L);

printf("\n---------------在順序表表尾刪除元素---------------\n");

DeleteLast_Sq(L, ee);
printf("\n被刪除的元素為%d\n",ee);
printf("此時順序表為：\n");
print_Sq(L);

printf("\n-------------------清空順序表---------------------\n");

ClearList_Sq(L);
if(ListEmpty_Sq(L)){
printf("\n清空成功\n");
}

printf("\n------------------銷毀順序表----------------------\n");

DestroyList_Sq(L);
getchar();
getchar();
return 0;
}

E. C語言順序表的基本操作

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

typedefintDataType;//定義數據數據類型

typedefstruct{
	DataType*data;//data指向數據區的首個數據
	intlength;//數據長度
}SqList;

voidSort(SqList*L){
	inti,j,k;
	DataTypetmp;
	for(i=0;i<L->length-1;++i){
		k=i;
		for(j=i+1;j<L->length;++j)
			if(L->data[k]>L->data[j])
				k=j;
		if(k!=i){
			tmp=L->data[k];
			L->data[k]=L->data[i];
			L->data[i]=tmp;
		}
	}
}

SqList*CreateList(DataTypea[],intn){
	inti;
	SqList*L;
	L=(SqList*)malloc(sizeof(SqList));
	L->data=(DataType*)malloc(n*sizeof(DataType));
	L->length=n;
	for(i=0;i<n;++i)L->data[i]=a[i];
	Sort(L);
	returnL;
}

intInsertList(SqList*L,DataTypex){
	inti,j;
	for(i=0;i<L->length;i++){
		if(x<=L->data[i]){
			for(j=L->length;j>=i;j--)
				L->data[j+1]=L->data[j];//結點後移
			L->data[i]=x;
			L->length++;
			return1;
		}
	}
	L->data[L->length++]=x;
	return1;
}

intRemoveListElem(SqList*L,DataTyped){
	inti,j;
	for(i=0;i<L->length;++i){
		if(L->data[i]==d){
			for(j=i;j<L->length-1;++j)
				L->data[j]=L->data[j+1];
			L->length--;
			return1;
		}
	}
	return0;
}

SqList*AndList(SqList*A,SqList*B){/*A∩B*/
	inti,j,k=0;
	intlen=(A->length>B->length)?B->length:A->length;
	SqList*C=(SqList*)malloc(sizeof(SqList));
	C->length=len;
	C->data=(DataType*)malloc(len*sizeof(DataType));
	for(i=0;i<A->length;++i){
		for(j=0;j<B->length;++j){
			if(A->data[i]==B->data[j]){
				C->data[k++]=A->data[i];
				break;
			}
		}
	}
	C->length=k;
	returnC;
}

SqList*OrList(SqList*A,SqList*B){/*A∪B*/
	inti,j,flag;
	DataTypee;
	SqList*C=(SqList*)malloc(sizeof(SqList));
	C->length=A->length+B->length;
	C->data=(DataType*)malloc(C->length*sizeof(DataType));
	for(i=0;i<A->length;++i)C->data[i]=A->data[i];
	for(i=0;i<B->length;++i){
		e=B->data[i];
		flag=1;
		for(j=0;j<C->length;++j){
			if(e==C->data[j]){
				flag=0;
				break;
			}
		}
		if(flag)InsertList(C,e);
	}
	returnC;
}

voidPrintList(SqList*L){
	inti;
	for(i=0;i<L->length;++i)
		printf("%d",L->data[i]);
	printf("
");
}

voidFreeList(SqList*L){
	free(L->data);
	free(L);
}

voidmain(){
	DataTypex;
	DataTypearra[]={36,24,31,5,90,65,70,39,37};
	DataTypearrb[]={9,8,43,51,37,89,33,46,29,80,56};
	intalen=sizeof(arra)/sizeof(arra[0]);
	intblen=sizeof(arrb)/sizeof(arrb[0]);
	SqList*A=CreateList(arra,alen);
	printf("A線性表為:");
	PrintList(A);
	SqList*B=CreateList(arrb,blen);
	printf("B線性表為:");
	PrintList(B);
	SqList*C=AndList(A,B);
	SqList*D=OrList(A,B);
	printf("C=A∩B:");
	PrintList(C);
	printf("D=A∪B:");
	PrintList(D);

	printf("在D表中插入數據:");
	scanf("%d",&x);
	InsertList(D,x);
	printf("D表插入x後:");
	PrintList(D);
	
	printf("刪除D表中數據:");
	scanf("%d",&x);
	RemoveListElem(D,x);
	printf("刪除x後的D表為:");
	PrintList(D);
	FreeList(A);
	FreeList(B);
	FreeList(C);
	FreeList(D);
}

F. 是C語言中建立順序表的程序

C語言中建立順序表的操作順序如下：

1.清空順序表：其實清空只不過將元素長度置0，讓後面插入數據函數的長度從0開始，其實並不是真正清空，之前的數據元素在內存中還存在，只不過可以被新元素覆蓋而已。

2.判斷順序表是否為空

G. 在C語言順序表中列印出各項的的和

#include <stdio.h>
#include <malloc.h>
#define maxsize 1024
typedef int datatype;
typedef struct{
datatype data[maxsize];
int last;
}sequenlist;
void displayLine(void){//畫一條線
printf("--------------------------------------\n");
}
int insert(sequenlist *L,datatype x,int i){//插入元素x
int j;
if((maxsize-1)==L->last){
printf("overflow");
return 0;
}
else if((i<0)||(i>L->last)){
printf("error,please input the right 'i'\n");
return 0;
}
else{
for(j=L->last;j>=i-1;j--)
L->data[j+1]=L->data[j];
L->data[i-1]=x;
L->last++;
}
return (1);
}
int dellist(sequenlist *L,int i){//刪除第i個元素
if((i<0)||(i>L->last)){
printf("error,please input the right 'i'\n");
return 0;
}
else{
for(int j=i;j<=L->last;j++)
L->data[j-1]=L->data[j];
L->last--;
return (1);
}
}
void creatlist(sequenlist *L){
int n,i;
int tmp;
displayLine();//畫一條線
printf("請輸入數據個數:\n");
scanf("%d",&n);
for(i=0;i<n;i++){
printf("data[%d]=",i);
fflush(stdin);//清除鍵盤緩沖區
scanf("%d",&tmp);
L->data[i]=tmp;
}
L->last=n-1;
displayLine();//畫一條線
}
void printout(sequenlist *L){//列印順序表
int i;
displayLine();//畫一條線
for(i=0;i<=L->last;i++){
printf("data[%d]=",i);
printf("%d\n",L->data[i]);
}
displayLine();//畫一條線
}
int add(sequenlist *L){
int i,sum=0;
for(i=0;i<=L->last;i++)
sum+=data[i];
return sum;
}
int main(void){
sequenlist *L;
char cmd;
int i,x;
L=(sequenlist *)malloc(sizeof(sequenlist));
creatlist(L);
printout(L);
do{
displayLine();//畫一條線
printf("請輸入你的選擇：\n");
printf("a,A為求和\n");
printf("i,I為插入\n");
printf("d,D為刪除\n");
printf("q,Q為退出\n");
displayLine();//畫一條線
do{
fflush(stdin);
scanf("%c",&cmd);
}while((cmd!='d')&&(cmd!='D')&&(cmd!='q')&&(cmd!='Q')&&(cmd!='I')&&(cmd!='i')&&(cmd!='A')&&(cmd!='a'));
switch(cmd){
case'a':case'A':
int sum=add(L);
printf("求和的結果是:%d\n",sum);
break;
case'i':case'I':
printf("請輸入你要插入的數據：");
fflush(stdin);
scanf("%d",&x);
printf("請輸入你要插入的位置：");
scanf("%d",&i);
insert(L,x,i);
printout(L);
break;
case'd':case'D':
printf("請輸入你要刪除的數據位置：");
fflush(stdin);
scanf("%d",&i);
dellist(L,i);
printout(L);
break;
}
}while((cmd!='q')||(cmd!='Q'));

return 0;
}

H. 用C語言編寫一個有關順序表的程序代碼

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

#define Size 50

//定義順序表結構體類型

typedef struct Table{
int*head;//順序表頭指針,為整型
int length;//順序表中元素個數
int size; //順序表的長度
}Table;

//創建順序表
Table CreateTable(){
Table T;
if(!(T.head=(int*)malloc(Size*sizeof(int)))){
printf("內存分配錯誤!\n");
exit(0);
}

T.size=Size;
T.length=0;
return T;
}

//增加
void Insert(Table T,int set,int values)//set為插入的位置，values為值
{
//首先判斷插入位置是否正確
if(set<0||set>T.length){
printf("插入位置不正確!\n");
reutrn;
}

//判斷是否有足夠的內存空間存儲增加的數
if(T.length==T.size){
if(!(T.head=(int*)realloc(T.head,(T.size+10)*sizeof(int)))){
printf("內存分配錯誤!\n");
exit(0);
}
T.size+=10;
}

//插入數據
for(int i=s.length;i>set;i--)
T.head[i]=T.head[i-1];

T.head[set]=values;
T.length++;
}

//刪除
void Delete(Tabel T,int set)
{
if(set<0||set>=T.length)
{
printf("刪除數的位置不爭確，刪除失敗!\n");
return;
}

//輸出數據
for(int i=set;i<s.length;i++)
T.head[i]=T.head[i+1];
T.length--;
}

//查找
int Search(Tabel T,int value)
{
for(int i=0;i<T.length;i++)
if(T.head[i]==value)
return i;
return -1;
}

I. 數據結構 用C語言實現順序表的建立及遍歷

#include<stdio.h>
#include<malloc.h>

typedefstructnlist
{
int*np;
intlen;//已使用地址個數
intmaxlen;//最大地址個數
}NLT;

NLT*createlist();//創建順序表
intaddtolist(NLT*nlist);//向順序表插入元素
voidpList(NLT*nlist);//遍歷順序表
intmain()
{
inti;
NLT*nlist=createlist();
if(nlist)
{
for(i=0;i<nlist->maxlen;i++)
addtolist(nlist);
pList(nlist);
}
return0;
}
voidpList(NLT*nlist)//遍歷列印,空格分割，最後一個數後面沒有空格
{
inti;
for(i=0;i<nlist->len-1;i++)
printf("%d",nlist->np[i]);
printf("%d",nlist->np[nlist->len-1]);
}
NLT*createlist()
{
NLT*nlist=NULL;
nlist=(NLT*)malloc(sizeof(NLT));
scanf("%d",&nlist->maxlen);
nlist->np=(int*)malloc(sizeof(int)*nlist->maxlen);
if(!nlist||!nlist->np)
{
printf("內存申請失敗！ ");
returnNULL;
}
nlist->len=0;
returnnlist;
}
intaddtolist(NLT*nlist)
{
if(nlist->len<nlist->maxlen)//如果存儲空間未滿，保存元素,保存成功返回1失敗返回0
{
scanf("%d",&nlist->np[nlist->len]);
nlist->len++;
return1;
}
else//這里可以寫當存儲滿的之後，空間擴容，本題用不到所以我不寫了
return0;
}

J. c語言順序表的創建程序

/*
*程序不足之處：1，main函數不應該為 void main
* 2，創建空的順序表函數中 SqList L;//定義順序表L L是局部變數，

函數結束即銷毀，應該用指針代替
* 3，SqList CreateList(SqList L) //創建順序表（非空）函數中：

scanf("%d",&L.elem); L裡面的elem本來就是地址，

沒必要再加&符號，且每次輸入都一直放在首地址，

沒達到程序所要表達的意思
* 4，void print(SqList L) //輸出當前順序表 函數中：

printf("%-3d",L.elem); 和上面是一樣的道理
* 5，main函數中沒有將申請的內存釋放
*現將程序稍作修改如下，望採納
*/

#include<stdio.h>
#include<stdlib.h>
#define LIST_INIT_SIZE 100
#define Icreament 20
typedef int ElemType; //用戶自定義數據元素類型

typedef struct
{
ElemType *elem; //順序表的基地址
int length; //順序表的當前長度
int listsize; //預設空間容量
}SqList; //線性表的順序存儲結構

SqList* InitList() //創建空的順序表
{
SqList* L = (SqList*)malloc(sizeof(SqList));//定義順序表L
if(!L)
{
printf("空間劃分失敗，程序退出 ");
return NULL;
}
L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L->elem)
{
printf("空間劃分失敗，程序退出 ");
return NULL;
}
L->length=0;
L->listsize=LIST_INIT_SIZE;
return L;
}

int CreateList(SqList* L) //創建順序表（非空）
{
int number; //順序表中元素的個數
int i; //循環變數
printf("請輸入順序表中元素的個數：");
scanf("%d",&number);
if(number > LIST_INIT_SIZE)//一定要判斷輸入的個數是否大於順序表的最大長度
{
printf("輸入個數大於順序表的長度 ");
return 0;
}

for(i=0;i<number;i++)
{
printf("輸入第%d個數: ",i+1);
scanf("%d",L->elem+i);//L->elem+i：每次的輸入都保存在順序表元素中的下一個地址，而不是一直放在元素的首地址
}//給順序表中每個數據元素賦值
L->length=number; //當前順序表的長度
return 1;
}
void print(SqList* L) //輸出當前順序表
{
int i;
for(i=0;i<L->length;i++)
{
printf("%-3d",*(L->elem + i));//L->elem+i：和輸入是一個道理
}
printf(" ");
}
int main()
{
SqList* L = InitList();//申請一個指向順序表的指針，並對其初始化
if(!L)//判斷申請是否成功
{
printf("初始化線性表失敗 ");
return 1;
}
if(!CreateList(L))//判斷創建順序表是否成功
{
printf("創建順序表失敗 ");
return 1;
}
print(L);//列印順序表
free(L->elem);//釋放申請的順序表元素的內存
free(L);//釋放申請的順序表內存
return 0;
}

運行效果如圖：