A. c語言目錄操作
我不知道樓主具體指的是什麼？什麼叫取得目錄中的函數名？是指文件名嗎？
如果是的話，看這個程序：
#include <process.h>
main()
{
clrscr();
system("dir e:\\younger"); /*"e:\\younger"可以改成任意目錄*/
getch();
}
這樣可以嗎？
B. C語言數組四個基本操作
#include<stdio.h>
#include<stdlib.h>
#include<string.h>void main()
{
int e,index,temp,j,l,i;
int a[11];
printf("輸入10個數\n");
for(i=0;i<10;i++)
scanf("%d",&a[i]);
for(i=0;i<10;i++) //顯示
printf("%d ",a[i]);printf("\n你需要查找的元素\n");
scanf("%d",&e);
for(i=0;i<10;i++)
{
if(a[i]==e) printf("%d ",i+1); //如果存在，返回其位置
}
printf("\n你需要插入的元素\n");
scanf("%d",&a[10]);
printf("\n排序\n");
for(i=0;i<11;i++)
{index=i;<br> for(j=i+1;j<11;j++)<br> if(a[index]<a[j])<br> index=j;<br> temp=a[i];<br> a[i]=a[index];<br> a[index]=temp;<br>}for(i=0;i<11;i++)
printf("%d ",a[i]);}刪除實現不了
C. 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);
}
D. C語言怎麼操作數組
這是個動態分配的問題可以用
realloc()函數真的很好用的，這里我也不多說了，
給個例子看看，這個是我以前在網路上看到的。很久了都忘了你自己看看，看不懂再說
#include"stdio.h"
#include"stdlib.h"
main()
{int i=0;
char *c,x;
c=malloc(sizeof(char));
while((x=getchar())!='\n')
{i++;
c=realloc(c,i*sizeof(char));
c=x;
}
for(;i>0;i--)
printf("%c",(c--));
printf("\n");
system("pause");
}這是模擬棧的作用
需要用。。。
E. C語言基本操作
標准輸入輸出應加頭文件其預處理命令為
＃include<stdio.h>(是C的編譯器的話可以不加)
printf(格式控制，輸出列表）如：
pritnf("%d,%c\n",a,b)
函數原型 int printf(char *format,arg,……)
scanf(格式控制，輸出列表）如：
scanf("%d,%c\n",&a,&b)
函數原型 int scanf(char *format,arg,……)
其他常用的標准輸入輸函數如getchar,gets,putchar,puts等在這里就不具體說明了
請參看C庫函數(C語言的書上都有)
F. C語言鏈表結點操作
鏈表中，假設有一個頭節點，即一個head指針指向鏈表的第一個節點，如果要查找目的節點，可以從頭開始往後搜索，注意，head節點指向的是一個數據結構，該結構包括element(元素值)，還有一個next指針，該指針指向下一個鏈表節點。遍歷鏈表進行查找時，循環條件可以是while(pone !=NULL)，在循環內部就不斷調用pone=pone.next，一旦找到滿足條件的就退出循環，即break。在這里假設鏈表為a->b->c，假設pone指向a節點，可以通過pone.element訪問a節點的值，並且pone.next就是b，在循環過程中，pone=pone.next，如果當前的pone為a，那麼執行這句話後就是將b給pone，即將pone指針指向b，在循環中一直使用這句話就可以保證pone一直向後移動直到找到目標節點。希望可以幫到你。
G. C語言數組操作問題
不可以.
數組a[]={1,2,3,4}
這樣初始化,表示只有4個元素的數組.不能再增加元素了.
數組a[10]={1,2,3,4}
這樣就可以.
H. 對C語言數組的操作
一樓有點錯誤
printf("最小數下標是%d
\n最小數是
%d\n",k+1,min);
c語言下標從0開始標記，輸出要加1才對。
I. C語言鏈表操作
包括鏈表的創建刪除添加和釋放操作！！
#include<stdio.h>
#include<stdlib.h>
struct node *create();
void print_list(struct node *head);
struct node * insert_node(struct node *h,int x,int y);
struct node * delete_node(struct node *h,int z);
void shifang(struct node *head);
struct node
{
char data;
struct node *next;
};
void main()
{
struct node *head;
int x,y,z;
head=create();
print_list(head);
printf("\n輸入插入結點的位置的值和插入的數值：");
scanf("%d%d",&x,&y);
head=insert_node(head,x,y);
print_list(head);
printf("\n輸入要刪除的結點：");
scanf("%d",&z);
head=delete_node(head,z);
print_list(head);
printf("\n釋放鏈表.\n");
}
struct node *create() //建立鏈表函數
{
printf("請輸入各節點（以-1結尾）：\n");
int x;
//定義指針*head，*tail，*s;
struct node *head,*tail,*s;
//head和tail初始化，生成一個頭結點
head=tail=(struct node *)malloc(sizeof(struct node));
//在循環中，生成新結點、賦值、連接、尾指針後移
scanf("%d",&x);
while(x!=-1)
{
s=(struct node *)malloc(sizeof(struct node));
s->data=x;
tail->next=s;
tail=s;
scanf("%d",&x);
}
//尾結點的指針域賦NULL
tail->next=NULL;
return head;
}
void print_list(struct node *head) //輸出鏈表函數
{
//定義工作指針*p並賦初值p=head->next；即指向第一個結點
struct node *p;
p=head->next;
//判斷鏈表是否為空，空：輸出空表的信息，否則：輸出所有結點
if(p==NULL)
printf("The list is NULL.");
else
//在循環中輸出當前結點，工作指針後移
{
printf("head->");
while(p!=NULL)
{
printf("%d->",p->data);
p=p->next;
}
printf("end.");
}
}
struct node * insert_node(struct node *h,int x,int y) //添加結點函數
{
struct node *p,*q,*s;
//生成要插入的新結點
s=(struct node *)malloc(sizeof(struct node));
s->data=y;
q=h;
p=h->next;
//查找要插入結點的位置
while((p!=NULL)&&(p->data!=x))
{
q=p;
p=p->next;
}
//插入結點
q->next=s;s->next=p;
return(h);
}
struct node * delete_node(struct node *h,int z) //刪除結點函數
{
struct node *p,*q;
q=h;
p=h->next ;
//查找要刪除結點的位置
if(p!=NULL)
{
while((p!=NULL)&&(p->data!=z))
{
q=p;
p=p->next;
}
//釋放結點
if(p->data ==z)
{
q->next=p->next ;
free(p);
}
}
return(h);
}
void shifang(struct node *head) //釋放鏈表函數
{
struct node *p;
//逐個釋放結點
while(head!=NULL)
{
p=head;
head=head->next;
free(p);
}
}
J. 線性表的基本操作c語言實現
代碼如下：
頭文件：
2_1.h
#ifndef _2_1_H
#define _2_1_H
typedef void SeqList;
typedef void SeqListNode;
//創建線性表
SeqList * SeqList_Create(int capacity);
//銷毀線性表
void SeqList_DesTroy(SeqList * list);
void SeqList_Clear(SeqList* list);
int SeqList_Length(SeqList* list);
int SeqList_Capacity(SeqList* list);
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);
SeqListNode* SeqList_Get(SeqList* list, int pos);
SeqListNode* SeqList_Delete(SeqList* list, int pos);
#endif
源文件：
// 順序線性表.cpp : 定義控制台應用程序的入口點。
//
#include "stdafx.h"
#include <malloc.h>
#include <stdlib.h>
#include "2_1.h"
typedef unsigned int TSeqListNode;
typedef struct {
int len; //長度
int capacity;//總長度
TSeqListNode * node;//每個節點的指針
} TSeqList;
int main()
{
SeqList* list = SeqList_Create(5);//創建線性表
int i = 6;//賦值6個變數，已超過線性表最大值 5
int j = 1;
int k = 2;
int x = 3;
int y = 4;
int z = 5;
int index = 0;
SeqList_Insert(list, &i, 7); //將這6個變數插入線性表中
SeqList_Insert(list, &j, 0);
SeqList_Insert(list, &k, 0);
SeqList_Insert(list, &x, 0);
SeqList_Insert(list, &y, 0);
SeqList_Insert(list, &z, 0);
//遍歷
for(index=0; index<SeqList_Length(list); index++)
{
int* p = (int*)SeqList_Get(list, index);
printf("%d ", *p);
}
printf(" ");
//刪除操作
while( SeqList_Length(list) > 0 )
{
int* p = (int*)SeqList_Delete(list, 0);
printf("刪除了： %d ", *p);
}
SeqList_Clear(list);
SeqList_DesTroy(list);
system("pause");
return 0;
}
//創建線性表
SeqList * SeqList_Create(int capacity)
{
TSeqList* ret = NULL ;
if(capacity >= 0)
{
ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode)*capacity); //為線性表分配空間，包含結 //構體和節點的總大小
}
if(NULL != ret)
{
ret->len = 0;
ret->capacity = capacity;
ret->node = (TSeqListNode*)(ret + 1);//將節點指向上述分配到的空間的後部分
}
return ret;
}
//銷毀
void SeqList_DesTroy(SeqList * list)
{
free(list);
}
//清空
void SeqList_Clear(SeqList* list)
{
TSeqList * ret = (TSeqList*)list;
if(NULL != ret)
{
ret->len = 0;
}
}
//獲得線性表的長度
int SeqList_Length(SeqList* list)
{
TSeqList * ret = (TSeqList*)list;
int len = -1;
if(NULL != ret)
{
len = ret->len;
}
return len;
}
//線性表的總長度
int SeqList_Capacity(SeqList* list)
{
TSeqList * ret = (TSeqList*)list;
int capacity = -1;
if(NULL != ret)
{
ret->capacity = capacity;
}
return capacity;
}
//插入
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
TSeqList * sList = (TSeqList*)list;
int i,ret = -1;
if((sList != NULL) &&(pos >= 0) && sList->capacity >= sList->len+1)
{
if(pos >= sList->len)
{
pos = sList->len;
}
for(i = sList->len; i > pos; i--)
{
sList->node[i] = sList->node[i-1];
}
sList->node[i] = (TSeqListNode)node;
++sList->len;
ret = 1;
}
return ret;
}
//獲得指定位置的節點
SeqListNode* SeqList_Get(SeqList* list, int pos)
{
TSeqList * sList = (TSeqList*)list;
TSeqListNode* node = NULL;
if(NULL != sList && pos>=0 && pos < sList->len)
{
node = (TSeqListNode*)sList->node[pos];
}
return node;
}
//刪除
SeqListNode* SeqList_Delete(SeqList* list, int pos)
{
TSeqList * sList = (TSeqList*)list;
SeqListNode * node = SeqList_Get( list, pos);
int i;
if(sList != NULL && pos >= 0 && pos< sList->len)
{
for( i=pos+1; i<sList->len; i++)
{
sList->node[i-1] = sList->node[i];
}
sList->len--;
}
return node;
}
演示：
資料拓展：
線性表是最基本、最簡單、也是最常用的一種數據結構。
線性表中數據元素之間的關系是一對一的關系，即除了第一個和最後一個數據元素之外，其它數據元素都是首尾相接的（注意，這句話只適用大部分線性表，而不是全部。比如，循環鏈表邏輯層次上也是一種線性表（存儲層次上屬於鏈式存儲），但是把最後一個數據元素的尾指針指向了首位結點）。
我們說「線性」和「非線性」，只在邏輯層次上討論，而不考慮存儲層次，所以雙向鏈表和循環鏈表依舊是線性表。
在數據結構邏輯層次上細分，線性表可分為一般線性表和受限線性表。一般線性表也就是我們通常所說的「線性表」，可以自由的刪除或添加結點。受限線性表主要包括棧和隊列，受限表示對結點的操作受限制。
線性表的邏輯結構簡單，便於實現和操作。因此，線性表這種數據結構在實際應用中是廣泛採用的一種數據結構。