java操作位
① java:二進制的按位與操作怎麼做求助大神！
//先用鏈接中的方法，把Stringa,b分別轉換成byte[]數組data_a和data_b
byte[]data_a=hex2byte(a);
byte[]data_b=hex2byte(b);
byte[]data_c=newbyte[a.length];//結果串
//逐個直接進行位與運算()
for(inti=0;i<a.Length;i++){
data_c[i]=data_a[i]&data_b[i];
}
//此時data_c中就是按位與結果，再轉換成字元串
Stringc=byte2hex(data_c);
//c便是結果字元串。
② java中的位運算符及其用法。
位邏輯運算符有「與」（AND）、「或」（OR）、「異或（XOR）」、「非（NOT）」，分別用「&」、「|」、「^」、「~」表示。
下面的例子說明了位邏輯運算符：
// Demonstrate the bitwise logical operators.
class BitLogic {
public static void main(String args[]) {
String binary[] = {
"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",
"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"
};
int a = 3; // 0 + 2 + 1 or 0011 in binary
int b = 6; // 4 + 2 + 0 or 0110 in binary
int c = a | b;
int d = a & b;
int e = a ^ b;
int f = (~a & b) | (a & ~b);
int g = ~a & 0x0f;
System.out.println(" a = " + binary[a]);
System.out.println(" b = " + binary[b]);
System.out.println(" a|b = " + binary[c]);
System.out.println(" a&b = " + binary[d]);
System.out.println(" a^b = " + binary[e]);
System.out.println("~a&b|a&~b = " + binary[f]);
System.out.println(" ~a = " + binary[g]);
}
}
在本例中，變數a與b對應位的組合代表了二進制數所有的 4 種組合模式：0-0，0-1，1-0，和1-1。「|」運算符和「&」運算符分別對變數a與b各個對應位的運算得到了變數c和變數d的值。對變數e和f的賦值說明了「^」運算符的功能。字元串數組binary代表了0到15對應的二進制的值。在本例中，數組各元素的排列順序顯示了變數對應值的二進制代碼。數組之所以這樣構造是因為變數的值n對應的二進制代碼可以被正確的存儲在數組對應元素binary[n]中。例如變數a的值為3，則它的二進制代碼對應地存儲在數組元素binary[3]中。~a的值與數字0x0f （對應二進制為0000 1111）進行按位與運算的目的是減小~a的值，保證變數g的結果小於16。因此該程序的運行結果可以用數組binary對應的元素來表示。該程序的輸出如下：
a = 0011
b = 0110
a|b = 0111
a&b = 0010
a^b = 0101
~a&b|a&~b = 0101
~a = 1100
左移運算符
左移運算符<<使指定值的所有位都左移規定的次數。它的通用格式如下所示：
value << num
這里，num指定要移位值value移動的位數。也就是，左移運算符<<使指定值的所有位都左移num位。每左移一個位，高階位都被移出（並且丟棄），並用0填充右邊。這意味著當左移的運算數是int類型時，每移動1位它的第31位就要被移出並且丟棄；當左移的運算數是long類型時，每移動1位它的第63位就要被移出並且丟棄。
在對byte和short類型的值進行移位運算時，你必須小心。因為你知道Java在對表達式求值時，將自動把這些類型擴大為 int型，而且，表達式的值也是int型 。對byte和short類型的值進行移位運算的結果是int型，而且如果左移不超過31位，原來對應各位的值也不會丟棄。但是，如果你對一個負的byte或者short類型的值進行移位運算，它被擴大為int型後，它的符號也被擴展。這樣，整數值結果的高位就會被1填充。因此，為了得到正確的結果，你就要舍棄得到結果的高位。這樣做的最簡單辦法是將結果轉換為byte型。下面的程序說明了這一點：
// Left shifting a byte value.
class ByteShift {
public static void main(String args[]) {
byte a = 64, b;
int i;
i = a << 2;
b = (byte) (a << 2);
System.out.println("Original value of a: " + a);
System.out.println("i and b: " + i + " " + b);
}
}
該程序產生的輸出下所示：
Original value of a: 64
i and b: 256 0
因變數a在賦值表達式中，故被擴大為int型，64（0100 0000）被左移兩次生成值256（10000 0000）被賦給變數i。然而，經過左移後，變數b中惟一的1被移出，低位全部成了0，因此b的值也變成了0。
既然每次左移都可以使原來的操作數翻倍，程序員們經常使用這個辦法來進行快速的2的乘法。但是你要小心，如果你將1移進高階位（31或63位），那麼該值將變為負值。下面的程序說明了這一點：
// Left shifting as a quick way to multiply by 2.
class MultByTwo {
public static void main(String args[]) {
int i;
int num = 0xFFFFFFE;
for(i=0; i<4; i++) {
num = num << 1;
System.out.println(num);
}
}
}
該程序的輸出如下所示：
536870908
1073741816
2147483632
-32
初值經過仔細選擇，以便在左移 4 位後，它會產生-32。正如你看到的，當1被移進31位時，數字被解釋為負值。
右移運算符
右移運算符>>使指定值的所有位都右移規定的次數。它的通用格式如下所示：
value >> num
這里，num指定要移位值value移動的位數。也就是，右移運算符>>使指定值的所有位都右移num位。
下面的程序片段將值32右移2次，將結果8賦給變數a:
int a = 32;
a = a >> 2; // a now contains 8
當值中的某些位被「移出」時，這些位的值將丟棄。例如，下面的程序片段將35右移2次，它的2個低位被移出丟棄，也將結果8賦給變數a:
int a = 35;
a = a >> 2; // a still contains 8
用二進製表示該過程可以更清楚地看到程序的運行過程：
00100011 35
>> 2
00001000 8
將值每右移一次，就相當於將該值除以2並且舍棄了余數。你可以利用這個特點將一個整數進行快速的2的除法。當然，你一定要確保你不會將該數原有的任何一位移出。
右移時，被移走的最高位（最左邊的位）由原來最高位的數字補充。例如，如果要移走的值為負數，每一次右移都在左邊補1，如果要移走的值為正數，每一次右移都在左邊補0，這叫做符號位擴展（保留符號位）（sign extension），在進行右移操作時用來保持負數的符號。例如，–8 >> 1 是–4，用二進製表示如下：
11111000 –8
>>1
11111100 –4
一個要注意的有趣問題是，由於符號位擴展（保留符號位）每次都會在高位補1，因此-1右移的結果總是–1。有時你不希望在右移時保留符號。例如，下面的例子將一個byte型的值轉換為用十六進製表示。注意右移後的值與0x0f進行按位與運算，這樣可以舍棄任何的符號位擴展，以便得到的值可以作為定義數組的下標，從而得到對應數組元素代表的十六進制字元。
// Masking sign extension.
class HexByte {
static public void main(String args[]) {
char hex[] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f''
};
byte b = (byte) 0xf1;
System.out.println("b = 0x" + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);
}
}
該程序的輸出如下：
b = 0xf1
無符號右移
正如上面剛剛看到的，每一次右移，>>運算符總是自動地用它的先前最高位的內容補它的最高位。這樣做保留了原值的符號。但有時這並不是我們想要的。例如，如果你進行移位操作的運算數不是數字值，你就不希望進行符號位擴展（保留符號位）。當你處理像素值或圖形時，這種情況是相當普遍的。在這種情況下，不管運算數的初值是什麼，你希望移位後總是在高位（最左邊）補0。這就是人們所說的無符號移動（unsigned shift）。這時你可以使用Java的無符號右移運算符>>>，它總是在左邊補0。下面的程序段說明了無符號右移運算符>>>。在本例中，變數a被賦值為-1，用二進製表示就是32位全是1。這個值然後被無符號右移24位，當然它忽略了符號位擴展，在它的左邊總是補0。這樣得到的值255被賦給變數a。
int a = -1;
a = a >>> 24;
下面用二進制形式進一步說明該操作：
11111111 11111111 11111111 11111111 int型- 1的二進制代碼
>>> 24 無符號右移24位
00000000 00000000 00000000 11111111 int型255的二進制代碼由於無符號右移運算符>>>只是對32位和64位的值有意義，所以它並不像你想像的那樣有用。因為你要記住，在表達式中過小的值總是被自動擴大為int型。這意味著符號位擴展和移動總是發生在32位而不是8位或16位。這樣，對第7位以0開始的byte型的值進行無符號移動是不可能的，因為在實際移動運算時，是對擴大後的32位值進行操作。下面的例子說明了這一點：
// Unsigned shifting a byte value.
class ByteUShift {
static public void main(String args[]) {
char hex[] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
};
byte b = (byte) 0xf1;
byte c = (byte) (b >> 4);
byte d = (byte) (b >>> 4);
byte e = (byte) ((b & 0xff) >> 4);
System.out.println(" b = 0x"
+ hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);
System.out.println(" b >> 4 = 0x"
+ hex[(c >> 4) & 0x0f] + hex[c & 0x0f]);
System.out.println(" b >>> 4 = 0x"
+ hex[(d >> 4) & 0x0f] + hex[d & 0x0f]);
System.out.println("( b & 0xff) >> 4 = 0x"
+ hex[(e >> 4) & 0x0f] + hex[e & 0x0f]);
}
}
該程序的輸出顯示了無符號右移運算符>>>對byte型值處理時，實際上不是對byte型值直接操作，而是將其擴大到int型後再處理。在本例中變數b被賦為任意的負byte型值。對變數b右移4位後轉換為byte型，將得到的值賦給變數c，因為有符號位擴展，所以該值為0xff。對變數b進行無符號右移4位操作後轉換為byte型，將得到的值賦給變數d，你可能期望該值是0x0f，但實際上它是0xff，因為在移動之前變數b就被擴展為int型，已經有符號擴展位。最後一個表達式將變數b的值通過按位與運算將其變為8位，然後右移4位，然後將得到的值賦給變數e，這次得到了預想的結果0x0f。由於對變數d（它的值已經是0xff）進行按位與運算後的符號位的狀態已經明了，所以注意，對變數d再沒有進行無符號右移運算。
B = 0xf1
b >> 4 = 0xff
b >>> 4 = 0xff
(b & 0xff) >> 4 = 0x0f
位運算符賦值
所有的二進制位運算符都有一種將賦值與位運算組合在一起的簡寫形式。例如，下面兩個語句都是將變數a右移4位後賦給a：
a = a >> 4;
a >>= 4;
同樣，下面兩個語句都是將表達式a OR b運算後的結果賦給a：
a = a | b;
a |= b;
下面的程序定義了幾個int型變數，然後運用位賦值簡寫的形式將運算後的值賦給相應的變數：
class OpBitEquals {
public static void main(String args[]) {
int a = 1;
int b = 2;
int c = 3;
a |= 4;
b >>= 1;
c <<= 1;
a ^= c;
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
}
}
該程序的輸出如下所示：
a = 3
b = 1
c = 6
③ java里怎麼對Byte進行位操作
//byte buf[]=為數組 for(byte b:buf){ System.out.print(b&15);//列印每個節的低四位 System.out.println(b>>>4);//列印每個節的高四位 }
④ java，位操作區別
>>是無符號數的右移
>>>是有符號的右移
這個符號只得是+ -號
如果你用 >>和-1 這樣的負數去移位的話的出的結果就會完全出錯
⑤ JAVA位運算符。。
~ 按位非（NOT） b = ~a
& 按位與（AND） c = a & b
| 按位或（OR） c = a | b
^ 按位異或（XOR） c = a ^ b
>> 右移 b = a >> 2
>>> 右移，左邊空出的位以0填充 b = a >>> 2
<< 左移 b = a << 1
當然同樣有 &=，|=，^=，>>=，>>>=，<<=。
有關這些操作的細節可以參看
http://www.pcvc.net/category/content.asp?sendid=247
位運算
前面介紹的各種運算都是以位元組作為最基本位進行的。 但在很多系統程序中常要求在位(bit)一級進行運算或處理。C語言提供了位運算的功能， 這使得C語言也能像匯編語言一樣用來編寫系統程序。
一、位運算符C語言提供了六種位運算符：
& 按位與
| 按位或
^ 按位異或
~ 取反
<< 左移
>> 右移
1. 按位與運算 按位與運算符"&"是雙目運算符。其功能是參與運算的兩數各對應的二進位相與。只有對應的兩個二進位均為1時，結果位才為1 ，否則為0。參與運算的數以補碼方式出現。
例如：9&5可寫算式如下： 00001001 (9的二進制補碼)&00000101 (5的二進制補碼) 00000001 (1的二進制補碼)可見9&5=1。
按位與運算通常用來對某些位清0或保留某些位。例如把a 的高八位清 0 ， 保留低八位， 可作 a&255 運算 ( 255 的二進制數為0000000011111111)。
main(){
int a=9,b=5,c;
c=a&b;
printf("a=%d\nb=%d\nc=%d\n",a,b,c);
}
2. 按位或運算 按位或運算符「|」是雙目運算符。其功能是參與運算的兩數各對應的二進位相或。只要對應的二個二進位有一個為1時，結果位就為1。參與運算的兩個數均以補碼出現。
例如：9|5可寫算式如下： 00001001|00000101
00001101 (十進制為13)可見9|5=13
main(){
int a=9,b=5,c;
c=a|b;
printf("a=%d\nb=%d\nc=%d\n",a,b,c);
}
3. 按位異或運算 按位異或運算符「^」是雙目運算符。其功能是參與運算的兩數各對應的二進位相異或，當兩對應的二進位相異時，結果為1。參與運算數仍以補碼出現，例如 9^5可寫成算式如下： 00001001^00000101 00001100 (十進制為12)
main(){
int a=9;
a=a^15;
printf("a=%d\n",a);
}
4. 求反運算 求反運算符～為單目運算符，具有右結合性。 其功能是對參與運算的數的各二進位按位求反。例如～9的運算為： ~(0000000000001001)結果為：1111111111110110
5. 左移運算 左移運算符「<<」是雙目運算符。其功能把「<< 」左邊的運算數的各二進位全部左移若干位，由「<<」右邊的數指定移動的位數，
高位丟棄，低位補0。例如： a<<4 指把a的各二進位向左移動4位。如a=00000011(十進制3)，左移4位後為00110000(十進制48)。6. 右移運算 右移運算符「>>」是雙目運算符。其功能是把「>> 」左邊的運算數的各二進位全部右移若干位，「>>」右邊的數指定移動的位數。
例如：設 a=15，a>>2 表示把000001111右移為00000011(十進制3)。 應該說明的是，對於有符號數，在右移時，符號位將隨同移動。當為正數時， 最高位補0，而為負數時，符號位為1，最高位是補0或是補1 取決於編譯系統的規定。Turbo C和很多系統規定為補1。
⑥ java中按位與和按位或的問題
按位與 &
按位或 |
轉為二進制操作即可
&: 兩位同時為「1」，結果才為「1」，否則為0
|: 參加運算的兩個對象只要有一個為1，其值為1。
按位與：
5: 0000 0101
9: 0000 1001
1: 0000 0001
按位或：
5: 0000 0101
9: 0000 1001
13: 0000 1101
⑦ JAVA中字元的位操作
這個地址也由參考的 可以去下了看看 http://download.csdn.net/source/1282762
這是C的 僅供參考
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define MAX_SINGLECODE_LEN 10 //單個字元最大碼長
#define MAX_STRING_LEN 1000 //要編碼的字元串的最大長度
#define MAX_CODESTRING_LEN 10000 //產生的二進制碼的最大長度
#define MAX_WORDS 1000 //要編碼的字元串中字元種數最大值
#define END_TREE 30000 //樹部分存儲的結束符
#define PATH_LEN 50 //路徑串最大長度
/*****哈夫曼樹結構定義*****/
typedef struct Huffmantree
{
char ch; //字元部分
int weight; //結點權值
int mark; //標記是否加入樹中
struct Huffmantree *parent,*lchild,*rchild,*next;
}HTNode,*LinkTree;
/*****編碼字典結構定義*****/
typedef struct
{
char ch; //字元部分
char code[MAX_SINGLECODE_LEN]; //編碼部分
}CodeDictionary;
/*********函數聲明*********/
LinkTree setWeight(char *);
LinkTree sortNode(LinkTree);
LinkTree createHTree(LinkTree);
void codeHTree(LinkTree,CodeDictionary *);
void decodeHTree(LinkTree,char *,char *);
void deleteNode(LinkTree);
void compressString(char *s,CodeDictionary *,char *);
void readFile(char *);
void writeFile(char *);
void readCode(LinkTree,char *);
void writeCode(LinkTree,char *);
void menu();
/**
*主函數
*輸入：空
*返回：空
*/
void main(void)
{
char choice; //菜單選擇變數
char string[MAX_STRING_LEN]; //保存從文件中讀取的內容
LinkTree temp; //保存賦了權值的表
LinkTree ht; //保存排序後的表
LinkTree ht,temp; //表備份
LinkTree htree; //保存哈夫曼樹
LinkTree ptr=NULL;
CodeDictionary codedictionary[MAX_WORDS];//編碼字典
char codestring[MAX_CODESTRING_LEN]; //保存0-1形的代碼串
char codestring2[MAX_CODESTRING_LEN];//保存0-1形的代碼串
LinkTree ht2; //保存讀取的樹
LinkTree htree2; //保存排序後的表
char filestring[MAX_STRING_LEN]; //解碼後要寫入文件中的內容
if((ht2=(LinkTree)malloc(sizeof(HTNode)))==NULL)//創建鏈表的頭結點
{
printf("內存不足！");
getch();
exit(0);
}
ht2->next=NULL;
while(1)
{
menu(); //調入主菜單
choice=getch(); //讀入用戶選項
switch(choice) //判斷用戶選擇
{
case 'c':
case 'C':
printf("\n您選擇了壓縮文件模式:\n\n");
readFile(string); //讀取要編碼的文件（字元串）
temp=setWeight(string); //得到有權值的表
temp=setWeight(string);
ht=sortNode(temp); //按權值排序後的表
ht=sortNode(temp); //用於記錄解碼樹
htree=createHTree(ht); //得到哈夫曼樹
codeHTree(htree,codedictionary);//哈夫曼編碼
compressString(string,codedictionary,codestring);//壓縮為0-1碼
writeCode(ht,codestring); //將解碼樹和0-1碼保存
deleteNode(htree); //釋放空間*/
break;
case 'u':
case 'U':
printf("您選擇了解壓縮文件模式:\n\n");
readCode(ht2,codestring2); //讀取要解碼的0-1碼
htree2=createHTree(ht2); //得到哈夫曼樹
codeHTree(htree2,codedictionary);//哈夫曼編碼
decodeHTree(htree2,codestring2,filestring); //解碼
writeFile(filestring); //將解碼文件保存
deleteNode(htree2); //釋放空間
break;
case 'e':
case 'E':
exit(0); //退出程序
}
}
}/**
*整理輸入的字元串，求出每個字元在數組中出現的次數，作為權值
*輸入：（字元型指針）字元串的地址
*返回：（哈夫曼結點指針）含權鏈表的首地址
*/
LinkTree setWeight(char *string)
{
int i=0; //文件字元串下標
LinkTree tree; //頭指針
LinkTree ptr,beforeptr; //創建指針與其前驅
HTNode *node;
if((tree=(LinkTree)malloc(sizeof(HTNode)))==NULL)//創建鏈表的頭結點
return NULL;
tree->next=NULL;
for(i=0;string[i]!='\0';i++)
{
ptr=tree;
beforeptr=tree;
if((node=(HTNode *)malloc(sizeof(HTNode)))==NULL)
return NULL;
node->next=NULL;
node->parent=NULL;
node->lchild=NULL;
node->rchild=NULL;
node->mark=0;
node->ch=string[i];
node->weight=1;
if(tree->next==NULL) //如果是第一個非頭結點
tree->next=node;
else
{
ptr=tree->next;
while(ptr&&ptr->ch!=node->ch) //查找相同字元
{
ptr=ptr->next;
beforeptr=beforeptr->next;
}
if(ptr&&ptr->ch==node->ch) //如果鏈表中某結點的字元與新結點的字元相同
{
ptr->weight++; //將該結點的權加一
free(node);
}
else //將新結點插入鏈表後
{
node->next=beforeptr->next;
beforeptr->next=node;
}
}
}
return tree; //返回頭指針
}
/**
*將整理完的字元串（帶權鏈表）按出現次數從小到大的順序排列
*輸入：（哈夫曼結點指針）要排序的表頭地址
*返回：（哈夫曼結點指針）排序後的表頭地址
*/
LinkTree sortNode(LinkTree tree)
{
LinkTree head; //頭指針
LinkTree ph,beforeph; //創建指針及其前驅
LinkTree pt;
if((head=(LinkTree)malloc(sizeof(HTNode)))==NULL)//創建新鏈表的頭結點
return NULL;
head->next=NULL;
ph=head;
beforeph=head;
while(tree->next)
{
pt=tree->next; //取被*作鏈表的頭結點
tree->next=pt->next;
pt->next=NULL;
ph=head->next;
beforeph=head;
if(head->next==NULL)
head->next=pt; //創建當前*作鏈表頭結點
else
{
while(ph&&ph->weight<pt->weight) //將被*作結點插入相應位置
{
ph=ph->next;
beforeph=beforeph->next;
}
pt->next=beforeph->next;
beforeph->next=pt;
}
}
free(tree);
return head; //返回排序後的頭指針
}
/**
*用排完序的字元串建立哈夫曼樹
*輸入：（哈夫曼結點指針）要建立哈夫曼樹的地址
*返回：（哈夫曼結點指針）建立後的哈夫曼樹地址
*/
LinkTree createHTree(LinkTree tree)
{
LinkTree p,q,beforep;
HTNode *newnode;
for(p=tree->next,q=p->next;p!=NULL&&q!=NULL;p=tree->next,q=p->next)
//p、q初值為頭結點後的兩個結點，即最小權結點
{
tree->next=q->next;
q->next=NULL;
p->next=NULL;
if((newnode=(HTNode *)malloc(sizeof(HTNode)))==NULL)
//申請新結點作為哈夫曼樹的中間結點
return NULL;
newnode->next=NULL;
newnode->mark=0;
newnode->lchild=p; //取鏈表頭結點後的兩個結點作為新結點的左、右孩子
newnode->rchild=q;
p->parent=newnode;
q->parent=newnode;
newnode->weight=p->weight+q->weight; //權值相加
p=tree->next;
beforep=tree;
if(p!=NULL&&p->weight>=newnode->weight)
{
newnode->next=beforep->next; //將新結點插入原鏈表的相應位置
beforep->next=newnode;
}
else
{
while(p!=NULL&&p->weight<newnode->weight)
{
p=p->next;
beforep=beforep->next;
}
newnode->next=beforep->next;
beforep->next=newnode;
}
}
return (tree->next);
}
/**
*對哈夫曼樹進行編碼
*輸入：（哈夫曼結點指針）要編碼的哈夫曼樹地址
* （編碼字典類型指針）存放字典的首地址
*返回：空
*/
void codeHTree(LinkTree tree,CodeDictionary *codedictionary)
{
int index=0,k=0;
char code[MAX_SINGLECODE_LEN]; //用於統計每個字元的哈夫曼編碼
LinkTree ptr=tree; //從樹的根結點開始
if(ptr==NULL)
{
printf("要壓縮的文件是空的!\n");
exit(0);
}
else
{
while(ptr->lchild&&ptr->rchild&&ptr->mark==0)
{
while(ptr->lchild&&ptr->lchild->mark==0)
{
code[index++]='0'; //左支路編碼為0
ptr=ptr->lchild;
if(!ptr->lchild&&!ptr->rchild) //如果沒有左右孩子，即葉子結點
{
ptr->mark=1; //作標記，表明該字元已被編碼
code[index]='\0'; //編碼0-1字元串結束
codedictionary[k].ch=ptr->ch;//給字典賦字元值
for(index=0;code[index]!='\0';index++)
codedictionary[k].code[index]=code[index];//給字典賦碼值
codedictionary[k].code[index]='\0';
k++;
ptr=tree; //指針復位
index=0;
}
}
if(ptr->rchild&&ptr->rchild->mark==0)
{
ptr=ptr->rchild;
code[index++]='1'; //右支路編碼為1
}
if(!ptr->lchild&&!ptr->rchild) //如果沒有左右孩子，即葉子結點
{
ptr->mark=1;
code[index++]='\0';
codedictionary[k].ch=ptr->ch; //給字典賦字元值
for(index=0;code[index]!='\0';index++)
codedictionary[k].code[index]=code[index];//給字典賦碼值
codedictionary[k].code[index]='\0';
k++;
ptr=tree;
index=0;
}
if(ptr->lchild->mark==1&&ptr->rchild->mark==1)//如果左右孩子都已標記
{
ptr->mark=1;
ptr=tree;
index=0;
}
}
}
printf("\n");
}
/**
*解碼，即將0-1碼轉化為字元串
*輸入：（哈夫曼結點指針）編碼樹的地址
* （字元型指針）要解碼的0-1字元串地址
* （字元型指針）解碼後的字元串地址
*返回：空
*/
void decodeHTree(LinkTree tree,char *code,char *filestring)
{
int i=0,j=0,k=0;
char *char0_1;
LinkTree ptr=tree;
char0_1=(char *)malloc(MAX_SINGLECODE_LEN); //此數組用於統計輸入的0-1序列
printf("預覽解壓後的字元：\n");
for(j=0,ptr=tree;code[i]!='\0'&&ptr->lchild&&ptr->rchild;j=0,ptr=tree)
{
for(j=0;code[i]!='\0'&&ptr->lchild&&ptr->rchild;j++,i++)
{
if(code[i]=='0')
{
ptr=ptr->lchild;
char0_1[j]='0';
}
if(code[i]=='1')
{
ptr=ptr->rchild;
char0_1[j]='1';
}
}
if(!ptr->lchild&&!ptr->rchild)
{
printf("%c",ptr->ch); //顯示解壓後的字元
filestring[k++]=ptr->ch; //將字元逐一保存到字元串里
}
if(code[i]=='\0'&&ptr->lchild&&ptr->rchild)
{
char0_1[j]='\0';
printf("\n沒有與最後的幾個0-1序列：%s相匹配的字元!\n",char0_1);
return;
}
}
printf("\n\n");
filestring[k]='\0';
free(char0_1);
}
⑧ java 裡面位操作符有哪些
java ~ 操作符，對每個二進制位的內容求反，即1變成0，0變成1
java & 操作符，對應的二內進制位進行容與操作，兩個都為1才為1，其他情況均為0
java | 操作符，對應的二進制位進行或操作，兩個都為0才為0，其他情況均為1
java ^ 操作符 當對應二進制位值相同，該位為0 否則為1
java << 操作符，左邊移動，右面填充0
java >> 操作符，左邊移動，右面填充0
⑨ java，位操作
減一啊~
反向操作嘛~
參考我以前回答過的問題