c語言空表順序

『壹』 在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語言建立空順序表，只要一個空表，求大神給串完整的代碼，能運行的，謝謝

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

constintMAXSIZE=檔岩漏20;//表長
typedefintDataType;

typedefstructlist{
	DataTypedata[MAXSIZE];
	intsize;
}SqList;

intmain(){
	SqListaL;//聲明一個表
	inti,j,flag;
	DataTypex;
	memset(aL.data,0,MAXSIZE);//表元素清零
	aL.size=0;
	srand((unsigned)time(NULL));
	for(i=0;i<MAXSIZE;行爛++i){
		x=rand()%100+1;
		flag=1;
		for(j=0;j<aL.size&&flag;++j)
			flag=(aL.data[j]!=x);
		if(flag==0)--i;
		else{
			aL.data[aL.size]=棗鄭x;
			++aL.size;
		}
	}
	for(i=0;i<aL.size;++i)
		printf("%d",aL.data[i]);
	printf("
");
	return0;
}

『叄』 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;
}

運行效果如圖：

『肆』 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;
}

『伍』 c語言程序問題 數據結構之空順序表定義

l=(senlsy*)macllo(sizeof(senlsy));當程序執行完這步這後，
l就指向了這個新申請的節點。
還賀滲簡有l->length=0;執行完這步禪褲，l沒變喊睜化。

其實你可以調試一下，l的具體值你都可以知道。

『陸』 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);
}
這里就簡要的寫了下第一小問，時間問題，沒有調試，你自己看看
其實網上這方面的資料很多的，你可以網路一下

『柒』 c語言數據結構，順序表

創建順序表

/**
* 創建順序表
*/
SqList createList_sq() {
//SqList list;
//return list;

SqList* list = (SqList*)malloc(sizeof(SqList));
return *list;
}
這里模亮提供兩種創建順序表的代碼，一種是由系統分配list佔用的內存，一種李碼羨是自己動態哪拍分配的內存，需要在程序運行之前手動釋放佔用的內存空間。
初始化順序表

/**
* 初始化順序表
* 返回1 表示初始化成功
* 返回0 表示初始化失敗
*/
int initList_sq(SqList &L) { //只有在C++中才會有引用的存在
L.elem = (SeqType *) malloc(sizeof(SeqType) * LIST_INIT_SIZE);
if (!L.elem)
return 0; //內存分配失敗，存儲空間不夠
L.length = 0; //表示順序表為空
L.listsize = LIST_INIT_SIZE; //表示順序表裡，最大存儲單元個數
return 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
分配順序表的存儲單元，初始化順序表屬性的值。
插入元素

/**
* 插入順序表
* 下標是負數就插入到結尾

『捌』 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);
}

『玖』 c語言建立空順序表

從答游貼上來的代碼看不出有什麼問題，下面提兩條建議:
1、作為鏈表數據類型，其內部應該有一個預先定義大小的數升咐組，你這里用int *elem，這只是一個指針，你是否打算在需要時再申請動態內存空間?
2、鏈表數據&L作為函吵舉純數實參是什麼意思？應該是*L才對，而作為函數形參，*L是錯的，而&L是對的。請體會！

『拾』 如何建造一個空的順序表，然後再向裡面插入數據，C語言

#include<stdio.h>
#include<stdlib.h>
/*
1.創建結構體-----具體事物的抽象
2.創建鏈表
3.創建結點
4.插入操作
4.1表頭插入
4.2表尾插入
4.3指定位置插入(指定位置的前面)
5.刪除操作
5.1表頭刪除
5.2表尾刪除
5.3指定位置刪除
6.判斷是否為空
7.列印鏈表
*/
//單鏈表的結構體
typedefstructSingleList
{
//數據域
intdata;//以這個數據為例
//structMMmyMM;
//指針域
structSingleList*next;
}LIST,*LPLIST;
/*
別名:習慣大寫
起別名---小名
//好處:單詞少,好看(含義更精簡)
structSingleList換一種叫法:LIST;
strcutSingleList*換一種叫法:LPLIST
*/
//------->2.創建鏈表---任何結構都需要用一個東西去表示
LPLISTCreateList()
{
//創建過程就是初始化過程---初始化基本數據成員過程
//需要內存空間
LPLISTList=(LPLIST)malloc(sizeof(LIST));
if(List==nullptr)
{
printf("失敗了
");
system("pause");
exit(0);
}
//初始化基本數據成員----有表頭的鏈表
List->next=nullptr;
returnList;
}
//------->3.創建結點
LPLISTCreateNode(intdata)
{
//1.需要內存
LPLISTNode=(LPLIST)malloc(sizeof(LIST));
//2.初始化基本數據成員
Node->data=data;//和創建鏈表多了數據域
Node->next=nullptr;
returnNode;
}
//------->4.1頭插法
//函數寫法:形參可以表示要操作的東西
//插入的鏈表是(List),插入的數據是多少(data)
voidInsertListHeadNode(LPLISTList,intdata)
{
//插入:創建插入的結點
LPLISTnewNode=CreateNode(data);//創建結點賣察
//插入操作
newNode->next=List->next;
/*
c=1
b=2
a=c;
c=b;
*/
List->next=newNode;
}
//------->4.2尾插法
voidInsertListTailNode(LPLISTList,intdata)
{
//找到表尾--->定義一個移動的指針
LPLISTtailNode=List;
while(tailNode->next!=nullptr)
{
tailNode=tailNode->next;
}
//創建插入的結點
LPLISTnewNode=CreateNode(data);
tailNode->next=newNode;
}
//------->4.3指定位置
voidInsertListAppoinNode(LPLISTList,intdata,intPosData)
{
//創建兩個移動的指針:去找指定位置和指定位置的前面
LPLISTfrontNode=List;
//frontNode->next==taiNode:判斷相鄰
LPLISTtailNode=List->next;
//判斷是否為空
while(tailNode->data!=PosData)
{
/*
frontNode=frontNode->next;
tailNode=tailNode->next;
*/
frontNode蔽配畝=tailNode;
tailNode=frontNode->next;
if(tailNode==nullptr)
{
printf("未找到指定位置
");
system("pause");
exit(0);
}
}
//tailNode->data=data;
宏森//找到後創建插入的結點
LPLISTnewNode=CreateNode(data);
frontNode->next=newNode;
newNode->next=tailNode;
}

//------->5.判斷是否為空
//和創建的時候比較
intIsEmptyList(LPLISTList)
{
if(List->next==nullptr)
return1;//返回1表示為空
return0;//表示不為空
}
////------->6.列印數據
voidPrintList(LPLISTList)
{
if(IsEmptyList(List))
{
printf("鏈表為空,無法列印");
system("pause");
exit(0);
}
LPLISTpNext=List->next;
while(pNext!=nullptr)
{
printf("%d	",pNext->data);
pNext=pNext->next;
}
printf("
");
}
//------->7.刪除
//頭刪除
voidDeleteListHeadNode(LPLISTList)
{
if(IsEmptyList(List))
{
printf("鏈表為空,無法刪除
");
system("pause");
exit(0);
}
LPLISTDNode=List->next;
List->next=DNode->next;
free(DNode);
DNode=nullptr;
}
//------->8.尾刪
voidDeleteListTailNode(LPLISTList)
{
if(IsEmptyList(List))
{
printf("鏈表為空,無法刪除
");
system("pause");
exit(0);
}
//找到表尾--->定義一個移動的指針
LPLISTtailNode=List->next;
LPLISTtailFront=List;
while(tailNode->next!=nullptr)
{
tailFront=tailNode;
tailNode=tailFront->next;
}
tailFront->next=nullptr;
free(tailNode);
}
//------->9.指定位置刪除
voidDeleteListAppoinNode(LPLISTList,intPosData)
{
//創建兩個移動的指針:去找指定位置和指定位置的前面
LPLISTfrontNode=List;
//frontNode->next==taiNode:判斷相鄰
LPLISTtailNode=List->next;
//判斷是否為空
while(tailNode->data!=PosData)
{
/*
frontNode=frontNode->next;
tailNode=tailNode->next;
*/
frontNode=tailNode;
tailNode=frontNode->next;
if(tailNode==nullptr)
{
printf("未找到指定位置
");
system("pause");
exit(0);
}
}
frontNode->next=tailNode->next;
free(tailNode);
}

intmain()
{
LPLISTList=CreateList();//List創建成功
printf("插入:
");
InsertListHeadNode(List,1);
InsertListHeadNode(List,2);
InsertListHeadNode(List,3);
InsertListTailNode(List,0);
PrintList(List);
printf("刪除:
");
DeleteListHeadNode(List);
PrintList(List);
DeleteListTailNode(List);
PrintList(List);
printf("指定位置:
");
//看不懂,可以找群主
InsertListAppoinNode(List,4,2);
InsertListAppoinNode(List,3,2);
//C/C++8群
PrintList(List);
//491994603
DeleteListAppoinNode(List,2);
PrintList(List);
system("pause");
return0;
}

以上代碼偏多,主要是多個層次和多個角度,全方位書寫順序表,真正項目一般使用一種插入和刪除方法.