ddr2的上电顺序_关于内存的插入顺序的问题
展開全部
#ifndef FUNS_H
#define FUNS_H
void error( char *, ... ); /* 輸出錯誤信32313133353236313431303231363533e59b9ee7ad9431333234323734息，退出程序 */
void flush_stdin( void ); /* 清空“輸入緩沖區” */
#endif
#ifndef SQLIST_H
#define SQLIST_H
#define INITSIZE 100 /* 順序表初始空間分配量 */
#define INCREMENT 10 /* 順序表空間分配增量 */
typedef int ElemType; /* 聲明ElemType代表的數據類型 */
/* 定義順序表結構 */
typedef struct {
ElemType *elem; /* 存儲空間基址 */
unsigned length; /* 當前長度 */
unsigned listsize; /* 當前空間分配量 */
} Sqlist;
/* 函數聲明 */
int InitList(Sqlist *); /* 創建順序表 */
int InputList(Sqlist *); /* 輸入數據 */
int InsertList(Sqlist *, unsigned); /* 插入數據 */
void DelList(Sqlist *, unsigned, unsigned); /* 刪除數據 */
int Union(Sqlist *, Sqlist *); /* 求順序表并集 */
void Purge(Sqlist *); /* 刪除表中重復元素 */
void Purge2(Sqlist *); /* 刪除表中重復元素 */
void Bubble(Sqlist *, unsigned); /* 冒泡排序 */
int Compare(Sqlist *, Sqlist *); /* 比較兩個順序表的大小 */
void Exchange(Sqlist *, unsigned); /* 前N個元素和后M個元素互換 */
int Location(Sqlist *, ElemType); /* 求元素位置 */
void Disp(Sqlist *, unsigned); /* 顯示順序表信息 */
void Three(Sqlist *, unsigned, unsigned); /* 三次逆轉法 */
#endif /* end of sqlist.h */
#include
#include
#include
#include "../header/funs.h"
/* begin of error 05-8-15 18:40 */
void error( char *fmt, ... )
{ /* 輸出錯誤信息，退出程序 */
va_list args;
va_start( args, fmt );
fprintf( stderr, "error: " );
vfprintf( stderr, fmt, args );
fprintf( stderr, "\n" );
va_end( args );
exit( -1 );
} /* end of error */
/* begin of flush_stdin 05-8-31 19:30 */
void flush_stdin( void ) /* 清空“輸入緩沖區” */
{
int c;
if ( !feof(stdin) ) {
while( ( c=getchar() ) != '\n' && c != EOF )
;
}
} /* end of flush_stdin */
#include
#include
#include "../header/sqlist.h"
/* begin of InitList 05-8-13 0:30 */
int InitList( Sqlist *L ) /* 創建順序表 */
{
/* malloc 返回值為 void 類型，不需要顯式轉換 */
L->elem = malloc( INITSIZE * sizeof *L->elem ); /* 分配初始空間 */
if ( !L->elem ) {
return 0; /* 創建失敗返回 0 */
}
/* 創建成功，初始化字符串長度和順序表長度 */
L->length = 0;
L->listsize = INITSIZE;
return 1; /* 創建成功返回 1 */
} /* end of InitList */
/* begin of InputList 05-8-13 2:15 */
int InputList(Sqlist *L) /* 接受用戶輸入的字符串 */
{
unsigned i;
L->length = 0;
for ( i = 0; ( L->elem[i]=getchar() ) != '\n' && L->elem[i] != EOF ; ++i ) {
++L->length;
if ( L->length == L->listsize ) { /* 如果順序表已滿 */
ElemType *newbase = realloc( L->elem, /* 增加空間 */
( L->listsize + INCREMENT ) * sizeof *L->elem );
if ( newbase ) { /* 如果分配成功 */
L->elem = newbase; /* 將指針指向新分配好的空間 */
L->listsize += INCREMENT; /* 增大 listsize 的值 */
} else { /* 分配空間失敗 */
return 0; /* 增加空間失敗，返回 0 */
}
}
}
return 1;
} /* end of InputList */
/* begin of InsertList 05-8-13 5:00 */
int InsertList(Sqlist *L, unsigned pos) /* 插入數據 */
{
Sqlist tmp; /* 用于暫時存儲用戶輸入的字符 */
long i;
if ( !InitList( &tmp ) ) {
return 0;
}
if ( InputList( &tmp ) ) {
if ( !tmp.length ) {
free(tmp.elem);
return 1;
}
if ( L->listsize - L->length < tmp.length ) {
ElemType *newbase = realloc( L->elem,
( L->listsize + tmp.length ) * sizeof *L->elem );
if ( newbase ) {
L->elem = newbase;
L->listsize += tmp.length;
} else {
free(tmp.elem);
return 0;
}
}
--pos;
/* 移動字符 */
for ( i = L->length - 1; i >= (long)pos; --i ) {
L->elem[i + tmp.length] = L->elem[i];
}
i = 0;
while ( i < (long)tmp.length ) {
L->elem[pos++] = tmp.elem[i++];
}
L->length += tmp.length; /* 更新字符串長度 */
free(tmp.elem);
return 1;
}
free(tmp.elem);
return 0;
} /* end of InsertList */
/* begin of DelList 05-8-13 12:00 */
void DelList(Sqlist *L, unsigned pos, unsigned size)
{
for ( --pos; pos + size < L->length; ++pos ) {
L->elem[pos] = L->elem[pos + size];
}
L->length -= size;
} /* end of DelList */
/* begin of Union 05-8-13 12:30 */
int Union(Sqlist *L1, Sqlist *L2){ /* 求順序表并集 */
unsigned k;
/* 開始進行并集操作 */
if ( L1 == L2 ) { /* 如果 L1 和 L2 為同一順序表 */
return 1;
}
for ( k = 0; k < L2->length; ++k ) {
/* 在順序表 L1 中找不到順序表 L2 中的第k+1個元素，將第k+1個元素插入順序表 L1 */
if ( !Location( L1, L2->elem[k]) ) {
if ( L1->length == L1->listsize ) { /* 如果順序表已滿 */
ElemType *newbase = realloc( L1->elem, /* 增加空間 */
( L1->listsize + INCREMENT ) * sizeof *L1->elem );
if ( newbase ) {
L1->elem = newbase;
L1->listsize += INCREMENT;
} else {
return 0; /* 增加空間失敗，返回 */
}
}
L1->elem[ L1->length ] = L2->elem[k]; /* 插入到表 L1 */
L1->length++; /* 表 L1 長度增加 */
}
}
return 1; /* 無誤返回 */
} /* end of Union */
/* begin of Purge 05-8-13 13:00 */
void Purge(Sqlist *L) /* 刪除表中重復元素 */
{
unsigned i, j, k;
for ( i = 0; i < L->length; i++ ) {
for ( j = i+1; j < L->length; ) {
if ( L->elem[i] == L->elem[j] ) { /* 若找到重復元素 */
for ( k = j; k < L->length; k++ ) { /* 刪除重復元素 */
L->elem[k] = L->elem[k+1];
}
L->length--; /* 順序表長度減1 */
}
else {
j++;
}
}
}
} /* end of Purge */
/* begin of Purge2 05-8-13 13:20 */
void Purge2(Sqlist *L) /* 刪除表中重復元素 */
{
Sqlist T = *L;
unsigned i;
T.length = 1;
for ( i = 1; i < L->length; i++ ) {
if ( !Location( &T, L->elem[i] ) ) { /* 若找不到重復元素 */
T.elem[T.length] = L->elem[i]; /* 插入 */
T.length++; /* 更新長度 */
}
}
L->length = T.length; /* 更新長度 */
} /* end of Purge2 */
/* begin of Bubble 05-8-13 14:10 */
void Bubble(Sqlist *L, unsigned ascend)
{
ElemType temp;
unsigned i, j, k = L->length - 1;
unsigned l;
if ( !L->length ) {
return;
}
for ( l = 1; l; k-- ) {
l = 0;
for ( i = 0, j = 1; i < k; i++, j++ ) {
/* 根據 ascend 的值進行升序或者降序排列 */
if ( ( L->elem[i] < L->elem[j] ) ^ ascend ) {
temp = L->elem[i];
L->elem[i] = L->elem[j];
L->elem[j] = temp;
l = 1;
}
}
}
} /* end of Bubble */
/* begin of Compare 05-8-13 14:40 */
int Compare(Sqlist *L1, Sqlist *L2) /* 比較兩個順序表 */
{
unsigned k;
if ( L1 == L2 ) {
return 0;
}
for ( k = 0; k < L1->length && k < L2->length; k++ ) {
if ( L1->elem[k] > L2->elem[k] ) {
return 1;
}
if ( L1->elem[k] < L2->elem[k] ) {
return -1;
}
}
return L1->length - L2->length;
} /* end of Compare */
/* begin of Exchange 05-8-13 15:10 */
void Exchange(Sqlist *L, unsigned i) /* 前N個元素和后M個元素互換 */
{
/* 三次逆轉 */
Three( L, 0, i-1 );
Three( L, i, L->length-1 );
Three( L, 0, L->length-1 );
} /* end of Exchange */
/* begin of Three 05-8-13 14:55 */
void Three(Sqlist *L, unsigned i, unsigned j) /* 三次逆轉法 */
{
ElemType temp;
for (; i < j; i++, j-- ) {
temp = L->elem[i];
L->elem[i] = L->elem[j];
L->elem[j] = temp;
}
} /* end of Three */
/* begin of Location 05-8-13 12:10 */
int Location(Sqlist *L, ElemType elem) /* 求元素位置 */
{
unsigned l;
for ( l=0; l < L->length && L->elem[l] != elem; l++ ) {
;
}
if ( l == L->length ) { /* 在順序表中找不到elem */
return 0; /* 返回0 */
}
return ++l; /* 找到則返回元素位置 */
} /* end of Location */
/* begin of Disp 05-8-13 15:20 */
void Disp( Sqlist *L, unsigned total_lists ) /* 顯示順序表信息 */
{
unsigned short i;
unsigned j;
printf( "\n當前一共有 %u 個順序表。每個表的數據如下：\n", total_lists );
for ( i = 0; i < total_lists; i++ ) {
printf( "\n順序表 %d ：", i+1 );
for ( j = 0; j < L[i].length; j++ ) {
printf( "%c", L[i].elem[j] );
}
printf( "\n字符串長度：%u 順序表長度：%u\n", L[i].length, L[i].listsize);
}
} /* end of Disp */
#include
#include
#include "header/sqlist.h"
#include "header/funs.h"
#define MAX_LISTS 10 /* 最多可以建立的順序表個數 */
/* 函數聲明 */
char Menu( void ); /* 打印菜單，請用戶選擇 */
unsigned Choose( unsigned, unsigned, char ); /* 接收用戶輸入的選擇 */
static int tmp; /* tmp 用于清空輸入緩沖區 */
const char *msg[] = { "\n請問您要對哪個順序表(%u — %u)進行操作：",
"\n請輸入刪除數目(%u — %u)：",
"\n請輸入字符串(原有數據會被覆蓋)：",
"\n請輸入插入位置(%u — %u)：",
"\n請輸入刪除位置(%u — %u)：",
"\n此項操作至少要有兩個順序表才能進行。請再建立一個順序表。",
"\n重復元素已被刪除。",
"\n請問您要進行降序排序還是升序排序(%u 代表降序，%u 代表升序)：",
"\n順序表 %u %c 順序表 %u",
"\n請輸如互換點(%u — %u)：",
"\n排序完成。" };
int main( void )
{
Sqlist L[ MAX_LISTS ]; /* 順序表數組 */
char choice; /* 記錄用戶選擇的操作 */
unsigned short total_lists = 0; /* 用于記錄目前一共有多少個順序表 */
char *init_msg[] = { "內存不足！創建失敗。", /* 創建順序表的提示信息 */
"順序表創建成功！您可以開始對順序表進行操作了。" };
printf( "\n請先創建一個順序表。最多可以創建 %u 個順序表。\n", MAX_LISTS );
while ( choice = Menu() ) { /* 根據用戶輸入選擇函數運行 */
if ( !total_lists && choice != 1 ) {
printf( "\n請先創建一個順序表。最多可以創建 %u 個順序表。\n", MAX_LISTS );
} else {
switch ( choice ) {
case 1 :
if ( total_lists == MAX_LISTS ) { /* 達到最大限制 */
printf( "\n最多只能建立 %u 個順序表。\n", MAX_LISTS );
} else {
int i = InitList( &L[total_lists] );
total_lists += i; /* 更新順序表數目 */
printf( "\n%s\n", init_msg[i] );
}
break;
case 2 :
{
unsigned num = Choose( total_lists, 1, 0 );
printf( "%s", msg[choice] );
InputList(&L[num-1]);
break;
}
case 3 :
{
unsigned num, pos;
num = Choose( total_lists, 1, 0 );
pos = Choose( L[num-1].length + 1, 1, choice );
printf( "\n請輸入字符串：" );
/* 在第 num 個順序表的第 pos 個元素處開始插入 */
InsertList( &L[num-1], pos );
break;
}
case 4 :
{
unsigned num, pos, size;
num = Choose( total_lists, 1, 0 );
if ( !L[num-1].length ) {
printf( "\n順序表為空，不能進行刪除操作。\n" );
break;
}
pos = Choose( L[num-1].length, 1, choice );
size = Choose( L[num-1].length - pos + 1, 1, 1 );
/* 從第 num 個順序表的第 pos 個位置開始，刪除 size 個元素 */
DelList( &L[num-1], pos, size );
break;
}
case 5 :
{
unsigned num1, num2;
if ( total_lists < 2 ) {
puts( msg[choice] );
break;
}
num1 = Choose( total_lists, 1, 0 );
num2 = Choose( total_lists, 1, 0 );
if ( Union( &L[num1-1], &L[num2-1] ) ) {
printf( "\n并集操作完成。操作結果保存于順序表 %u 。\n", num1 );
} else {
printf( "\n并集操作失敗。\n" );
}
break;
}
case 6 :
{
unsigned num = Choose( total_lists, 1, 0 );
Purge( &L[num-1] );
puts( msg[choice] );
break;
}
case 7 :
{
unsigned num = Choose( total_lists, 1, 0 );
unsigned ascend = Choose( 1, 0, choice );
Bubble( &L[num - 1], ascend );
puts( msg[10] );
break;
}
case 8 :
{
unsigned num1, num2;
int flag;
if ( total_lists < 2 ) {
puts( msg[5] );
break;
}
num1 = Choose( total_lists, 1, 0 );
num2 = Choose( total_lists, 1, 0 );
flag = Compare( &L[num1-1], &L[num2-1] );
if ( !flag ) {
flag = '=';
} else if ( flag > 0 ) {
flag = '>';
} else {
flag = '
}
printf( msg[choice], num1, flag, num2 );
break;
}
case 9 :
{
unsigned num = Choose( total_lists, 1, 0 ), point;
if ( L[num-1].length < 2 ) {
puts("\n元素太少，不能進行互換。");
break;
}
point = Choose( L[num-1].length - 1, 1, choice );
Exchange( &L[num-1], point );
puts( "\n互換完成。" );
break;
}
case 10 :
{
unsigned num = Choose( total_lists, 1, 0 );
Purge2( &L[num-1] );
puts( msg[6] );
break;
}
break;
default:
break;
}
}
/* 打印順序表的內容 */
Disp( L, total_lists );
}
while ( total_lists ) {
free( L[ --total_lists ].elem ); /* 釋放內存 */
}
puts( "\n感謝您使用我們的產品！請按回車退出..." );
getchar();
return 0; /* 退出程序 */
} /* end of main */
/* begin of Choose 05-8-13 3:00 */
unsigned Choose( unsigned up, unsigned low, char c )
{
unsigned num = 0;
do {
printf( msg[c], low, up );
scanf( "%u", &num );
flush_stdin(); /* 清空輸入緩沖區 */
} while ( num > up || num < low );
return num;
} /* end of Choose */
/* begin of Menu 05-8-12 23:20 */
char Menu( void ) /* 打印菜單，并且接受用戶輸入 */
{
int ch = -1; /* ch 用于接收用戶輸入 */
for (;;) {
printf( "\n********************************\n"
"* 1. 創建順序表 *\n"
"* 2. 輸入數據 *\n"
"* 3. 插入數據 *\n"
"* 4. 刪除數據 *\n"
"* 5. 求順序表并集 *\n"
"* 6. 刪除重復元素 *\n"
"* 7. 冒泡排序 *\n"
"* 8. 比較順序表大小 *\n"
"* 9. 前N個元素和后M個元素互換 *\n"
"*10. 刪除重復元素(2) *\n"
"* 0. 退出 *\n"
"********************************\n\n"
"請輸入您要執行的操作(按回車確定)：");
scanf( "%d", &ch );
flush_stdin(); /* 清空輸入緩沖區 */
if ( ch < 11 && ch > -1 ) {
break; /* 輸入合法，退出循環 */
}
/* 非法輸入，請用戶重新輸入 */
puts("\n請輸入 0 到 10 之間的數字。\n");
} /* end of for */
return ch; /* 返回操作號 */
} /* end of Menu */
已贊過
已踩過<
你對這個回答的評價是？
評論
收起
總結
以上是生活随笔為你收集整理的ddr2的上电顺序_关于内存的插入顺序的问题的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： messageformat.format
- 下一篇： python顺序结构实验_Python程