❶ 數據結構實驗（用c語言寫） 棧的基本操作
//順序棧
#include
#include
#include
#define
STACK_INIT_SIZE
100;
#define
STACKINCREMENT
10;
typedef
struct
{
int
*base;
int
*top;
int
stacksize;
}SqStack;
typedef
int
ElemType;
int
InitStack(SqStack
&S)
//為棧S分配存儲空間，並置S為空棧
{
int
size
=
STACK_INIT_SIZE;
S.base=(int
*)malloc(size*sizeof(ElemType));
if(!S.base)
return
0;
S.top=S.base;
//置棧S為空棧
S.stacksize=STACK_INIT_SIZE;
return
1;
}
int
GetTop(SqStack
S,int
&e)
//若棧不空，則用e返回S的棧頂元素
{
if(S.top==S.base)
return
0;
e=*(S.top-1);
return
1;
}
int
Push(SqStack
&S,
int
e)
/*進棧函數,將e插入棧S中,並使之成為棧頂元素*/
{
if(S.top-S.base>=S.stacksize)
/*棧滿，追加存儲空間*/
{
int
stackinvrement
=
STACKINCREMENT;
S.base=(ElemType
*)
realloc(S.base,(S.stacksize+stackinvrement)*sizeof(ElemType));
if(!S.base)
return
0;
/*存儲分配失敗*/
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return
1;
}
int
Pop(SqStack
&S,int
&e)/*出棧函數,若棧S不空,則刪除S的棧頂元素,用e返回其值*/
{
if(S.top==S.base)
return
0;
e=*--S.top;
return
1;
}
void
OutputStack(SqStack
&S)
{int
*q;
q=S.top-1;
for(int
i=0;i
#include
typedef
struct
SNode
{
int
data;
struct
SNode
*next;
}SNode,*LinkStack;
LinkStack
top;
LinkStack
PushStack(LinkStack
top,int
x)
//入棧
{
LinkStack
s;
s=(LinkStack)malloc(sizeof(SNode));
s->data=x;
s->next=top;
top=s;
return
top;
}
LinkStack
PopStack(LinkStack
top)
//退棧
{
LinkStack
p;
if(top!=NULL)
{
p=top;
top=top->next;
free(p);
printf("退棧已完成\n");
return
top;
}
else
printf("棧是空的，無法退棧！\n");
return
0;
}
int
GetStackTop(LinkStack
top)
//取棧頂元素
{
return
top->data;
}
bool
IsEmpty()//bool取值false和true，是0和1的區別,bool只有一個位元組,BOOL為int型,bool為布爾型
{
return
top==NULL
?
true:false;
}
void
Print()
{
SNode
*p;
p=top;
if(IsEmpty())
{
printf("The
stack
is
empty!\n");
return;
}
while(p)
{
printf("%d
",
p->data);
p=p->next;
}
printf("\n");
}
void
main()
{
int
x,a,b;
char
m;
do
{
printf("\n");
printf("###############鏈棧的基本操作##################\n");
printf("××××××××1.置空棧××××××××××\n");
printf("××××××××2.進棧×××××××××××\n");
printf("××××××××3.退棧×××××××××××\n");
printf("××××××××4.取棧頂元素××××××××\n");
printf("××××××××5.退出程序×××××××××\n");
printf("##############################################\n");
printf("\n請選擇一個字元:");
scanf("%c",&m);
switch(m){
case
'1':
top=NULL;
printf("\n棧已置空!");
break;
case
'2':
printf("\n請輸入要進棧的元素個數是:");
scanf("%d",&a);
printf("\n請輸入要進棧的%d個元素:",a);
for(b=0;b
評論
0
0
載入更多
❷ 數據結構實驗（C語言）： 順序表實驗
//線性表函數操作
#include <stdio.h>
#include <string.h>
#define MaxSize 30
#define Error 0
#define True 1
typedef char ElemType;
typedef struct
{
ElemType elem[MaxSize];
int length;
}sqlist; /*順序表類型定義*/
void InitList(SqList * &L) /*初始化順序表L*/
{
L = (SqList *)malloc(sizeof(SqList));
L -> length = 0;
}
void DestroyList( SqList *L ) /*釋放順序表L*/
{
free(L);
}
int ListEmpty( SqList *L ) /*判斷順序表L是否為空表*/
{
return( L -> length == 0);
}
int ListLength( SqList *L ) /*返回順序表L的元素個數*/
{
return( L -> length);
}
void DispList( SqList *L ) /*輸出順序表L*/
{
int i;
if( ListEmpty(L))
return;
for( i = 0; i < L -> length; i++ )
printf("%c", L -> elem[i]);
printf("\n");
}
int GetElem( SqList *L, int i, ElemType &e) /*獲取順序表中的第i個元素*/
{
if( i < 1 || i > L -> elem[i])
return Error;
e = L -> elem[i - 1];
return True;
}
int LocateElem( SqList *L, ElemType e) /*在順序表中查找元素e*/
{
int i = 0;
while( i < L -> length && L -> elem[i] != e)
i++;
if(i >= L -> length)
return Error;
else
return i+1;
}
int ListInsert( SqList * &L, int i, ElemType e) /*在順序表L中第i個位置插入元素e*/
{
int j;
if( i < 1 || i > L -> length + 1)
return 0;
i--; /*將順序表位序轉化為elem下標*/
for( j = L -> length; j > i; j--) /*將elem[i]及後面元素後移一個位置*/
L -> elem[j] = L -> elem[j - 1];
L -> elem[i] = e;
L -> length++; /*順序表長度增1*/
return True;
}
int ListDelete( SqList * &L, int i, ElemType &e) /*順序表L中刪除第i個元素*/
{
int j;
if( i < 1 || i > L -> length)
return Error;
i--; /*將順序表位序轉化為elem下標*/
e = L -> elem[i];
for(j = i; j < L -> length - i; j++)
L -> elem[j] = L -> elem[j + 1];
L -> length--; /*順序表長度減1*/
return True;
}
void main()
{
SqList *L;
ElemType e;
printf("(1)初始化順序表L\n");
InitList(L);
printf("(2)依次採用尾插法插入a,b,c,d,e元素\n");
ListInsert(L, 1, 'a');
ListInsert(L, 2, 'b');
ListInsert(L, 3, 'c');
ListInsert(L, 4, 'd');
ListInsert(L, 5, 'e');
printf("(3)輸出順序表L:");
DispList(L);
printf("(4)順序表L長度 = %d\n", ListLength(L));
printf("(5)順序表L為%s\n", (ListEmpty(L) ?"空" :"非空"));
GetElem(L, 3, e);
printf("(6)順序表L的第3個元素 = %c\n", e);
printf("(7)元素a的位置 = %d\n", LocateElem(L,'a'));
printf("(8)在第4個元素位置上插入f元素\n");
ListInsert(L, 4, 'f');
printf("(9)輸出新的順序表L:");
DispList(L);
printf("(10)刪除L的第3個元素\n");
ListDelete(L, 3, e);
printf("(11)輸出新的順序表L:");
DispList(L);
printf("(12)釋放順序表L\n");
DestroyList(L);
}
❸ 咋寫C語言實驗報告
c（c++）上機實驗報告格式：
⒈ 實驗目的
(1) 了解在具體的語言環境下如何編輯、編譯、連接和運行一個 C 程序。
⑵ 通過運行簡單的 C 程序,初步了解 C 源程序的特點。
⑶ 掌握 C 語言數據類型,熟悉如何定義一個整型、字元型和實型的變數,以及對它們賦值的方法。
⑷ 掌握不同的類型數據之間賦值的規律。
⑸ 學會使用 C 的有關算術運算符,以及包含這些運算符的表達式,特別是自加（++）和自減（--）運算符的使用。
2.實驗內容和步驟
⑴ 檢查所用的計算機系統是否已安裝了 C 編譯系統並確定他所在的子目錄。
⑵ 進入所用的集成環境。
⑶ 熟悉集成環境的界面和有關菜單的使用方法。
⑷ 輸入並運行一個簡單的、正確的程序。
⒊ 實驗題目
⑴ 輸入下面的程序
# include 「stdio.h」 void main()
{ printf(「This is a c program. 」); }
❹ c語言數據結構
對於排序演算法來說，不管用哪種演算法實現，都是要做「比較」操作和「移動」操作（或者說交換）。第（2）條要求就是要你分別統計「選擇排序、插入排序、交換排序、歸並排序等各種排序方法」，在對100個元素進行排序時，分別作了多少次「比較」操作和多少次「移動」操作。
對於查找演算法來說，不管用哪種演算法實現，，都是要做「比較」操作。第（3）條要求，就是要你分別統計順序查找和二分查找，分別要做多少次「比較」操作。
❺ C語言實驗
哈夫曼編碼(Huffman Coding)是一種編碼方式，以哈夫曼樹—即最優二叉樹，帶權路徑長度最小的二叉樹，經常應用於數據壓縮。 在計算機信息處理中，「哈夫曼編碼」是一種一致性編碼法（又稱"熵編碼法"），用於數據的無損耗壓縮。這一術語是指使用一張特殊的編碼表將源字元（例如某文件中的一個符號）進行編碼。這張編碼表的特殊之處在於，它是根據每一個源字元出現的估算概率而建立起來的（出現概率高的字元使用較短的編碼，反之出現概率低的則使用較長的編碼，這便使編碼之後的字元串的平均期望長度降低，從而達到無損壓縮數據的目的）。這種方法是由David.A.Huffman發展起來的。 例如，在英文中，e的出現概率很高，而z的出現概率則最低。當利用哈夫曼編碼對一篇英文進行壓縮時，e極有可能用一個位(bit)來表示，而z則可能花去25個位（不是26）。用普通的表示方法時，每個英文字母均佔用一個位元組（byte），即8個位。二者相比，e使用了一般編碼的1/8的長度，z則使用了3倍多。倘若我們能實現對於英文中各個字母出現概率的較准確的估算，就可以大幅度提高無損壓縮的比例。
本文描述在網上能夠找到的最簡單，最快速的哈夫曼編碼。本方法不使用任何擴展動態庫，比如STL或者組件。只使用簡單的C函數，比如：memset，memmove，qsort，malloc，realloc和memcpy。
因此，大家都會發現，理解甚至修改這個編碼都是很容易的。
背景
哈夫曼壓縮是個無損的壓縮演算法，一般用來壓縮文本和程序文件。哈夫曼壓縮屬於可變代碼長度演算法一族。意思是個體符號（例如，文本文件中的字元）用一個特定長度的位序列替代。因此，在文件中出現頻率高的符號，使用短的位序列，而那些很少出現的符號，則用較長的位序列。
編碼使用
我用簡單的C函數寫這個編碼是為了讓它在任何地方使用都會比較方便。你可以將他們放到類中，或者直接使用這個函數。並且我使用了簡單的格式，僅僅輸入輸出緩沖區，而不象其它文章中那樣，輸入輸出文件。
bool CompressHuffman(BYTE *pSrc, int nSrcLen, BYTE *&pDes, int &nDesLen);
bool DecompressHuffman(BYTE *pSrc, int nSrcLen, BYTE *&pDes, int &nDesLen);
要點說明
速度
為了讓它(huffman.cpp)快速運行，我花了很長時間。同時，我沒有使用任何動態庫，比如STL或者MFC。它壓縮1M數據少於100ms（P3處理器，主頻1G）。
壓縮
壓縮代碼非常簡單，首先用ASCII值初始化511個哈夫曼節點：
CHuffmanNode nodes[511];
for(int nCount = 0; nCount < 256; nCount++)
nodes[nCount].byAscii = nCount;
然後，計算在輸入緩沖區數據中，每個ASCII碼出現的頻率：
for(nCount = 0; nCount < nSrcLen; nCount++)
nodes[pSrc[nCount]].nFrequency++;
然後，根據頻率進行排序：
qsort(nodes, 256, sizeof(CHuffmanNode), frequencyCompare);
現在，構造哈夫曼樹，獲取每個ASCII碼對應的位序列：
int nNodeCount = GetHuffmanTree(nodes);
構造哈夫曼樹非常簡單，將所有的節點放到一個隊列中，用一個節點替換兩個頻率最低的節點，新節點的頻率就是這兩個節點的頻率之和。這樣，新節點就是兩個被替換節點的父節點了。如此循環，直到隊列中只剩一個節點（樹根）。
// parent node
pNode = &nodes[nParentNode++];
// pop first child
pNode->pLeft = PopNode(pNodes, nBackNode--, false);
// pop second child
pNode->pRight = PopNode(pNodes, nBackNode--, true);
// adjust parent of the two poped nodes
pNode->pLeft->pParent = pNode->pRight->pParent = pNode;
// adjust parent frequency
pNode->nFrequency = pNode->pLeft->nFrequency + pNode->pRight->nFrequency;
這里我用了一個好的訣竅來避免使用任何隊列組件。我先前就直到ASCII碼只有256個，但我分配了511個(CHuffmanNode nodes[511])，前255個記錄ASCII碼，而用後255個記錄哈夫曼樹中的父節點。並且在構造樹的時候只使用一個指針數組(ChuffmanNode *pNodes[256])來指向這些節點。同樣使用兩個變數來操作隊列索引(int nParentNode = nNodeCount;nBackNode = nNodeCount –1)。
接著，壓縮的最後一步是將每個ASCII編碼寫入輸出緩沖區中：
int nDesIndex = 0;
// loop to write codes
for(nCount = 0; nCount < nSrcLen; nCount++)
{
*(DWORD*)(pDesPtr+(nDesIndex>>3)) |=
nodes[pSrc[nCount]].dwCode << (nDesIndex&7);
nDesIndex += nodes[pSrc[nCount]].nCodeLength;
}
(nDesIndex>>3): >>3 以8位為界限右移後到達右邊位元組的前面
(nDesIndex&7): &7 得到最高位.
注意：在壓縮緩沖區中，我們必須保存哈夫曼樹的節點以及位序列，這樣我們才能在解壓縮時重新構造哈夫曼樹（只需保存ASCII值和對應的位序列）。
解壓縮
解壓縮比構造哈夫曼樹要簡單的多，將輸入緩沖區中的每個編碼用對應的ASCII碼逐個替換就可以了。只要記住，這里的輸入緩沖區是一個包含每個ASCII值的編碼的位流。因此，為了用ASCII值替換編碼，我們必須用位流搜索哈夫曼樹，直到發現一個葉節點，然後將它的ASCII值添加到輸出緩沖區中：
int nDesIndex = 0;
DWORD nCode;
while(nDesIndex < nDesLen)
{
nCode = (*(DWORD*)(pSrc+(nSrcIndex>>3)))>>(nSrcIndex&7);
pNode = pRoot;
while(pNode->pLeft)
{
pNode = (nCode&1) ? pNode->pRight : pNode->pLeft;
nCode >>= 1;
nSrcIndex++;
}
pDes[nDesIndex++] = pNode->byAscii;
}
❻ C語言實驗報告怎麼寫
#include <stdio.h>
int main()
{
unsigned long a;
char c;
printf("Input a binary number: ");
for(a=0;(c=getchar())!=' ';)
a=a*2+c-'0';
printf("The number is %lu in decimal ",a);
printf("The number is %lo in octal ",a);
printf("The number is %lX in Hexadecimal ",a);
return 0;
}
❼ c語言數據結構實驗 題目請看圖 感謝大佬們
#include<stdio.h>
#include<malloc.h>
#definemaxsize1024//線性表的最大長度
typedefstruct{//表的類型
intdata[maxsize];//表的儲存空間
intlast;
}sqlist,*sqlink;//說明標示符
voidCreateList(sqlinkL);//創空表
voidClearList(sqlinkL);//置空表
intGetList(sqlinkL,intno);//取表元素
intLengthList(sqlinkL);//求表長
intInsertList(sqlinkL,intdata,intno);//插入元素
intDeleteList(sqlinkL,intno);//刪除元素
intLocateList(sqlinkL,intdata);//定位元素
intEmptyList(sqlinkL);//判空表
voidPrintList(sqlinkL);//列印表元素
intmain(){
sqlinkL=(sqlink)malloc(sizeof(sqlist));
CreateList(L);
PrintList(L);
intdata,x;
printf("請輸入要插入的數據和位置：");
scanf("%d%d",&data,&x);
InsertList(L,data,x);
PrintList(L);
return0;
}
voidCreateList(sqlinkL){
inttempNo=1;
inttempData=0;
do{
printf("請輸入順序表第%d個元素：",tempNo);
scanf("%d",&tempData);
if(tempData!=-1){
L->data[tempNo-1]=tempData;
L->last=tempNo-1;
tempNo++;
}
}while(tempNo<=maxsize&&tempData!=-1);
}
voidPrintList(sqlinkL){
inti;
for(i=0;i<LengthList(L);i++){
printf("%d",L->data[i]);
}
printf(" ");
}
voidClearList(sqlinkL){
L->last=-1;
}
intGetList(sqlinkL,intno){
inttempData=0;
tempData=L->data[no-1];
returntempData;
}
intLengthList(sqlinkL){
inttempL;
tempL=L->last+1;
returntempL;
}
//插入元素
intInsertList(sqlinkL,intdata,intno){
intj;
if(L->last>=maxsize-1){
printf("沒有空閑空間！ ");
return0;
}elseif(no<0||no>L->last+1){
printf("插入位置不存在！ ");
return0;
}else{
for(j=L->last;j>=no-1;j--)
L->data[j+1]=L->data[j];
L->data[no-1]=data;
L->last++;
return0;
}
}
//刪除元素
intDeleteList(sqlinkL,intno){
intj;
if(no<0||no>L->last){
printf("刪除的元素不存在");
return0;
}else{
for(j=no;j+1<=L->last;j++)
L->data[j]=L->data[j+1];
L->last--;
return0;
}
}
//定位元素
intLocateList(sqlinkL,intdata){
inti=0;
while(i<=L->last&&L->data[i]!=data)
i++;
if(i<L->last)returni;
elsereturn0;
}